Come gestire nella architettura MVI gli eventi che…

Per gestire eventi unici (ad esempio, mostrare una toast, navigazione) in MVI, che non devono sopravvivere alla ricreazione della View o essere memorizzati nello stato, si utilizzano diversi approcci:

Effetti collaterali (SingleLiveEvent / Channels):

Meccanismo speciale per inviare eventi dal ViewModel alla View. SingleLiveEvent (in progetti vecchi o librerie come androidx.lifecycle:lifecycle-livedata-ktx), o Channel di Flow (in progetti moderni). Garantisce che l'evento venga consumato una sola volta.

// ViewModel con Flow e Channel
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.receiveAsFlow
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class MyViewModel : ViewModel() {

    private val _sideEffect = Channel<SideEffect>(Channel.BUFFERED)
    val sideEffect = _sideEffect.receiveAsFlow()

    fun doSomething() {
        // Logica di business...
        viewModelScope.launch {
            _sideEffect.send(SideEffect.ShowToast("Operazione riuscita!"))
        }
    }
}

sealed class SideEffect {
    data class ShowToast(val message: String) : SideEffect()
    object NavigateNext : SideEffect()
}

// Nella View (Fragment/Activity), osserviamo SideEffect
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch

class MyFragment : Fragment() {

    private val viewModel: MyViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        viewLifecycleOwner.lifecycleScope.launch {
            viewModel.sideEffect.collect { effect ->
                when (effect) {
                    is SideEffect.ShowToast -> showToast(effect.message)
                    SideEffect.NavigateNext -> navigateToNextScreen()
                }
            }
        }
    }

    private fun showToast(message: String) {
        // Implementazione per mostrare toast
    }

    private fun navigateToNextScreen() {
        // Implementazione per navigare
    }
}

Eventi a uso singolo nello stato:

È un metodo meno raccomandato, ma a volte viene usato in casi semplici. Si aggiunge una bandiera o un campo nello stato UiState che indica la presenza di un evento a uso singolo. Dopo aver elaborato l'evento, la View invia un nuovo Intent al ViewModel per resettare questa bandiera o campo nello stato. Questo può complicare la logica e portare a riattivazioni indesiderate in caso di gestione errata o ricreazione della View.

// Esempio di stato con bandiera a uso singolo
data class MyUiState(
    val data: List<Item> = emptyList(),
    val isLoading: Boolean = false,
    val showSuccessToast: Boolean = false // Bandiera per evento a uso singolo
)

// Nel ViewModel, dopo un'operazione riuscita
fun processSuccess() {
    _uiState.update { it.copy(showSuccessToast = true) }
}

// Nella View, quando si gestisce showSuccessToast = true
if (state.showSuccessToast) {
    showToast("Successo!")
    // Importante: inviare un Intent per resettare la bandiera
    viewModel.onToastShown()
}

// Nel ViewModel, per resettare la bandiera
fun onToastShown() {
    _uiState.update { it.copy(showSuccessToast = false) }
}

L'approccio più raccomandato in Android moderno con Flow e MVI è l'uso di Effetti collaterali tramite Channel. È una soluzione pulita, sicura e prevedibile per eventi a uso singolo.

Come gestire nella architettura MVI gli eventi che non devono essere salvati?