Essential Books

Designing and understanding how to retrieve realtime data from the Firebase Database

suggest change

This example assumes that you have already set up a Firebase Realtime Database. If you are a starter, then please inform yourself here on how to add Firebase to your Android project.

First, add the dependency of the Firebase Database to the app level build.gradle file: 

compile 'com.google.firebase:firebase-database:9.4.0'

Now, let us create a chat app which stores data into the Firebase Database.

Step 1: Create a class named Chat

Just create a class with some basic variables required for the chat: 

public class Chat{
    public String name, message;
}

Step 2: Create some JSON data

For sending/retrieving data to/from the Firebase Database, you need to use JSON. Let us assume that some chats are already stored at the root level in the database. The data of these chats could look like as follows: 

[
    {
        "name":"John Doe",
        "message":"My first Message"
    },
    {
        "name":"John Doe",
        "message":"Second Message"
    },
    {
        "name":"John Doe",
        "message":"Third Message"
    }
]

Step 3: Adding the listeners

There are three types of listeners. In the following example we are going to use the childEventListener: 

DatabaseReference chatDb = FirebaseDatabase.getInstance().getReference() // Referencing the root of the database.
        .child("chats"); // Referencing the "chats" node under the root.

chatDb.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String s) {
        // This function is called for every child id chat in this case, so using the above
        // example, this function is going to be called 3 times.
        
        // Retrieving the Chat object from this function is simple.
        Chat chat; // Create a null chat object.

        // Use the getValue function in the dataSnapshot and pass the object's class name to
        // which you want to convert and get data. In this case it is Chat.class.
        chat = dataSnapshot.getValue(Chat.class);

        // Now you can use this chat object and add it into an ArrayList or something like
        // that and show it in the recycler view.
    }

    @Override
    public void onChildChanged(DataSnapshot dataSnapshot, String s) {
        // This function is called when any of the node value is changed, dataSnapshot will
        // get the data with the key of the child, so you can swap the new value with the
        // old one in the ArrayList or something like that.

        // To get the key, use the .getKey() function.
        // To get the value, use code similar to the above one.
    }

    @Override
    public void onChildRemoved(DataSnapshot dataSnapshot) {
        // This function is called when any of the child node is removed. dataSnapshot will
        // get the data with the key of the child.

        // To get the key, use the s String parameter .
    }

    @Override
    public void onChildMoved(DataSnapshot dataSnapshot, String s) {
        // This function is called when any of the child nodes is moved to a different position.

        // To get the key, use the s String parameter.
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        // If anything goes wrong, this function is going to be called.

        // You can get the exception by using databaseError.toException();
    }
});

Step 4: Add data to the database

Just create a Chat class object and add the values as follows: 

Chat chat=new Chat();
chat.name="John Doe";
chat.message="First message from android";

Now get a reference to the chats node as done in the retrieving session: 

DatabaseReference chatDb = FirebaseDatabase.getInstance().getReference().child("chats");

Before you start adding data, keep in mind that you need one more deep reference since a chat node has several more nodes and adding a new chat means adding a new node containing the chat details. We can generate a new and unique name of the node using the push() function on the DatabaseReference object, which will return another DatabaseReference, which in turn points to a newly formed node to insert the chat data.

Example 

// The parameter is the chat object that was newly created a few lines above.
chatDb.push().setValue(chat);

The setValue() function will make sure that all of the application’s onDataChanged functions are getting called (including the same device), which happens to be the attached listener of the “chats” node.

Found a mistake? Have a question or improvement idea? Let me know.

Feedback about page:

Feedback:
Optional: your email if you want me to get back to you:

Firebase Realtime Database:
* Firebase Realtime DataBase
* Quick setup
* Firebase Realtime DataBase event handler
* Designing and understanding how to retrieve realtime data from the Firebase Database
* Denormalization Flat Database Structure
* Understanding firebase JSON database
* Retrieving data from firebase
* Listening for child updates
* Retrieving data with pagination
Table Of Contents
0 Getting Started
1 Layouts
2 Gradle
3 RecyclerView onClickListeners
4 NavigationView
5 Intent
6 JSON handling with org.json
7 Android Studio
8 Resources
9 Data Binding Library
10 Exceptions
11 Getting Calculated View Dimensions
12 AsyncTask
13 SharedPreferences
14 Emulator
15 Material Design
16 Lint Warnings
17 Service
18 Storing Files in Internal and External Storage
19 WebView
20 Project SDK versions
21 RecyclerView
22 Google Maps
23 PorterDuff Mode
24 9-Patch images
25 Android NDK
26 RecyclerView Decorations
27 Camera 2 API
28 ViewPager
29 CardView
30 HttpURLConnection
31 SQLite
32 ADB Android Debug Bridge
33 ButterKnife
34 Supporting different screen resolutions
35 Glide
36 Retrofit2
37 Dialog
38 ACRA
39 GreenDAO
40 Formatting Strings
41 Notifications
42 AlarmManager
43 Fragments
44 Handler
45 Creating Custom Views
46 BroadcastReceiver
47 Activity
48 Snackbar
49 Runtime Permissions in API-23
50 Logging and using Logcat
51 VectorDrawable and AnimatedVectorDrawable
52 Tools Attributes
53 Toast
54 Interfaces
55 Animators
56 Location
57 Theme Style Attribute
58 The Manifest File
59 Parcelable
60 MediaPlayer
61 Multidex and the Dex Method Limit
62 Data Synchronization with Sync Adapter
63 Menu
64 Instant Run in Android Studio
65 Picasso
66 Bluetooth LE API
67 RoboGuice
68 Memory Leaks
69 Universal Image Loader
70 Volley
71 Widgets
72 Date and Time Pickers
73 Integrate Google Sign In
74 In-app billing
75 FloatingActionButton
76 ContentProvider
77 Dagger 2
78 Realm
79 Unit testing in Android with JUnit
80 Android Versions
81 Wi-Fi Connections
82 SensorManager
83 Localization with resources
84 ProgressBar
85 Custom Fonts
86 Vibration
87 Google Awarness APIs
88 Text to Speech (TTS)
89 UI Lifecycle
90 Spinner
91 Data Encryption / Decryption
92 Testing UI with Espresso
93 Writing UI tests
94 GreenRobot EventBus
95 OkHttp
96 Enhancing Performance Using Icon Fonts
97 Handling Depp Links
98 Canvas drawing using SurfaceView
99 Firebase
100 Crash Reporting Tools
101 Check Internet Connectivity
102 Facebook SDK
103 Unzip File
104 Android Places API
105 Creating your own libraries
106 Handling JSON with Gson
107 Device Display Metrics
108 TextView
109 ListView
110 Building Backwards Compatible Apps
111 Loader
112 ProGuard - Obfuscating and Shrinking your code
113 Detect Shake Event
114 Typedef Annotations
115 Capturing Screenshots
116 MVP Architecture
117 Orientation Changes
118 Xposed
119 Security
120 PackageManager
121 ImageView
122 Gesture Detection
123 Doze Mode
124 Android Sound and Media
125 SearchView
126 Camera and Gallery
127 Callback URL
128 Twitter APIs
129 SqlCipher integration
130 Drawables
131 Colors
132 ConstraintLayout
133 RenderScript
134 Fresco
135 Swipe to Refresh
136 AutoCompleteTextView
137 Installing apps with ADB
138 IntentService
139 AdMob
140 Implicit Intents
141 Publish to Play Store
142 Firebase Realtime Database
143 Image Compression
144 Email Validation
145 Keyboard
146 Button
147 TextInputLayout
148 Bottom Sheets
149 CoordinatorLayout and Behaviors
150 EditText
151 Paypal Gateway Integration
152 Firebase App Indexing
153 Firebase Crash Reporting
154 Displaying Google Ads
155 Vk SDK
156 Localized DateTime
157 Count Down Timer
158 Reading Barcode and QR codes
159 Otto Event Bus
160 TransitionDrawable
161 Port Mapping using Cling
162 Creating Overlay always-on-top Windows
163 ExoPlayer
164 Inter-app UI testing with UIAutomator
165 MediaSession
166 Speech to Text Conversion
167 FileProvider
168 Publish .aar file to Apache Archive with Gradle
169 XMPP
170 Authenticator
171 RecyclerView and LayoutManagers
172 AudioManager
173 Job Scheduling
174 Accounts and AccountManager
175 OpenCV
176 Split Screen Multi-Screen Activities
177 Threads
178 MediaStore
179 Time Utils
180 Touch Events
181 Fingerprint API
182 MVVM Architecture
183 BottomNavigationView
184 ORMLite
185 YouTube API
186 TabLayout
187 Retrofit2 with RxJava
188 DayNight Theme AppCompat
189 ShortcutManager
190 LruCache
191 Using Jenkins CI
192 Zip files
193 Vector Drawables
194 Fastlane
195 Define step value for RangeSeekBar
196 Getting started with OpenGL ES 2.0
197 Check Data Connection
198 Java Native Interface (JNI)
199 FileIO
200 Perfomance Optimization
201 Robolectric
202 Moshi
203 Strick Mode Policy
204 Internalization and localization
205 Retrolambda
206 SparseArray
207 Firebase Cloud Messaging
208 Shared Element Transitions
209 Android Things
210 VideoView
211 ViewFlipper
212 Dependency Injection with Dagger 2
213 Formatting phone numbers
214 Storing password securely
215 Android Kernel Optimization
216 Paint
217 AudioTrack
218 ProGuard
219 Create Android Custom ROMs
220 Java on Android
221 Pagination in RecyclerVi
222 Genymotion for Android
223 Handling touch and motion events
224 Creating Splash screen
225 ConstraintSet
226 CleverTap
227 Publish library to Maven repositories
228 ADB shell
229 Ping ICMP
230 AIDL
231 Using Kotlin
232 Autosizing TextView
233 Signing apps for release
234 Context
235 Activity Recognition
236 Secure SharedPreferences
237 Secure SharedPreferences
238 Bitmap Cache
239 Android x86 in VirtualBox
240 JCodec
241 Design Patterns
242 Okio
243 Google SignIn integration
244 TensorFlow
245 Game developmen
246 Notification Channel
247 Bluetooth Low Energy (LE)
248 Leak Canary
249 FuseView
250 SQLite using ContentValues
251 Enhancing Alert Dialogs
252 Hardware Button Events, Intents PTT
253 SpannableString
254 Looper
255 Optimized VideoView
256 Google Drive API
257 Animated AlertDialog Box
258 Annotation Processor
259 SyncAdapter with periodically do sync of data
260 Singleton Class for Toast Message
261 Fastjson
262 Android Architecture Components
263 Jackson
264 Play Store
265 Loading Bitmaps Effectively
266 Getting system font names
267 Smartcard
268 Convert vietnamese string to english
269 Contributors