Theory
Data પાછો મેળવવો
Data write કરવું માત્ર અડધું કામ છે; FestConnectએ events અને registrations read કરીને screen પર બતાવવા જોઈએ. Realtime Databaseમાંથી read કરવા reference પર listener attach કરો. Databaseનું real-time nature અહીં દેખાય છે: listener UIને live રાખી શકે છે અને data બદલાય ત્યારે આપમેળે update કરી શકે છે.
આ lessonમાં બે listener types, live અને once, DataSnapshotમાંથી data કાઢવાની રીત અને listeners detach કરવાની habit શીખશો. સારી રીતે read કરવાથી app connected અને current લાગે છે.
Theory
Listen કરવાની બે રીત
Reference પર listener attach કરતી વખતે નક્કી કરો કે તે કેટલો સમય રહે.
addValueEventListener એક persistent listener attach કરે છે. તે હાલના data સાથે તરત fire થાય છે અને પછી data બદલાય ત્યારે દરેક વખતે ફરી fire થાય છે. Latest state હંમેશા બતાવતી list માટે આ live view યોગ્ય છે.
addListenerForSingleValueEvent data માત્ર એક વાર વાંચે છે અને પછી detach થઈ જાય છે. Live updatesની જરૂર ન હોય તેવા one-off fetch માટે તેનો ઉપયોગ કરો.
બંને રીતે data listenerના onDataChange callbackમાં DataSnapshot તરીકે આવે છે અને failures onCancelledમાં આવે છે. Live UI માટે persistent listener અને quick read માટે single-value listener પસંદ કરો.
Practical
Value listenerથી list read કરવી
val eventsRef = FirebaseDatabase.getInstance().getReference("events")
eventsRef.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val events = mutableListOf<String>()
for (child in snapshot.children) { // loop the list items
val name = child.child("name").getValue(String::class.java)
if (name != null) events.add(name)
}
showEvents(events) // update the UI (e.g. a RecyclerView)
}
override fun onCancelled(error: DatabaseError) { /* handle failure */ }
})
// Fires now with current data, and again on every change: a live list.Formula
જરૂર ન હોય ત્યારે listener detach કરો
Persistent value listener remove ન કરો ત્યાં સુધી updates લેતો રહે છે. Screen બંધ થયા પછી પણ listener attach રહે તો તે callbacks fire કરતો રહી શકે છે, resources વેડફાઈ શકે છે અને dead UI update કરવાથી memory leak અથવા crashનું risk રહે છે.
Habit બનાવો: screen visible થાય ત્યારે, જેમ કે onStartમાં, listener attach કરો અને screen visible ન રહે ત્યારે, જેમ કે onStopમાં, removeEventListener કરો. Single-value listener એક read પછી પોતે detach થઈ જાય છે, તેથી તેને cleanupની જરૂર નથી. Live listenersનું lifecycle manage કરશો તો app efficient અને stable રહેશે.
Quiz
FestConnectની listમાં latest events હંમેશા દેખાવા જોઈએ અને data બદલાય ત્યારે list આપમેળે update થવી જોઈએ. કઈ approach યોગ્ય છે?
- addListenerForSingleValueEvent, કારણ કે તે એક વાર read કરે છે
- addValueEventListener, જે current data સાથે તરત અને દરેક change વખતે ફરી fire થાય છે
- setValue, કારણ કે તે data read કરે છે
- કોઈ listener નહીં; data guess કરો
Show the answer
addValueEventListener, જે current data સાથે તરત અને દરેક change વખતે ફરી fire થાય છે
addValueEventListener persistent listener attach કરે છે. તે current data તરત આપે છે અને દરેક change વખતે ફરી fire થાય છે, તેથી events list live અને automatically updated રહે છે. Option A, addListenerForSingleValueEvent, data માત્ર ONCE read કરીને detach થાય છે; તેથી events બદલાય ત્યારે list update નહીં થાય. તે one-off fetch માટે યોગ્ય છે. Option C, setValue, data WRITE કરે છે; read નથી કરતું. Option D અર્થહીન છે. Live auto-updating UI માટે value-event listener વાપરો અને screen દૂર થાય ત્યારે તેને detach કરવાનું યાદ રાખો.
Think first
Connected app માટે live listener શક્તિશાળી કેમ છે?
One-time read સરળ છે. Persistent value listener વારંવાર ફરી fetch કરવાથી શું વધારે આપે છે? પછી tap.
Show the answer
તે polling વગર AUTOMATICALLY CURRENT UI આપે છે. Database change થાય ત્યારે Realtime Database appને push કરે છે, એટલે user refresh કર્યા વગર latest state જોઈ શકે છે.
માનો FestConnect કોઈ event માટે remaining seats બતાવે છે. One-time readથી screen '5 seats left' બતાવતી રહી શકે છે, જ્યારે seats પૂરી થઈ ગઈ હોય. Fresh રાખવા માટે appએ દર થોડા secondsે POLL કરવું પડે, જેમાં સતત requests થાય અને મોટા ભાગે કોઈ change ન હોય; છતાં data થોડું મોડું મળે. Persistent value listenerમાં એક વાર subscribe કરો અને databaseમાં change થાય ત્યારે onDataChange callback fire થાય છે. એક student register કરે અને count ઘટે ત્યારે દરેક listening device તરત update થઈ શકે છે.
આ real-time databaseની core strength છે: chats તરત દેખાય, dashboardsના numbers બદલાય, lists data update થતાં reorder થાય. Cost એ છે કે persistent listeners connection અને resources વાપરે છે અને જરૂર ન હોય ત્યારે detach કરવા પડે છે. પરંતુ જ્યાં freshness મહત્વની હોય ત્યાં live listener clumsy pollingને push-based syncingથી બદલે છે. એક વાર subscribe કરો અને UI પોતે current રહે છે.
Summary
Key takeaways
- Realtime Databaseમાંથી read કરવા DatabaseReference પર listener attach કરો.
- addValueEventListener current data સાથે તરત fire થાય છે અને દરેક change વખતે ફરી fire થઈને live view આપે છે.
- addListenerForSingleValueEvent data એક વાર વાંચે છે અને પછી detach થઈ જાય છે.
- Data onDataChangeમાં DataSnapshot તરીકે આવે છે; getValue(Type) વાપરો અથવા list માટે snapshot.children loop કરો.
- Failures onCancelledમાં આવે છે.
- Screen દૂર થાય ત્યારે persistent listener removeEventListenerથી detach કરો; સામાન્ય રીતે onStopમાં cleanup કરો.
- Memory hook: live auto-updating list માટે value listener, one-time read માટે single-value listener; live listener જરૂર પૂરી થાય ત્યારે detach કરો.