Anexo 3. Referencia: StateFlow, corrutinas y arquitectura MVVM

 1// Función normal — bloquea el hilo hasta que termina
 2fun cargarDatos(): List<String> {
 3    Thread.sleep(2000)   // el hilo está bloqueado durante 2 segundos
 4    return listOf("dato1", "dato2")
 5}
 6
 7// Función suspend — libera el hilo mientras espera
 8suspend fun cargarDatos(): List<String> {
 9    delay(2000)   // el hilo queda libre durante 2 segundos
10    return listOf("dato1", "dato2")
11}

 1class EjemploViewModel : ViewModel() {
 2
 3    fun cargarYProcesar() {
 4        viewModelScope.launch {
 5            // Por defecto: Dispatchers.Main.immediate
 6
 7            // Cambiar a IO para operaciones de entrada/salida
 8            val datos = withContext(Dispatchers.IO) {
 9                repositorio.cargarDesdeRed()   // llamada de red o BD
10            }
11
12            // De vuelta en Main — actualizar la UI con los datos
13            _uiState.value = UiState.Exito(datos)
14        }
15    }
16}

 1class DemoViewModel : ViewModel() {
 2
 3    fun ejemploLanzamiento() {
 4        // launch: lanza y no espera (fire-and-forget)
 5        viewModelScope.launch {
 6            val datos = repositorio.cargar()   // suspende aquí sin bloquear
 7            _uiState.value = UiState.Exito(datos)
 8        }
 9    }
10
11    suspend fun ejemploAsync() {
12        // async/await: lanza y espera el resultado
13        val deferred = viewModelScope.async {
14            repositorio.cargar()
15        }
16        val resultado = deferred.await()
17        _uiState.value = UiState.Exito(resultado)
18    }
19
20    fun dosPeticionesEnParalelo() {
21        viewModelScope.launch {
22            // async lanza ambas corrutinas en paralelo
23            val peliculas = async { repositorio.getPeliculas() }
24            val generos   = async { repositorio.getGeneros() }
25
26            // await espera a que ambas terminen
27            _uiState.value = UiState.Exito(
28                peliculas = peliculas.await(),
29                generos   = generos.await()
30            )
31        }
32    }
33}

 1// Opción 1 — try/catch (recomendada para la mayoría de casos)
 2viewModelScope.launch {
 3    try {
 4        val resultado = repositorio.cargar()
 5        _uiState.value = UiState.Exito(resultado)
 6    } catch (e: IOException) {
 7        _uiState.value = UiState.Error("Sin conexión a internet")
 8    } catch (e: HttpException) {
 9        _uiState.value = UiState.Error("Error del servidor: ${e.code()}")
10    } catch (e: Exception) {
11        _uiState.value = UiState.Error(e.message ?: "Error desconocido")
12    }
13}
14
15// Opción 2 — CoroutineExceptionHandler (para errores no controlados)
16// Útil para logging centralizado o crashlytics
17private val manejadorErrores = CoroutineExceptionHandler { _, excepcion ->
18    _uiState.value = UiState.Error(excepcion.message ?: "Error no controlado")
19}
20
21viewModelScope.launch(manejadorErrores) {
22    val resultado = repositorio.cargar()
23    _uiState.value = UiState.Exito(resultado)
24}

 1class BuscadorViewModel : ViewModel() {
 2
 3    private val _resultados = MutableStateFlow<List<Pelicula>>(emptyList())
 4    val resultados: StateFlow<List<Pelicula>> = _resultados.asStateFlow()
 5
 6    // Referencia al Job de la búsqueda activa
 7    private var jobBusqueda: Job? = null
 8
 9    fun buscar(query: String) {
10        // Cancelar la búsqueda anterior si sigue activa
11        jobBusqueda?.cancel()
12
13        if (query.isBlank()) {
14            _resultados.value = emptyList()
15            return
16        }
17
18        jobBusqueda = viewModelScope.launch {
19            // debounce manual: espera 300ms antes de buscar
20            // evita buscar con cada letra tecleada
21            delay(300)
22            _resultados.value = repositorio.buscar(query)
23        }
24    }
25}

 1// Cold Flow — creado con el builder flow { }
 2val flujoFrio: Flow<Int> = flow {
 3    println("Inicio de la emisión")   // se ejecuta por cada colector
 4    emit(1)
 5    delay(500)
 6    emit(2)
 7    delay(500)
 8    emit(3)
 9}
10
11// Primer colector: recibe 1, 2, 3 desde el principio
12flujoFrio.collect { println(it) }
13
14// Segundo colector: también recibe 1, 2, 3 desde el principio
15flujoFrio.collect { println(it) }

1// StateFlow — siempre tiene un valor actual
2// Nuevo colector: recibe inmediatamente el último valor emitido
3val estadoActual = MutableStateFlow(42)
4
5// SharedFlow — no tiene valor actual por defecto
6// Nuevo colector: no recibe nada hasta la siguiente emisión
7val eventos = MutableSharedFlow<String>(replay = 0)

 1val flujoBase: Flow<Pelicula> = repositorio.getPeliculasFlow()
 2
 3// map — transforma cada elemento
 4val titulos: Flow<String> = flujoBase.map { it.titulo }
 5
 6// filter — filtra elementos que cumplen la condición
 7val soloFavoritas: Flow<Pelicula> = flujoBase.filter { it.esFavorita }
 8
 9// filterNotNull — elimina los valores nulos
10val sinNulos: Flow<Pelicula> = flujoBase.filterNotNull()
11
12// distinctUntilChanged — descarta emisiones iguales consecutivas
13// Útil para evitar recomposiciones innecesarias
14val sinDuplicados: Flow<Pelicula> = flujoBase.distinctUntilChanged()
15
16// debounce — espera un tiempo antes de emitir el último valor
17// Ideal para búsqueda mientras el usuario teclea
18val busquedaFlow: Flow<String> = textoBusqueda.debounce(300)
19
20// flatMapLatest — al llegar un nuevo valor, cancela el flujo anterior
21// Útil para búsquedas donde solo interesa el resultado de la última query
22val resultados: Flow<List<Pelicula>> = busquedaFlow.flatMapLatest { query ->
23    repositorio.buscar(query)
24}
25
26// combine — combina los últimos valores de dos flujos
27val uiState: Flow<UiState> = combine(
28    repositorio.getPeliculasFlow(),
29    filtrosFlow
30) { peliculas, filtros ->
31    UiState.Exito(peliculas.filter { it.genero in filtros })
32}

 1class PeliculasViewModel(
 2    private val repository: PeliculasRepository
 3) : ViewModel() {
 4
 5    // SharingStarted.WhileSubscribed(5_000):
 6    // Mantiene la suscripción activa 5 segundos después de que el último
 7    // colector desaparezca. Sobrevive a rotaciones de pantalla (que tardan
 8    // menos de 5s) sin mantener recursos en background indefinidamente.
 9    val uiState: StateFlow<PeliculasUiState> = repository
10        .getPeliculasFlow()
11        .map { peliculas -> PeliculasUiState.Exito(peliculas) }
12        .catch { error -> emit(PeliculasUiState.Error(error.message ?: "Error")) }
13        .stateIn(
14            scope = viewModelScope,
15            started = SharingStarted.WhileSubscribed(5_000),
16            initialValue = PeliculasUiState.Cargando
17        )
18}

 1// ANTES — con LiveData
 2class ViewModelConLiveData : ViewModel() {
 3    private val _peliculas = MutableLiveData<List<Pelicula>>(emptyList())
 4    val peliculas: LiveData<List<Pelicula>> = _peliculas
 5
 6    // En el Composable:
 7    // val peliculas by viewModel.peliculas.observeAsState(emptyList())
 8}
 9
10// DESPUÉS — con StateFlow (equivalente moderno)
11class ViewModelConStateFlow : ViewModel() {
12    private val _peliculas = MutableStateFlow<List<Pelicula>>(emptyList())
13    val peliculas: StateFlow<List<Pelicula>> = _peliculas.asStateFlow()
14
15    // En el Composable:
16    // val peliculas by viewModel.peliculas.collectAsStateWithLifecycle()
17}

 1// collectAsState — sigue activo aunque la app esté en background
 2// Solo adecuado para Kotlin Multiplatform (iOS no tiene "background")
 3val estado by viewModel.uiState.collectAsState()
 4
 5// collectAsStateWithLifecycle — pausa cuando la app está en background
 6// Recomendado en Android: ahorra CPU, memoria y batería
 7val estado by viewModel.uiState.collectAsStateWithLifecycle()
 8
 9// collectAsStateWithLifecycle con lifecycle personalizado
10// (raramente necesario, por defecto usa Lifecycle.State.STARTED)
11val estado by viewModel.uiState.collectAsStateWithLifecycle(
12    minActiveState = Lifecycle.State.RESUMED   // solo activo cuando la app está en primer plano
13)

 1// UiState genérico reutilizable para cualquier tipo de datos
 2sealed interface UiState<out T> {
 3    data object Cargando : UiState<Nothing>
 4    data class Exito<T>(val datos: T) : UiState<T>
 5    data class Error(val mensaje: String, val causa: Throwable? = null) : UiState<Nothing>
 6}
 7
 8// Uso con diferentes tipos de datos
 9val estadoPeliculas: StateFlow<UiState<List<Pelicula>>>
10val estadoDetalle:   StateFlow<UiState<Pelicula>>
11val estadoUsuario:   StateFlow<UiState<UsuarioPerfilDto>>
12
13// Funciones de extensión para simplificar el acceso
14fun <T> UiState<T>.datosONull(): T? = (this as? UiState.Exito)?.datos
15fun <T> UiState<T>.esCargando(): Boolean = this is UiState.Cargando
16fun <T> UiState<T>.esError(): Boolean = this is UiState.Error

 1// Para pantallas complejas con múltiples estados simultáneos
 2data class ListadoUiState(
 3    val peliculas: List<Pelicula> = emptyList(),
 4    val estaCargando: Boolean = false,
 5    val error: String? = null,
 6    val busqueda: String = "",
 7    val generoSeleccionado: String? = null,
 8    val soloFavoritos: Boolean = false
 9) {
10    // Propiedades derivadas — calculadas automáticamente al cambiar el estado
11    val peliculasFiltradas: List<Pelicula>
12        get() = peliculas.filter { pelicula ->
13            (busqueda.isBlank() || pelicula.titulo.contains(busqueda, ignoreCase = true)) &&
14            (generoSeleccionado == null || pelicula.genero == generoSeleccionado) &&
15            (!soloFavoritos || pelicula.esFavorita)
16        }
17
18    val hayResultados: Boolean get() = peliculasFiltradas.isNotEmpty()
19}
20
21// ViewModel con data class UiState
22class ListadoViewModel(private val repository: PeliculasRepository) : ViewModel() {
23
24    private val _uiState = MutableStateFlow(ListadoUiState())
25    val uiState: StateFlow<ListadoUiState> = _uiState.asStateFlow()
26
27    init { cargarPeliculas() }
28
29    fun cargarPeliculas() {
30        viewModelScope.launch {
31            _uiState.update { it.copy(estaCargando = true, error = null) }
32            try {
33                val peliculas = repository.getPeliculas()
34                _uiState.update { it.copy(peliculas = peliculas, estaCargando = false) }
35            } catch (e: Exception) {
36                _uiState.update { it.copy(estaCargando = false, error = e.message) }
37            }
38        }
39    }
40
41    fun actualizarBusqueda(texto: String) =
42        _uiState.update { it.copy(busqueda = texto) }
43
44    fun seleccionarGenero(genero: String?) =
45        _uiState.update { it.copy(generoSeleccionado = genero) }
46
47    fun toggleSoloFavoritos() =
48        _uiState.update { it.copy(soloFavoritos = !it.soloFavoritos) }
49
50    fun toggleFavorita(id: Int) {
51        _uiState.update { estado ->
52            estado.copy(
53                peliculas = estado.peliculas.map {
54                    if (it.id == id) it.copy(esFavorita = !it.esFavorita) else it
55                }
56            )
57        }
58    }
59}

 1// ❌ ViewModel demasiado grande — señal de problemas
 2class AppViewModel : ViewModel() {
 3    // Estado del listado
 4    val peliculas: StateFlow<...>
 5    // Estado del detalle
 6    val peliculaSeleccionada: StateFlow<...>
 7    // Estado de favoritos
 8    val favoritos: StateFlow<...>
 9    // Estado de ajustes
10    val ajustes: StateFlow<...>
11    // ...30 funciones más
12}
13
14// ✅ Un ViewModel por pantalla o flujo de pantallas relacionadas
15class ListadoViewModel : ViewModel() { ... }
16class DetalleViewModel : ViewModel() { ... }
17class FavoritosViewModel : ViewModel() { ... }
18class AjustesViewModel : ViewModel() { ... }

 1// ❌ Antipatrón — cada ViewModel gestiona su propia copia de los favoritos
 2class ListadoViewModel : ViewModel() {
 3    private val favoritos = mutableListOf<Int>()   // copia propia
 4}
 5class FavoritosViewModel : ViewModel() {
 6    private val favoritos = mutableListOf<Int>()   // otra copia, puede desincronizarse
 7}
 8
 9// ✅ Patrón correcto — ambos leen y escriben en el mismo Repository
10// (En B3 el repositorio usará ROOM, que expone un Flow que se actualiza automáticamente)
11class ListadoViewModel(private val repository: PeliculasRepository) : ViewModel()
12class FavoritosViewModel(private val repository: PeliculasRepository) : ViewModel()

 1// ❌ Causa del problema
 2@Composable
 3fun Pantalla() {
 4    var busqueda by remember { mutableStateOf("") }   // se pierde al rotar
 5}
 6
 7// ✅ Solución
 8class MiViewModel : ViewModel() {
 9    private val _busqueda = MutableStateFlow("")      // sobrevive a la rotación
10    val busqueda: StateFlow<String> = _busqueda.asStateFlow()
11}

 1// ❌ Error — nueva instancia en cada recomposición
 2@Composable
 3fun Pantalla() {
 4    val viewModel = MiViewModel()   // nueva instancia cada vez
 5}
 6
 7// ✅ Correcto — misma instancia gestionada por Jetpack
 8@Composable
 9fun Pantalla() {
10    val viewModel: MiViewModel = viewModel(factory = MiViewModel.Factory)
11}

 1// ❌ Error — llamada de red en el hilo principal
 2fun cargar() {
 3    val datos = repositorio.cargarDatos() // NetworkOnMainThreadException
 4    _uiState.value = UiState.Exito(datos)
 5}
 6
 7// ✅ Correcto — dentro de viewModelScope
 8fun cargar() {
 9    viewModelScope.launch {
10        val datos = repositorio.cargarDatos() // suspend — no bloquea el hilo
11        _uiState.value = UiState.Exito(datos)
12    }
13}

 1// ❌ Causa 2 — modificar la lista directamente no notifica a StateFlow
 2fun añadirFavorita(id: Int) {
 3    val listaActual = (_uiState.value as UiState.Exito).peliculas
 4    listaActual.add(Pelicula(id, "Nueva")) // la lista es la misma referencia
 5    // StateFlow no detecta el cambio porque la referencia no cambió
 6}
 7
 8// ✅ Correcto — crear una nueva lista
 9fun añadirFavorita(pelicula: Pelicula) {
10    _uiState.update { estado ->
11        if (estado is UiState.Exito) {
12            estado.copy(peliculas = estado.peliculas + pelicula) // nueva lista
13        } else estado
14    }
15}

1class MiViewModelTest {
2    @get:Rule
3    val mainDispatcherRule = MainDispatcherRule() // inicializa Dispatchers.Main para tests
4    // ...
5}

 1// build.gradle.kts (app) — dependencias completas del Bloque 2
 2dependencies {
 3    // ── Compose BOM ────────────────────────────────────────────────────────
 4    val composeBom = platform("androidx.compose:compose-bom:2026.01.01")
 5    implementation(composeBom)
 6    implementation("androidx.compose.ui:ui")
 7    implementation("androidx.compose.ui:ui-tooling-preview")
 8    implementation("androidx.compose.material3:material3")
 9    debugImplementation("androidx.compose.ui:ui-tooling")
10
11    // ── Activity Compose ───────────────────────────────────────────────────
12    implementation("androidx.activity:activity-compose:1.12.3")
13
14    // ── ViewModel y Lifecycle ──────────────────────────────────────────────
15    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.9.2")
16    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.9.2")
17
18    // ── Navigation Compose ─────────────────────────────────────────────────
19    implementation("androidx.navigation:navigation-compose:2.9.7")
20
21    // ── Kotlin Serialization (para rutas tipadas de Navigation) ────────────
22    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0")
23
24    // ── Corrutinas ─────────────────────────────────────────────────────────
25    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
26
27    // ── Testing ────────────────────────────────────────────────────────────
28    testImplementation("junit:junit:4.13.2")
29    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
30    androidTestImplementation("androidx.test.ext:junit:1.2.1")
31    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
32    debugImplementation("androidx.compose.ui:ui-test-manifest")
33}

1// build.gradle.kts — plugins (nivel de módulo app)
2plugins {
3    id("com.android.application")
4    id("org.jetbrains.kotlin.android")
5    id("org.jetbrains.kotlin.plugin.serialization") // misma versión que Kotlin
6}