¿Cómo se pueden implementar diferentes estados en una…

Las clases selladas son ideales para modelar un conjunto finito de estados. Cada estado secundario puede contener sus propios datos únicos.

Ejemplo:

sealed class UiState {
    object Loading : UiState() // Estado de carga sin datos
    data class Success(val data: List<Item>) : UiState() // Estado exitoso con datos recibidos
    data class Error(val message: String) : UiState() // Estado de error con mensaje

    object Idle : UiState() // Estado inicial o neutral
}

Aplicación:

En ViewModel se puede actualizar MutableStateFlow (u otro tipo observable) con el UiState actual.
En Fragment o Activity, suscribirse a los cambios en UiState y usar when para manejar cada estado posible, actualizando la UI en consecuencia.

// En 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() // Tu función para obtener datos
                _uiState.value = UiState.Success(result)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Error desconocido")
            }
        }
    }
}

// En Fragmento/Actividad (usando Compose)
@Composable
fun MyScreen(viewModel: MyViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsState()

    when (uiState) {
        UiState.Idle -> { /* Mostrar pantalla inicial */ }
        UiState.Loading -> { /* Mostrar indicador de carga */ }
        is UiState.Success -> {
            val data = (uiState as UiState.Success).data
            // Mostrar datos de data
        }
        is UiState.Error -> {
            val errorMessage = (uiState as UiState.Error).message
            // Mostrar mensaje de error
        }
    }
}

Ventajas:

Verificación exhaustiva: El compilador requiere manejar todas las subclases de la clase sellada en la expresión when. Esto previene omisiones y aumenta la fiabilidad del código.
Modelado claro de estados: Define explícitamente todos los estados posibles del componente UI.
Seguridad de tipos: Cada estado tiene sus propios datos, accesibles de forma segura sin necesidad de casting.
Mejor legibilidad: El código que usa clases selladas para estados es más comprensible y fácil de mantener.

Este enfoque es especialmente útil con Flow y Compose, pero también funciona bien con LiveData y View Binding.

¿Cómo se pueden implementar diferentes estados en una aplicación de Android usando clases selladas?