UI is not updated when DB changes

Issue

I'm writing an application using the Android Architecture Components, originally based on the famous article, however that is now outdated and not accurate, so based on other documentation, articles and videos, I build something using the latest components, which turned out in a very simple architecture with very little code.

The idea is the app starts with its tables empty, and goes to read from a Firestore db to get its data, stores the data in a local SqlLite DB (using Room) and displays the updated data. Whenever the data is updated on Firestore, it should be updated in SqlLite and update the UI.

However, my UI (just a text box for now) is only updated when the application starts, and never ever after the DB is modified.

PorteroDao

package com.sarcobjects.portero.db

import androidx.room.*
import com.sarcobjects.portero.entities.Portero
import com.sarcobjects.portero.entities.PorteroWithLevelsAndUnits

@Dao
abstract class PorteroDao {

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    abstract suspend fun insert(portero: Portero): Long

    @Transaction
    @Query("SELECT * FROM Portero WHERE porteroId == :porteroId")
    abstract suspend fun getPortero(porteroId: Long): PorteroWithLevelsAndUnits
}

PorteroRepository

package com.sarcobjects.portero.repository

import com.google.firebase.firestore.DocumentSnapshot
import com.google.firebase.firestore.EventListener
import com.google.firebase.firestore.FirebaseFirestore
import com.sarcobjects.portero.db.PorteroDao
import com.sarcobjects.portero.entities.Portero
import com.sarcobjects.portero.entities.PorteroWithLevelsAndUnits
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.launch
import timber.log.Timber.d
import timber.log.Timber.w
import java.util.concurrent.TimeUnit
import javax.inject.Inject
import javax.inject.Singleton

@Singleton
class PorteroRepository @Inject constructor(
    private val porteroDao: PorteroDao,
    private val firestore: FirebaseFirestore
) {

    @ExperimentalCoroutinesApi
    suspend fun getPortero(porteroId: Long): PorteroWithLevelsAndUnits {
        GlobalScope.launch {refreshPortero(porteroId)}
        val portero = porteroDao.getPortero(porteroId)
        d("Retrieved portero: $portero")
        return portero
    }

    @ExperimentalCoroutinesApi
    private suspend fun refreshPortero(porteroId: Long) {
        d("Refreshing")
        //retrieve from firestore
        retrieveFromFirestore(porteroId)
            .collect { portero ->
                d("Retrieved and collected: $portero")
                porteroDao.insert(portero)
            }
    }

    @ExperimentalCoroutinesApi
    private fun retrieveFromFirestore(porteroId: Long): Flow<Portero> = callbackFlow {
        val callback = EventListener<DocumentSnapshot> { document, e ->
            if (e != null) {
                w(e, "Listen from Firestore failed.")
                close(e)
            }
            d("Read successfully from Firestore")
            if (document != null && document.exists()) {
                //Convert to objects
                val portero = document.toObject(Portero::class.java)
                d("New Portero: ${portero.toString()}")
                offer(portero!!)
            } else {
                d("Portero not found for porteroId: $porteroId")
            }
        }
        val addSnapshotListener = firestore.collection("portero").document(porteroId.toString())
            .addSnapshotListener(callback)
        awaitClose { addSnapshotListener.remove()}
    }
}

ButtonsViewModel

package com.sarcobjects.portero.ui.buttons

import androidx.hilt.Assisted
import androidx.hilt.lifecycle.ViewModelInject
import androidx.lifecycle.LiveData
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.liveData
import com.sarcobjects.portero.entities.PorteroWithLevelsAndUnits
import com.sarcobjects.portero.repository.PorteroRepository
import timber.log.Timber.d


class ButtonsViewModel @ViewModelInject
constructor(@Assisted savedStateHandle: SavedStateHandle, porteroRepository: PorteroRepository) : ViewModel() {

    private val porteroId: Long = savedStateHandle["porteroId"] ?: 0
    val portero: LiveData<PorteroWithLevelsAndUnits> = liveData {
        val data = porteroRepository.getPortero(porteroId)
        d("Creating LiveData with: $data")
        emit(data)
    }
}

ButtonsFragment

package com.sarcobjects.portero.ui.buttons

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.Observer
import com.sarcobjects.portero.R
import com.sarcobjects.portero.entities.PorteroWithLevelsAndUnits
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.android.synthetic.main.buttons_fragment.*
import timber.log.Timber.d

@AndroidEntryPoint
class ButtonsFragment : Fragment() {

    companion object {
        fun newInstance() = ButtonsFragment()
    }

    private val viewModel: ButtonsViewModel by viewModels (
    )

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.buttons_fragment, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewModel.portero.observe(viewLifecycleOwner, Observer<PorteroWithLevelsAndUnits> {porteroWLAU ->
            d("Observing portero: $porteroWLAU")
            message.text = porteroWLAU?.portero?.name ?: "Portero not found."
        })

    }
}

All the dependency injection seems to be OK (no NPEs), I even checked that the ViewModel instance is the same on the Fragment and in the ViewModel itself, and the persistence via Room is correct; the new data is actually being saved into SqlLite when I update Firestore. Also, no exceptions or errors in logcat. But the UI is not updated.

Solution

So, I managed to find a way to make this work, although in a different way. My idea was to make Room trigger a liveData reload whenever I wrote to SqlLite, but I never managed to make it work, and still I don't know why.

What I did in the end was:

Return a Flow from the repository, triggered by the updates in Firestore:

    @ExperimentalCoroutinesApi
    fun getPorteroFlow(porteroId: Long): Flow<Portero> = retrieveFromFirestore(porteroId)

    @ExperimentalCoroutinesApi
    private fun retrieveFromFirestore(porteroId: Long): Flow<Portero> = callbackFlow {
        val callback = EventListener<DocumentSnapshot> { document, e ->
            if (e != null) {
                w(e, "Listen from Firestore failed.")
                return@EventListener
            }
            d("Read successfully from Firestore")
            if (document != null && document.exists()) {
                //Convert to objects
                val portero = document.toObject(Portero::class.java)
                d("New Portero: ${portero.toString()}")
                GlobalScope.launch {
                    d("Saved new portero: $portero")
                    porteroDao.insert(portero!!)
                }
                offer(portero!!)
            } else {
                d("Portero not found for porteroId: $porteroId")
            }
        }
        val addSnapshotListener = firestore.collection("portero").document(porteroId.toString()) //.get()
            .addSnapshotListener(callback)
        awaitClose { addSnapshotListener.remove()}
    }

Convert the Flow to liveData in the ViewModel:

    private val porteroId: Long = savedStateHandle["porteroId"] ?: 0
    @ExperimentalCoroutinesApi
    val portero = porteroRepository.getPorteroFlow(porteroId)
        .onStart { porteroRepository.getPortero(porteroId) }
        .asLiveData()
}

(onStart is used to read data from SqlLite when the app starts, in case there's no internet and Firestore is unreachable).

This works flawlessly and is very fast, as soon as I update data in Firestore console, I can see the UI update in the device.

Answered By - Alex