mutableStateListOf solo puede notificar sobre agregar/eliminar/reemplazar algún elemento en la lista. Cuando cambia cualquier clase dentro de la lista, el estado mutable no puede saberlo.

Las clases de datos son muy buenas para almacenar el estado inmutable en el flujo de datos unidireccional, porque siempre puede "cambiarlo" con copy , mientras ve la necesidad de pasar los nuevos datos a la vista o al estado mutable. Por lo tanto, evite usar variables var con clases de datos, siempre declárelas como val para evitar tales errores.

 var childTravellersList = mutableStateListOf<TravellersDetails>() fun update(index){ childTravellersList[index] = childTravellersList[index].copy(error = true) }

Otro problema es que está usando val list = remember{viewModel.childTravellersList} : guarda el primer valor de la lista y evita actualizaciones en el futuro. Con ViewModel puedes usarlo directamente itemsIndexed(viewModel.childTravellersList)

La recomposición ocurrirá solo cuando cambie la lista en sí. Puedes hacerlo así.

 var childTravellersList by mutableStateOf(emptyList<TravellersDetails>()) fun update(indexToUpdate: Int) { childTravellersList = childTravellersList.mapIndexed { index, details -> if(indexToUpdate == index) details.copy(error = true) else details } }

Además, no necesita recordar esta lista en su componible como lo ha hecho aquí val list = remember{viewModel.childTravellersList} . Dado que MutableState es un modelo de vista interna, siempre sobrevivirá a todas las recomposiciones. Simplemente use viewModel.childTravellersList dentro de LazyColumn.

Use un único mecanismo de activación para actualizar su componible. Su lista debería estar disponible como una variable normal. Puede agregar/eliminar/eliminar elementos de la lista e incluso actualizar las propiedades de cada elemento. Una vez que realice estas actualizaciones en la lista, puede recomponer su componible generando un número aleatorio que está vinculado a un estado mutable observable que se observa en su componible:

Kotlin:

 class MyViewModel: ViewModel() { var childTravellersList = mutableListOf<TravellersDetails>() var onUpdate = mutableStateOf(0) private fun updateUI() { onUpdate.value = (0..1_000_000).random() } fun update(index){ childTravellersList[index].error = true updateUI() } } @Composable fun MyComposableHandler() { // This will detect any changes to data and recompose your composable. viewmodel.onUpdate.value MyComposable( travelersList = viewmodel.childTravellersList ) } @Composable fun MyComposable( travelersList: List<TravellersDetails> ) { }

Debe evitar crear múltiples variables de estado mutables en su modelo de vista para diferentes variables que necesitan actualización. No hay absolutamente ninguna necesidad de hacer esto. Simplemente cree una sola variable de estado mutable, como se muestra arriba. Siempre que necesite recomponer su componible, simplemente actualice la función UI. La lógica en su modelo de vista debe decidir qué debe actualizarse, pero dejar el mecanismo de actualización real en un solo estado mutable observable. Este es un patrón limpio y hará que actualizar tus componibles sea mucho más fácil.

Sin embargo, tenga en cuenta que su interfaz de usuario normalmente estará compuesta por muchos componibles en una jerarquía. No desea recomponer toda la jerarquía cuando solo cambia un elemento. Por esa razón, se debe usar un observable de estado mutable para cada componible que deba recomponerse independientemente de los demás en la jerarquía.

El otro beneficio de usar la solución que se muestra arriba es que puede actualizar objetos fácilmente sin necesidad de crear nuevos objetos. Si desea que su componible se recomponga cuando solo cambia una determinada propiedad del objeto, no puede usar un estado mutable observable porque solo detecta cambios en el objeto en sí y NO en las propiedades del objeto. Esta es la razón por la que es mejor usar el método de activación que se muestra arriba y simplemente recuperar el objeto actualizado cuando el componible se recompone.