here any one access to view model will be able to modify this directly. Which live data i use this pattern

private val _quickLinks = MutableLiveData<List<UIQuickLink>>()
val quickLink: LiveData<List<UIQuickLink>> = _quickLinks

So that, quickLink access are only observed than posted with new values from UI, here update to quickLink happens from only view model

You can do the same for state, just expose a

State

instead of a

MutableState

using a second property. You could also do it with a function instead of a property

@f.babic, is this how we do it ? I understood your point, however some thing is missing, this isn't working

val _registeredUsers = mutableStateListOf<UIRegisteredUser>()

val registeredUser: State<UIRegisteredUser> = _registeredUsers

Is there a reason why you use

mutableStateListOf

instead of

mutableStateOf

? We're using the latter in our code and seems to work fine, haven't had issues per se.

private val _registeredUsers = mutableStateOf<List<UIRegisteredUser>>(value = listOf())
val registeredUser: State<List<UIRegisteredUser>> = _registeredUsers

This above appears to work , however following use case we are not able to accomplish with above approach, where as with mutableStateListOf() these worked fine, however, object became insecure

init {
    _registeredUsers.value.toMutableStateList().addAll(mockRegisteredUsers)
    
}

fun onUserSelected(user: UIRegisteredUser) {
    viewModelScope.coroutineContext.run {
        _registeredUsers.value.toMutableStateList().let { userList ->
            userList.find { it.isSelected }?.let {
                userList.indexOf(it).also { index ->
                    userList.remove(it)
                    userList.add(index, it.copy(isSelected = false))
                }
            }

            userList.find { it == user }?.let {
                userList.indexOf(it).also { index ->
                    userList.remove(it)
                    userList.add(index, it.copy(isSelected = true))
                }
            }
        }
    }
}

Oh okay that makes sense - in that case you'd come back to the same thing if you went that way. I mean, instead of:

_registeredUsers.value.toMutableStateList().addAll(mockRegisteredUsers)

You could have:

_registeredUsers.value = _registeredUsers.value + mockRegisteredUsers

Basically, instead of havign a mutable list that can be changed anywhere, you use immutable lists but make sure to add/remove items from the given list and producing a new list instead. That gives you control in the ViewModel of whatever you want to do, but the rest of the world won't be able to mutate incorrectly

@f.babic i got it working with your approach, so these are the changes,

This is because you're taking the list of items form the State, copying it and updating it in that instance. You should always push the new state/list to the property like:

_registeredUsers.value = newValue

when you mutate the list within those

find

calls, you need to make sure to push the new state to the UI

@f.babic sorry to bother you this way 😢 that didn't work either UI is observing from composable for registeredUser

SelectLoginUsersScreenContent(registeredUsers = loginViewModel.registeredUsers.value, onUserSelected = onUserSelected)

fun onUserSelected(user: UIRegisteredUser) {
    viewModelScope.coroutineContext.run {
        _registeredUsers.value.let { userList ->
            userList.find { it.isSelected }?.let {
                userList.indexOf(it).also { index ->
                    userList.remove(it)
                    userList.add(index, it.copy(isSelected = false))
                }
            }

            userList.find { it == user }?.let {
                userList.indexOf(it).also { index ->
                    userList.remove(it)
                    userList.add(index, it.copy(isSelected = true))
                }
            }
            _registeredUsers.value = userList
        }
    }
}

Could you try doing something like:

val registeredUsers by loginViewModel.registeredUsers

SelectLoginUsersScreenContent(registeredUsers = registeredUsers, onUserSelected = onUserSelected)

Basically the way we expose state in our VMs is the following:

private var threadMessagesState: MessagesState by mutableStateOf(MessagesState())

And then we just fetch it using an exposed property or something

val registeredUsers by loginViewModel.registeredUsers

SelectLoginUsersScreenContent(
    registeredUsers = registeredUsers,
    onUserSelected = onUserSelected
)

😭 didnt work @f.babic

Why can’t you just do this?

private val _registeredUsers = mutableStateListOf<UIRegisteredUser>()
val registeredUsers: List<UIRegisteredUser> = _registeredUsers

i need registeredUsers to trigger recomposing when value changes

Yep. As long as a snapshot state is read, even if not directly, it will trigger recomposition when it changes.

💥🥳