MVI Bien Hecho: Resolviendo Eventos Puntuales en Android

Image of the author

Germán Bustamante @germanbustamante

Diagrama de arquitectura MVI mostrando el ciclo de flujo de estado

MVI Bien Hecho: Resolviendo Eventos Puntuales en Android

Este post sintetiza ideas de tres artículos excelentes. Todo el crédito y agradecimiento a:

Recomiendo mucho leer los originales. Este post conecta sus ideas en una narrativa unificada y añade mi propia perspectiva.

🧠 Introducción: La Confusión con el Estado

Durante años, la comunidad Android ha debatido sobre arquitectura: ¿MVVM o MVI? ¿Son siquiera patrones distintos? Y luego está ese problema recurrente y obstinado de los eventos puntuales — ¿cómo navegas a una pantalla exactamente una vez, muestras un snackbar sin duplicarlo o lanzas un toast que no debería reproducirse tras un cambio de configuración?

Lo que encuentro interesante es que estos dos debates son en realidad el mismo problema con diferente disfraz. La confusión en torno a MVI y la confusión en torno a los eventos puntuales comparten una raíz común: una comprensión difusa de lo que “estado” significa realmente en una UI reactiva.

Mi tesis es simple — si entiendes verdaderamente MVI, el problema de los eventos puntuales se disuelve. Los eventos no son una categoría especial que requiere mecanismos especiales. Son estado transitorio. Una vez que aceptas eso, la solución se vuelve casi obvia, y los anti-patrones resultan obviamente incorrectos.

Construyamos esa comprensión desde la base.

🔄 Qué es MVI en Realidad

El Registro Histórico

Aquí hay algo que la comunidad Android suele equivocarse: MVI no es un Redux rebautizado. De hecho, MVI es anterior a Redux por aproximadamente un año.

André Staltz introdujo MVI en 2014 a través de su trabajo en Cycle.js y su post sobre “Reactive MVC and the Virtual DOM.” Redux se lanzó en 2015. Ambos se inspiraron en Flux (Facebook, 2014) y su idea central de flujo de datos unidireccional, pero evolucionaron de forma independiente con filosofías distintas.

¿Por qué importa esto? Porque cuando los desarrolladores dicen “MVI en Android es solo Redux,” importan suposiciones que no corresponden. Redux está construido alrededor de un store global a nivel de app y reducers imperativos. MVI, tal como Staltz lo concibió, trata sobre streams reactivos — la vista y el modelo están vinculados a través de pipelines observables, no acciones despachadas.

La evolución se ve así:

La Fórmula

En su núcleo, MVI puede expresarse como:

Estado Anterior + Intent = Nuevo Estado

Los tres componentes:

El ViewModel en Android actúa como el reducer: recibe Intents, los aplica al estado actual y emite un nuevo Model. La UI se suscribe al stream del Model y se re-renderiza cada vez que cambia.

MVI vs. MVVM: No Son el Mismo Patrón

La diferencia práctica está en el modelo de estado:

Esta restricción en MVI no es arbitraria. Un objeto de estado único previene estados intermedios inconsistentes — nunca puedes tener isLoading = true e items = populated simultáneamente si tus transiciones del reducer son atómicas.

🎯 El Problema de los Eventos Puntuales

Con MVI correctamente definido, podemos enmarcar el desafío: algunas interacciones de UI se sienten como “eventos” en lugar de “estado.” La navegación a una pantalla de detalles, una confirmación de snackbar, un toast tras una eliminación — ocurren una vez y luego terminan. No describen una condición persistente.

Los desarrolladores instintivamente recurren a mecanismos tipo eventos: Channels, SharedFlow, Kotlin Flows. El modelo mental es “lanzo este evento desde el ViewModel, la UI lo captura.” Parece limpio. Refleja cómo pensamos sobre los clics de botones.

El problema es que este modelo mental rompe el contrato de MVI. En MVI, el trabajo del ViewModel es exponer cuál es el estado de la app, no enviar comandos a la UI. En el momento en que tienes _events.send(NavigateToDetail), el ViewModel está dirigiendo la UI — ha cruzado la línea de la gestión de estado a la lógica de UI.

Y más allá del argumento de pureza arquitectónica, hay un problema muy práctico: estos mecanismos no entregan eventos a la UI de forma fiable.

🚫 Anti-Patrones: Qué No Hacer

El Enfoque con Channel

// Anti-patrón: Channel para eventos puntuales
class PaymentViewModel : ViewModel() {
    private val _events = Channel<PaymentEvent>()
    val events = _events.receiveAsFlow()

    fun processPayment() {
        viewModelScope.launch {
            val result = repository.pay()
            _events.send(PaymentEvent.NavigateToConfirmation(result))
        }
    }
}

Esto parece razonable. Pero considera qué ocurre durante un cambio de configuración: la UI deja de recolectar del flow mientras la Activity se recrea. Si processPayment() termina en ese intervalo, la llamada send() se suspende hasta que haya un recolector — pero si la coroutine se cancela primero, el evento se pierde silenciosamente.

Antes de kotlinx.coroutines 1.4, la cancelación atómica significaba que las operaciones del Channel se completaban incluso tras la cancelación del scope, lo que causaba crashes pero al menos garantizaba la entrega. Con la introducción de la cancelación inmediata en 1.4, el crash fue eliminado — pero también la garantía de entrega. Como señaló Roman Elizarov en ese momento: “Nunca funcionó en primer lugar.” La versión 1.4 simplemente hizo visible el fallo.

El Enfoque con SharedFlow

// Anti-patrón: SharedFlow para eventos puntuales
class PaymentViewModel : ViewModel() {
    private val _events = MutableSharedFlow<PaymentEvent>()
    val events = _events.asSharedFlow()

    fun processPayment() {
        viewModelScope.launch {
            val result = repository.pay()
            _events.emit(PaymentEvent.NavigateToConfirmation(result))
        }
    }
}

SharedFlow con replay = 0 descarta eventos si no hay suscriptor activo. Con replay = 1, solo sobrevive el último evento — inútil si se emiten múltiples eventos rápidamente. Con replay = unlimited, arriesgas problemas de memoria y reproducir eventos obsoletos para nuevos recolectores. No hay configuración que resuelva el problema fundamental.

Los Tres Anti-Patrones de Manuel Vivo

Manuel Vivo articuló esto con precisión en su artículo de 2022. Los tres modos de fallo son:

La Línea de Tiempo Histórica

Lo que hace esta historia particularmente interesante es cuánto tardó la industria en reconocer el problema:

La industria se movió lentamente aquí porque los bugs eran intermitentes y difíciles de reproducir. Solo surgían bajo condiciones de timing específicas durante cambios de configuración. Esta es una lección de precaución: los patrones que funcionan la mayoría del tiempo son más peligrosos que los que obviamente fallan.

✅ La Solución: Estado de Principio a Fin

La corrección es conceptualmente simple — si los eventos puntuales son el problema, deja de modelarlos como eventos. Modélalos como estado transitorio.

El Patrón Consume-and-Reset

data class PaymentUiState(
    val isLoading: Boolean = false,
    val paymentResult: PaymentData? = null,  // null = sin navegación pendiente
    val userMessage: String? = null          // null = sin mensaje pendiente
)

class PaymentViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(PaymentUiState())
    val uiState = _uiState.asStateFlow()

    fun processPayment() {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }
            val result = repository.pay()
            _uiState.update { it.copy(isLoading = false, paymentResult = result) }
        }
    }

    fun onNavigationHandled() {
        _uiState.update { it.copy(paymentResult = null) }
    }

    fun onMessageShown() {
        _uiState.update { it.copy(userMessage = null) }
    }
}

La UI observa uiState. Cuando paymentResult se vuelve no nulo, desencadena la navegación y llama a onNavigationHandled(). El ViewModel limpia el estado. No se envió ningún evento — el estado cambió, la UI reaccionó, el estado fue limpiado.

Esto sobrevive a los cambios de configuración porque StateFlow mantiene el último valor. Un nuevo suscriptor de la UI obtiene inmediatamente el estado actual, incluyendo cualquier navegación pendiente. No se pierde ningún evento.

Sealed Interface de Efectos

Para pantallas con múltiples tipos de efectos, una interfaz sellada mantiene las cosas organizadas:

sealed interface UiEffect {
    data class Navigate(val route: String) : UiEffect
    data class ShowSnackbar(val message: String, val actionLabel: String? = null) : UiEffect
    data object ShowDeleteConfirmation : UiEffect
}

data class MyUiState(
    val items: List<Item> = emptyList(),
    val isLoading: Boolean = false,
    val pendingEffect: UiEffect? = null
)

El campo pendingEffect es nullable — null significa ningún efecto pendiente, no nulo significa que algo está esperando ser manejado. La UI lo procesa y llama de vuelta para resetearlo.

Composable Effect Handler

Eury Pérez Beltré fue más lejos con un composable LaunchedUiEffectHandler que elimina el boilerplate:

@Composable
fun LaunchedUiEffectHandler(
    effect: UiEffect?,
    onEffectHandled: () -> Unit,
    handler: suspend (UiEffect) -> Unit
) {
    LaunchedEffect(effect) {
        effect?.let {
            handler(it)
            onEffectHandled()
        }
    }
}

Esto centraliza la recolección del ciclo de vida, el keying de LaunchedEffect, la comprobación de nulos y el consumo en un único componente reutilizable. También hace el contrato consume-and-reset explícito y difícil de omitir accidentalmente.

Por Qué Gana StateFlow

🛡️ Reforzando el Patrón

Una buena arquitectura es aquella que es difícil de violar accidentalmente. El artículo de Eury Pérez Beltré describe una regla personalizada de Detekt que detecta cualquier LaunchedEffect que maneje manualmente parámetros tipo efecto, sugiriendo LaunchedUiEffectHandler en su lugar. De forma similar, una regla que detecte el uso de Channel o MutableSharedFlow en clases ViewModel puede atrapar anti-patrones en tiempo de compilación. Cuando los patrones son reforzados por herramientas en lugar de disciplina en revisiones de código, escalan a equipos grandes.

💡 Conclusiones Clave

📚 Lectura Adicional