I have a `LiveData` of type `MutableLiveData<Mu...

# android

[nilTheDev]

I have a LiveData of type MutableLiveData<MutableList<User>>.

I have an issue.

If I update the value by another MutableList<User> the changes are emitted to the observers.

However, if I simply add other elements to the MutableList<User> , that is already initialised in the LiveData , the changes are not emitted.

Here is what I am doing...

//other codes 
private val _users: MutableLiveData<MutableList<User>> = MutableLiveData<MutableList<User>>()

init {
    _users.value = mutableListOf<User>()
}

val uiScope = CoroutineScope(Dispatchers.Main + Job())

fun loadUsers(){
    uiScope.launch{
        // this works perfectly
        _users.value = fetchUsers() as MutableList<User>
        // this doesn't work... no idea why
        _users.value.addAll(fetchUsers())
    }
}

suspend fun fetchUsers(): List<User>{
    return withContext(<http://Dispatchers.IO|Dispatchers.IO>){
        //fetch users asynchronously
    }
}

This is just an emulation of the actual program. That actual code is not that trivial.

[divid3d]

U need to use setValue() every time u want to dispatch new value to active observers. In second case you're doing nothing with the result. U could do something like:

val newUsers = _users.value.addAll(fetchUsers)
_users.value = newUsers

[nilTheDev]

@divid3d
_users.value = fetchUsers() does indeed call the setValue() . Maybe that's why it is working.

In the second case I am updating the MutableList<User> stored inside the LiveData. Does it have no effect because I am calling a suspend function?

I am no sure whether your code would even type-check.

val newUsers = _users.value.addAll(fetchUsers)
_users.value = newUsers

_users.value.addAll(fetchUsers()) would return a Boolean . And we can only store MutableList<User> inside _users.value.

[divid3d]

Oh right. So its should look something like:

val newUsers =_users.value.apply{
    addAll(fetchUsers)
}
_users.value = newUsers

[Aniket Kadam]

Mutations are always troublesome for a reactive state.
Try _users = _users.value + fetchedUsers
Which will create a new object and that should actually be detected as such and send the update.

[Adam Powell]

Agreed, this kind of setup is a bad habit to get into and will become a source of bugs down the road. Once you submit an object to be seen by observers you should stop mutating it.

[nilTheDev]

@divid3d @Aniket Kadam either of the solutions works. However, effectively it involves reassigning the whole object inside the LiveData . Why is it like that?

I have even tried this,

// inside viewModel
// _users is a MutableLiveData<MutableList<User>>
fun loadUsers(){
    
    val uiScope = CoroutineScope(Dispatchers.Main + Job())
 
    uiScope.launch{
        _users.value.add(User())
    }

}

But it doesn't emit the value.

In contrast, this code works,

// inside viewModel
// _users is a MutableLiveData<MutableList<User>>
fun loadUsers(){
    _users.value.add(User())
}

Why does it work this way? Apparently, LiveData doesn't notify the observers about the changes while done asynchronously, even if it is the main thread. But it works when it is synchronous.

[Adam Powell]

If observers are getting notified when you edit a list that way in your second example it's because you're getting lucky and some other side effect of your setup is responsible. LiveData has no way to observe changes to a list assigned to it.

[nilTheDev]

@Adam Powell @divid3d @Aniket Kadam thank you all for your help.