Is there any difference between ``` val devices = remember m

Question

Is there any difference between ``` val devices = remember mutableStateListOf lt DeviceModel gt LaunchedEffect subject = viewModel devices block = viewModel devices collect model gt if devices contains model devices add model ``` and ``` val devices by produceState initialValue = mutableStateListOf lt DeviceModel gt viewModel viewModel devices collect model gt if value contains model value add model ```

allan.conda · Answer

check the source and you ll see how it s different

allan.conda · Answer

second one only runs a LaunchedEffect once per composition even if devices state changed it seems

Lilly · Answer

woman facepalming my bad

Lilly · Answer

< allan conda> Are you aware of an elegant way to only have unique objects in the `mutableStateList`

Dominaezzz · Answer

The second one is slightly less efficient Or at least add a bit of unnecessary complexity

Dominaezzz · Answer

Because you never change the state object

Dominaezzz · Answer

Consider using `List lt DeviceModel gt ` for the second case then they become more comparable

Adam Powell · Answer

or `PersistentList` I think `MutableStateList` uses the persistent collections under the hood

Dominaezzz · Answer

To keep the objects unique you can use a `LinkedHashSet`

Lilly · Answer

Thanks guys < Dominaezzz> < Adam Powell> When I use `linkedSetOf` or `mutableListOf` for second snippt no items are shown which makes sense because I don t do `value = device` so `devices` doesn t change but when I use `mutableStateListOf` and do `value add device ` `devices` changed Or am I wrong Btw it seems that `PersistentList` doesn t exist same for `MutableStateList`

Adam Powell · Answer

PersistentList comes from the kotlinx collections immutable artifact by MutableStateList I mean the object returned by mutableStateListOf The analogy here is `var list = mutableListOf ` you don t need both the list and the reference to the list to be mutable

Adam Powell · Answer

Pick one `produceState` is about that leading `var`

Adam Powell · Answer

Your first snippet is about the collection being mutable but the reference to it immutable probably what you want here

Lilly · Answer

Waht do you mean with gt `produceState` is about that leading `var`

Adam Powell · Answer

`produceState` is just a convenience around ```val state = remember mutableStateOf initialValue LaunchedEffect state block return state```

Adam Powell · Answer

It gives you one observable mutable variable that the provided block feeds

Adam Powell · Answer

But you don t want one observable mutable value you want one observable mutable list

Lilly · Answer

ok I guess I got it In second snippet both the list and the reference is mutable

Adam Powell · Answer

Yep

Lilly · Answer

The first one fits definetely better here slightly smiling face

Adam Powell · Answer

I think so too slightly smiling face

Lilly · Answer

But I still have the problem with duplicates confused

Adam Powell · Answer

we ve only got `mutableStateListOf` and `mutableStateMapOf` for snapshot observable collections at the moment we don t have a set If you combine `PersistentSet` from kotlinx collections immutable and `produceState` from compose you should have what you need

Adam Powell · Answer

which is to say `PersistentSet` is an efficient immutable set type that potentially returns a new set instance whenever you add or remove from it and if you store that reference in a `mutableStateOf` holder you get the observability you need with an efficient immutable set implementation

Lilly · Answer

< Adam Powell> Couldn t I also add the device directly to the LazyColumn instead of adding it to a list set first thinking face

Adam Powell · Answer

a LazyColumn and any composable function really just reads from state you supply Once this patch lands you can use any backing state type you like but there will still be no concept of adding to a data structure private to owned by LazyColumn itself <https android review googlesource com c platform frameworks support + 1530327>

Lilly · Answer

< Adam Powell> Alright thanks Lets say a device is collected which is already in list set but I would like to replace the new one with the existing one because the new one has updates fields how would you achieve this

Lilly · Answer

I could remove the existing one and add the new one but this would trigger recompose twice or

Adam Powell · Answer

When you add or remove from a persistent collection it returns a new immutable collection instance that copies as little as possible from the original while sharing internal structure Once you perform the manipulation you need assign the new collection to a MutableState object once

Adam Powell · Answer

Either way though if you want to perform several snapshot state updates atomically with regard to one another see `withMutableSnapshot` Any changes you make within an explicit mutable snapshot all happen together or not at all and changes aren t made visible to other threads unless you commit all changes together or otherwise pass the snapshot between threads explicitly

Adam Powell · Answer

Compose will only recompose for full snapshot commits not for partial snapshots

Lilly · Answer

I still get duplicates ``` val devices = remember mutableStateOf persistentListOf lt DeviceModel gt LaunchedEffect subject = viewModel deviceFlow block = viewModel deviceFlow collect model gt if devices value contains model devices value = devices value add model BluetoothDeviceListComponent devices value onConnectDevice ``` What do I wrong

Dominaezzz · Answer

Does `DeviceModel` have an `equals` implementation

Lilly · Answer

```data class DeviceModel val bluetoothDevice BluetoothDevice val rssi Int ``` data classes generate equals functions right

Adam Powell · Answer

They do so if the rssi keeps changing they aren t equal and it will look like a new object to that code slightly smiling face

Adam Powell · Answer

Remove the element with the same unique id or use a map with the unique id as the key

Lilly · Answer

< Dominaezzz> Thanks for the hint To just get rid of the duplicates I only had to override the equals function ``` data class BluetoothDeviceModel val bluetoothDevice BluetoothDevice val rssi Int override fun equals other Any Boolean if other is BluetoothDeviceModel return this bluetoothDevice address == other bluetoothDevice address return false ``` Additionally when I want to update the list with newer devices there are multiple options To preserve the order of the items I came up with this solution ``` val devices = remember mutableStateListOf lt DiscoverBluetoothDevicesUseCase BluetoothDeviceModel gt LaunchedEffect subject = viewModel deviceFlow block = viewModel deviceFlow collect model gt withMutableSnapshot devices indexOf model takeIf it = 1 let i gt devices remove devices i devices add i model devices add model ``` < Adam Powell> Is this implementation legit regarding performance and do I use `withMutableSnapshot` properly

Adam Powell · Answer

That ll do fine