My first observer called correctly but another was not called after inserted data to room database in kotlin android

Issue

In the application, I am fetching data from the web and from the observer change method, Insert that data to local db. that's fine. but after inserted to db, My second observer not called so my UI will not update.

ManActivity.class

class MainActivity : AppCompatActivity() {

    private lateinit var viewModel: MainViewModel
    private lateinit var adapter: MainAdapter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(layout.activity_main)
        setupViewModel()
        setupUI()
        setupObservers()
        setupObservers2()
    }


    private fun setupViewModel() {
        viewModel = ViewModelProviders.of(
            this,
            ViewModelFactory(ApiHelper(RetrofitBuilder.apiService))
        ).get(MainViewModel::class.java)
    }

    private fun setupUI() {
        recyclerView.layoutManager = LinearLayoutManager(this)
        adapter = MainAdapter(arrayListOf())
        recyclerView.addItemDecoration(
            DividerItemDecoration(
                recyclerView.context,
                (recyclerView.layoutManager as LinearLayoutManager).orientation
            )
        )
        recyclerView.adapter = adapter
    }

    private fun setupObservers() {
        viewModel.getUsers().observe(this, Observer {

            //viewModel.getUserFromWeb()
            it?.let { resource ->
               when (resource.status) {
                    SUCCESS -> {
                        Log.d("MYLOG","MyAPIChange success")
                        recyclerView.visibility = View.VISIBLE
                        progressBar.visibility = View.GONE
                        resource.data?.let {

                               users ->  viewModel.setUserListToDB(this,users)
                               //sleep(1000)
                           }

                    }
                    ERROR -> {
                        recyclerView.visibility = View.VISIBLE
                        progressBar.visibility = View.GONE
                        Log.d("MYLOG","MyAPIChange error")
                        Toast.makeText(this, it.message, Toast.LENGTH_LONG).show()
                    }
                    LOADING -> {
                        Log.d("MYLOG","MyAPIChange loading")
                        progressBar.visibility = View.VISIBLE
                        recyclerView.visibility = View.GONE
                    }
                }
            }
        })

    }

    private fun setupObservers2() {
        viewModel.getUserFromDB(this).observe(this, Observer {
                users -> retrieveList(users)
            Log.d("MYLOG","..MyDBChange")
        })
    }

    private fun retrieveList(users: List<User>) {
        adapter.apply {
            addUsers(users)
            notifyDataSetChanged()
        }
    }
}

MyViewModel.class

class MainViewModel(private val mainRepository: MainRepository) : ViewModel() {

    //lateinit var tempUser : MutableLiveData<List<User>>
    fun getUsers() = liveData(Dispatchers.IO) {
        emit(Resource.loading(data = null))
        try {
            emit(Resource.success(data = mainRepository.getUsers()))
        } catch (exception: Exception) {
            emit(Resource.error(data = null, message = exception.message ?: "Error Occurred!"))
        }
        //emit(mainRepository.getUsers())   //direct call
    }

    fun getUserFromDB(context: Context) = liveData(Dispatchers.IO) {
        emit(mainRepository.getUserList(context))
    }

    fun setUserListToDB(context: Context, userList: List<User>) {

        /*GlobalScope.launch {
            mainRepository.setUserList(context, userList)
        }*/

        CoroutineScope(Dispatchers.IO).launch {
            mainRepository.setUserList(context, userList)
        }

    }
}

MyRepository.class

class MainRepository(private val apiHelper: ApiHelper) {

    suspend fun getUsers() = apiHelper.getUsers()    // get from web

    companion object {

        var myDatabase: MyDatabase? = null

        lateinit var userList: List<User>

        fun initializeDB(context: Context): MyDatabase {
            return MyDatabase.getDataseClient(context)
        }

        /*fun insertData(context: Context, username: String, password: String) {

            myDatabase = initializeDB(context)

            CoroutineScope(Dispatchers.IO).launch {
                val loginDetails = User(username, password)
                myDatabase!!.myDao().InsertData(loginDetails)
            }

        }*/
    }
    //fun getUserList(context: Context, username: String) : LiveData<LoginTableModel>? {

    suspend fun getUserList(context: Context) : List<User> {

        myDatabase = initializeDB(context)
        userList = myDatabase!!.myDao().getUserList()
        Log.d("MYLOG=", "DBREAD"+userList.size.toString())


         return userList
    }

    fun setUserList(context: Context,userList: List<User>){

        myDatabase = initializeDB(context)

        /*CoroutineScope(Dispatchers.IO).launch {
            myDatabase!!.myDao().InsertAllUser(userList)
            Log.d("MYLOG","MyDBInserted")
        }*/
        myDatabase!!.myDao().InsertAllUser(userList)
        Log.d("MYLOG","MyDBInserted")
        /*val thread = Thread {
            myDatabase!!.myDao().InsertAllUser(userList)
        }
        Log.d("MYLOG","MyDBInserted")
        thread.start()*/
    }
}

DAO class

@Dao
interface DAOAccess {

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun InsertAllUser(userList: List<User>)

//    @Query("SELECT * FROM User WHERE Username =:username")
//    fun getLoginDetails(username: String?) : LiveData<LoginTableModel>

    @Query("SELECT * FROM User")
    suspend fun getUserList() : List<User>
}

RetrofitBuilder

object RetrofitBuilder {

    private const val BASE_URL = "https://5e510330f2c0d300147c034c.mockapi.io/"

    private fun getRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    val apiService: ApiService = getRetrofit().create(ApiService::class.java)
}

Please can you know that what I am doing wrong here and why the second observer was not called after insert to db

Actually It was called when the screen launched but that time data not inserted so list size was 0 and after insert data this method will not call again. But Once I close app and again start then data will display bcoz at launch time, this method call and data got

Solution

I don't have enough reputation to commet, therefore I just bring a suggestion in this answer:

Suggestion/Solution

Room supports LiveData out of the box. So in your DAO you can change

suspend fun getUserList() : List<User>

to

suspend fun getUserList() : LiveData<List<User>>

Then in your repository adjust to

suspend fun getUserList(context: Context) : LiveData<List<User>> {

        myDatabase = initializeDB(context)
        userList = myDatabase!!.myDao().getUserList()
        Log.d("MYLOG=", "DBREAD"+userList.value.size.toString())


         return userList
    }

and in the ViewModel

fun getUserFromDB(context: Context) = mainRepository.getUserList(context))
    

With these adjustments I think it should work.

Explaination

You used the liveData couroutines builder here

fun getUserFromDB(context: Context) = liveData(Dispatchers.IO) {
        emit(mainRepository.getUserList(context))
    }

As far as I understand this builder, it is meant to execute some asynchronous/suspend task and as soon as this task finishes the liveData you created will emit the result. That means that you only once receive the state of the user list an emidiately emit the list to the observer one single time and then this liveData is done. It does not observe changes to the list in the DB the whole time.

That is why it works perfectly for observing the API call (you want to wait until the call is finished and emit the response one single time), but not for observing the DB state(you want to observe the user list in the DB all the time and emit changes to the observer whenever the list is changed)

Answered By - Erik Schmidt