Comment peut-on implémenter différents états dans une application Android en utilisant des classes scellées?

Les classes scellées sont idéales pour modéliser un ensemble fini d'états. Chaque état secondaire peut contenir ses propres données uniques.

Exemple:

sealed class UiState {
    object Loading : UiState() // État de chargement sans données
    data class Success(val data: List<Item>) : UiState() // État réussi avec données reçues
    data class Error(val message: String) : UiState() // État d'erreur avec message

    object Idle : UiState() // État initial ou neutre
}

Application:

• Dans ViewModel, on peut mettre à jour MutableStateFlow (ou un autre type observable) avec le UiState actuel.
• Dans Fragment ou Activity, s'abonner aux changements de UiState et utiliser when pour gérer chaque état possible, en mettant à jour l'UI en conséquence.

// Dans ViewModel
class MyViewModel : ViewModel() {
    private val _uiState = MutableStateFlow<UiState>(UiState.Idle)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            try {
                val result = fetchData() // Votre fonction pour obtenir des données
                _uiState.value = UiState.Success(result)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Erreur inconnue")
            }
        }
    }
}

// Dans Fragment/Activity (en utilisant Compose)
@Composable
fun MyScreen(viewModel: MyViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsState()

    when (uiState) {
        UiState.Idle -> { /* Afficher l'écran initial */ }
        UiState.Loading -> { /* Afficher l'indicateur de chargement */ }
        is UiState.Success -> {
            val data = (uiState as UiState.Success).data
            // Afficher les données
        }
        is UiState.Error -> {
            val errorMessage = (uiState as UiState.Error).message
            // Afficher le message d'erreur
        }
    }
}

Avantages:

• Vérification exhaustive: Le compilateur exige de gérer toutes les sous-classes de la classe scellée dans l'expression when. Cela empêche les omissions et augmente la fiabilité du code.
• Modélisation claire des états: Définit explicitement tous les états possibles du composant UI.
• Sécurité de type: Chaque état a ses propres données, accessibles en toute sécurité sans besoin de cast.
• Meilleure lisibilité: Le code utilisant des classes scellées pour les états est plus compréhensible et facile à maintenir.

Cette approche est particulièrement utile avec Flow et Compose, mais fonctionne également bien avec LiveData et View Binding.