Skip to content

6. Procesamiento asíncrono y estado compartido

6.1. Ejemplo 19: corrutinas, Flow y temporizadores

Muchas cosas ocurren “más tarde”: tics de un temporizador, pulsaciones de teclas, la respuesta de un servidor. Mientras que [Dart] tiene sus [Future] y [Stream], [Kotlin] tiene las CORRUTINAS:

  • Una función [suspend] puede ESPERAR ([delay], la respuesta de un servidor...) sin congelar el teléfono: mientras espera, la pantalla sigue activa. Devuelve UN valor más tarde: es equivalente a una función [async] que devuelve un [Future];
  • un [Flow<T>] es una SECUENCIA de valores a lo largo del tiempo, que se transforman con operadores ([map], [debounce]...) : el equivalente de un [Stream];
  • una corrutina se lanza en un ÁMBITO ([LaunchedEffect], [rememberCoroutineScope], [viewModelScope]...); se CANCELA cuando termina su ámbito.
// =========================================================================
// ex19/Ex19Activity.kt - corrutinas, Flow, temporizadores
// -------------------------------------------------------------------------
// Muchas cosas ocurren "más tarde": los tics de un temporizador, las
// pulsaciones de teclas, la respuesta de un servidor. Kotlin tiene
// CORRUTINAS para eso:
//   - una función "suspend" puede ESPERAR (delay, la respuesta de un
//     servidor...) sin bloquear el teléfono: durante la espera, la pantalla
//     sigue viva. Devuelve UN valor, más tarde;
//   - un Flow<T> es una SECUENCIA de valores, a lo largo del tiempo (tics,
//     entradas...), transformada con operadores (map, debounce...);
//   - una corrutina se lanza en un SCOPE: LaunchedEffect,
//     rememberCoroutineScope...; se cancela cuando su scope desaparece.
// Compose puede mostrar un Flow, recomponiéndose en cada valor:
// collectAsStateWithLifecycle.
// =========================================================================
@file:OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)

package fr.stahe.examples.ex19

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.mapLatest
import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.random.Random

val doctors = listOf("Marie PELISSIER", "Paul TATOU", "Sophie DUPONT", "Jacques DURAND", "Martine PELLETIER")

// un "servidor" simulado: una función SUSPEND, cuya respuesta llega
// tras un retraso aleatorio
suspend fun search(text: String): List<String> {
    delay(200L + Random.nextLong(600))
    return doctors.filter { it.lowercase().contains(text) }
}

// 1. un Flow construido con el builder flow { }: cada emit ENVÍA un
// valor a quien lo recolecta
fun countdown(start: Int): Flow<Int> = flow {
    for (remaining in start downTo 0) {
        emit(remaining)
        if (remaining > 0) delay(1000)
    }
}

fun currentTime(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))

class Ex19Activity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent { ExamplesTheme { AsynchronousPage() } }
    }
}

@Composable
fun AsynchronousPage() {
    val log = remember { mutableStateListOf<String>() }
    fun trace(message: String) = log.add("${currentTime()} $message")

    // el Flow se crea UNA SOLA VEZ (remember): ¡sin ello, cada recomposición
    // reiniciaría la cuenta regresiva!
    val countdownFlow = remember { countdown(20) }
    // collectAsStateWithLifecycle: un estado que sigue los valores del Flow
    // (null antes del primero); la recolección se detiene si la aplicación
    // pasa a segundo plano
    val remaining by countdownFlow.collectAsStateWithLifecycle(initialValue = null)

    // 2. la búsqueda mientras se escribe
    var input by remember { mutableStateOf("") }
    var results by remember { mutableStateOf(listOf<String>()) }
    LaunchedEffect(Unit) {
        // snapshotFlow: un Flow de los valores sucesivos de un estado de Compose
        snapshotFlow { input }
            // el DEBOUNCE: una entrada solo se transmite tras 400 ms sin pulsar una tecla
            .debounce(400)
            .map { it.trim().lowercase() }
            // mapLatest: una nueva entrada CANCELA la búsqueda anterior,
            // si no ha terminado: ninguna respuesta obsoleta
            .mapLatest { text ->
                // menos de dos letras: sin búsqueda, sin resultado
                if (text.length < 2) return@mapLatest emptyList()
                trace("search sent: \"$text\"")
                try {
                    search(text)
                } catch (e: CancellationException) {
                    trace("search cancelled (stale): \"$text\"")
                    throw e // una corrutina cancelada debe seguir cancelada
                }
            }
            // collect: consume los valores del Flow, uno por uno
            .collect { results = it }
    }

    // 3. un valor que llega después de un segundo: produceState lanza una
    // corrutina que PRODUCE un estado
    val message by produceState<String?>(initialValue = null) {
        delay(1000)
        value = "three (one second later)"
    }

    val titleStyle = MaterialTheme.typography.titleSmall
    ExamplePage("Example 19 - asynchronous code") {
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text("A countdown (a Flow, collected)", style = titleStyle)
                Text(remaining?.toString() ?: "...", style = MaterialTheme.typography.displaySmall)
            }
        }
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text("A search as you type (debounce, stale responses)", style = titleStyle)
                OutlinedTextField(
                    value = input,
                    onValueChange = { input = it },
                    placeholder = { Text("at least two letters: pel, dur...") },
                    singleLine = true,
                    modifier = Modifier.fillMaxWidth(),
                )
                for (r in results) Text("• $r")
                if (results.isEmpty()) Text("no result", color = Color.Gray)
            }
        }
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text("Waiting for a value (produceState)", style = titleStyle)
                // mientras el valor no haya llegado: el texto de espera
                if (message == null) Text("waiting...", color = Color.Gray) else Text("received: $message")
            }
        }
        Text("Log", style = titleStyle)
        log.forEachIndexed { i, line -> Text("${i + 1}. $line", fontSize = 12.sp) }
    }
}
  • líneas 65–67: un “servidor” simulado: una función suspendida cuya respuesta llega después de una demora aleatoria;
  • líneas 72–75: un [Flow] creado con [flow [ ... ]]: cada [emit] envía un valor a quien lo recolecta; [downTo]: un bucle descendente;
  • líneas 96–100: el [Flow] se crea UNA SOLA VEZ ([remember]): de lo contrario, ¡cada recomposición reiniciaría la cuenta regresiva! [collectAsStateWithLifecycle] crea en realidad un estado que sigue sus valores; la recolección se detiene cuando la aplicación pasa a segundo plano;
  • líneas 107–125: búsqueda mientras se escribe. [snapshotFlow [ input ]]: el [Flow] de los valores sucesivos de un estado de [Compose]; [debounce(400)], DEBOUNCE: una entrada se envía solo después de 400 ms sin pulsaciones de teclas; [mapLatest]: una nueva entrada CANCELA la búsqueda anterior, si no ha terminado: ninguna respuesta obsoleta;
  • líneas 119–121: una corrutina cancelada recibe una [CancellationException]: se puede registrar, pero debe relanzarse ([throw e]) para que la cancelación se complete;
  • líneas 130–132: [produceState]: una corrutina que PRODUCE un estado (aquí, un valor que llega después de un segundo).

Image

Image

A la izquierda, al inicio; a la derecha, después de escribir rápidamente “pel”, “du” y luego “dup”: solo las pulsaciones seguidas de una pausa activaron una búsqueda, y la pantalla muestra el resultado de la última.

6.2. Ejemplo 20: un estado compartido

Un “store” es un estado que vive FUERA de las pantallas, como UNA ÚNICA instancia, compartida por todos los que lo leen. El Ejemplo 14 lo hacía manualmente; [Android] proporciona lo siguiente para este fin: un objeto creado a petición ([viewModel()]), entregado luego idéntico a todos los que lo solicitan, y que se recrea cuando cambia la actividad (rotación de la pantalla, cambio de idioma). Es equivalente a los paquetes [provider] o [riverpod] de [Flutter].

// =========================================================================
// ex20/stores/Cart.kt - un ESTADO COMPARTIDO, en un ViewModel
// -------------------------------------------------------------------------
// Un "store" es un estado que vive FUERA de las pantallas, en UNA sola
// copia, compartida por todos los que lo leen. El ejemplo 14 lo hizo
// a mano (CompositionLocal); Android ofrece el ViewModel para eso:
//   - un objeto creado en la PRIMERA solicitud, y luego devuelto idéntico a
//     todas las funciones de la actividad que lo piden: viewModel();
//   - que SOBREVIVE a la recreación de la actividad (rotación de pantalla,
//     cambio de idioma): solo se destruye cuando la actividad se
//     cierra definitivamente.
// Organización habitual:
//   - el ESTADO: un MutableStateFlow PRIVADO, un valor observable; hacia afuera, solo
//     se ve una versión de solo lectura (StateFlow);
//   - las ACCIONES: funciones, las únicas que modifican el estado;
//   - los valores calculados: otros StateFlows, deducidos del primero (map),
//     que SOLO cambian si su valor cambia.
// =========================================================================
package fr.stahe.examples.ex20.stores

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update

data class Item(val label: String, val price: Double)

class Cart : ViewModel() {
    private val _items = MutableStateFlow(listOf<Item>())
    val items: StateFlow<List<Item>> = _items.asStateFlow()

    // valores DEDUCIDOS: stateIn los convierte en StateFlows, que viven tanto
    // como el ViewModel (viewModelScope)
    val count: StateFlow<Int> = items.map { it.size }.stateIn(viewModelScope, SharingStarted.Eagerly, 0)
    val total: StateFlow<Double> = items.map { list -> list.sumOf { it.price } }.stateIn(viewModelScope, SharingStarted.Eagerly, 0.0)

    // update: reemplaza el valor por uno nuevo, calculado a partir del anterior
    fun add(item: Item) = _items.update { it + item }

    fun clear() {
        _items.value = emptyList()
    }
}
  • líneas 34–35: el ESTADO: un [MutableStateFlow] PRIVADO, un valor observable; hacia el exterior, solo es visible una versión de solo lectura ([StateFlow]);
  • líneas 39–40: valores DEDUCIDOS: [map], luego [stateIn], que a su vez crea [StateFlow] que existen mientras exista el [ViewModel] ([viewModelScope]). Un [StateFlow] emite solo si su valor CAMBIA;
  • Líneas 43–46: las ACCIONES son las únicas que modifican el estado; [update] reemplaza el valor por uno nuevo, calculado a partir del anterior.

Para que los datos sobrevivan a la DETENCIÓN de la aplicación, deben almacenarse en el dispositivo. La biblioteca [DataStore] de [Jetpack] proporciona un pequeño diccionario de clave a valor, almacenado en un archivo propio de la aplicación:

// =========================================================================
// ex20/stores/Preferences.kt - un estado que sobrevive a la detención
// -------------------------------------------------------------------------
// Para que un dato sobreviva a la detención de la aplicación, debe guardarse
// EN EL DISPOSITIVO. La biblioteca Jetpack DataStore ofrece un pequeño
// diccionario clave -> valor (Boolean, Int, Float, String...), propio de la
// aplicación y guardado en un archivo del teléfono:
//   - leer es un Flow: emite los valores guardados (leídos
//     de forma asíncrona, sin bloquear la pantalla), luego cada nuevo valor;
//   - escribir es una función suspend (edit).
// NUNCA guarde datos sensibles en él (contraseña, token): se
// escriben en texto plano.
// =========================================================================
package fr.stahe.examples.ex20.stores

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.floatPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

// EL archivo de preferencias del ejemplo: una propiedad de extensión de
// Context, delegada a preferencesDataStore (un solo DataStore por archivo)
val Context.storage: DataStore<Preferences> by preferencesDataStore(name = "example20")

// lo que se guarda
data class Settings(val dark: Boolean, val size: Float)

class UserPreferences(private val storage: DataStore<Preferences>) {
    private val darkKey = booleanPreferencesKey("dark")
    private val sizeKey = floatPreferencesKey("size")

    // lo que el dispositivo ha guardado, y si no, los valores predeterminados
    val settings: Flow<Settings> = storage.data.map { p -> Settings(p[darkKey] ?: false, p[sizeKey] ?: 16f) }

    // un parámetro con nombre opcional por preferencia: solo se cambia lo que se proporciona
    suspend fun update(dark: Boolean? = null, size: Float? = null) {
        storage.edit { p ->
            if (dark != null) p[darkKey] = dark
            if (size != null) p[sizeKey] = size
        }
    }
}
  • línea 28: EL archivo de preferencias del ejemplo: una propiedad de extensión de [Context], delegada en [preferencesDataStore] (solo un [DataStore] por archivo);
  • línea 38: la operación de lectura es un [Flow]: emite los valores almacenados (leídos sin bloquear la pantalla) y luego cada nuevo valor;
  • líneas 41–44: la operación de escritura es una función suspendida ([edit]). Los datos sensibles (contraseñas, tokens) NUNCA se almacenan allí: se escribirían en texto plano.

Componentes que usan el carrito de compras:

// =========================================================================
// ex20/components/Components.kt - tres componentes del ejemplo 20
// -------------------------------------------------------------------------
// viewModel(): el Cart de la actividad, creado en la primera solicitud, y luego
// el MISMO para todos los que lo piden.
// =========================================================================
package fr.stahe.examples.ex20.components

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.ShoppingCart
import androidx.compose.material3.Card
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ex20.stores.Item
import fr.stahe.examples.ex20.stores.Cart

val products = listOf(Item("Consultation", 30.0), Item("Vaccine", 12.5))

// AGREGA al carrito compartido: la tienda no LEE el carrito, no
// se recompone cuando el carrito cambia
@Composable
fun Shop(cart: Cart = viewModel()) {
    Card {
        Column(Modifier.padding(12.dp)) {
            Text("Shop", style = MaterialTheme.typography.titleSmall)
            for (p in products) {
                TextButton(onClick = { cart.add(p) }) {
                    Icon(Icons.Default.Add, contentDescription = null)
                    Text("${p.label} (€${p.price})")
                }
            }
        }
    }
}

// LEE el mismo carrito: solo el conteo y el total (se recompone
// solo si uno de los dos cambia)
@Composable
fun CartSummary(cart: Cart = viewModel()) {
    val count by cart.count.collectAsStateWithLifecycle()
    val total by cart.total.collectAsStateWithLifecycle()
    Card {
        Row(Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
            Icon(Icons.Default.ShoppingCart, contentDescription = null)
            Spacer(Modifier.width(8.dp))
            Text("$count item(s), €$total", Modifier.weight(1f))
            TextButton(onClick = { cart.clear() }, enabled = count > 0) { Text("Clear") }
        }
    }
}

// un estado LOCAL (rememberSaveable), que desaparece con el componente...
// a menos que se coloque en un SaveableStateProvider (cf. Ex20Activity.kt)
@Composable
fun LocalCounter(title: String) {
    var clicks by rememberSaveable { mutableIntStateOf(0) }
    Card {
        ListItem(
            headlineContent = { Text(title) },
            trailingContent = { OutlinedButton(onClick = { clicks++ }) { Text("$clicks click(s)") } },
        )
    }
}
  • Línea 42: [cart: Cart = viewModel()]: el carrito de compras de la actividad, creado en la primera solicitud. La tienda ([Shop]) AGREGA al carrito sin leerlo: no se regenera cuando cambia el carrito;
  • Líneas 60–61: el resumen lee solo la cantidad y el total; se regenera únicamente si cambia alguno de los dos;
  • líneas 75–76: un contador (LOCAL), que desaparece junto con el componente.

La pantalla:

// =========================================================================
// ex20/Ex20Activity.kt - tres "ámbitos" de datos
// -------------------------------------------------------------------------
//   - el estado LOCAL de un componente (LocalCounter) desaparece con él;
//   - el estado de un STORE (el carrito, un ViewModel) es compartido por todos
//     los componentes y sobrevive a su eliminación, e incluso a una rotación de
//     la pantalla - pero no a la detención de la aplicación;
//   - el estado guardado en el dispositivo (las preferencias, DataStore) sobrevive
//     a la detención.
// Y el SaveableStateHolder: CONSERVA el estado local (rememberSaveable)
// de un contenido retirado de la pantalla, y lo devuelve si regresa.
// Desmarque y vuelva a marcar "show the area", luego detenga y reinicie
// la aplicación: compare.
// =========================================================================
package fr.stahe.examples.ex20

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.selection.toggleable
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ListItem
import androidx.compose.material3.Slider
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.saveable.rememberSaveableStateHolder
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex20.components.Shop
import fr.stahe.examples.ex20.components.LocalCounter
import fr.stahe.examples.ex20.components.CartSummary
import fr.stahe.examples.ex20.stores.UserPreferences
import fr.stahe.examples.ex20.stores.storage
import kotlinx.coroutines.launch
import kotlin.math.roundToInt

class Ex20Activity : ComponentActivity() {
    // lazy: el objeto se crea en el primer uso (el contexto de la aplicación
    // aún no existe cuando se construye la actividad)
    private val preferences by lazy { UserPreferences(applicationContext.storage) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent { App(preferences) }
    }
}

@Composable
fun App(preferences: UserPreferences) {
    // las preferencias guardadas: null mientras no se hayan leído
    val settings by preferences.settings.collectAsStateWithLifecycle(initialValue = null)
    val s = settings ?: return // nada que mostrar antes de la lectura (unos milisegundos)
    val scope = rememberCoroutineScope()

    // el tema oscuro, o el claro
    ExamplesTheme(dark = s.dark) {
        // el tamaño del texto: fontScale multiplica el tamaño de TODOS los textos
        val density = LocalDensity.current
        CompositionLocalProvider(LocalDensity provides Density(density.density, fontScale = s.size / 16f)) {
            SharedStatePage(
                dark = s.dark,
                size = s.size,
                onDark = { v -> scope.launch { preferences.update(dark = v) } },
                onSize = { v -> scope.launch { preferences.update(size = v) } },
            )
        }
    }
}

@Composable
fun SharedStatePage(dark: Boolean, size: Float, onDark: (Boolean) -> Unit, onSize: (Float) -> Unit) {
    var areaVisible by rememberSaveable { mutableStateOf(true) }
    // el guardián de los estados de los contenidos retirados
    val keptStates = rememberSaveableStateHolder()

    ExamplePage("Example 20 - a shared state") {
        ListItem(
            headlineContent = { Text("dark theme") },
            trailingContent = { Switch(checked = dark, onCheckedChange = onDark) },
        )
        ListItem(
            headlineContent = { Text("text size: ${size.roundToInt()}") },
            supportingContent = { Slider(value = size, onValueChange = onSize, valueRange = 12f..22f, steps = 9) },
        )
        ListItem(
            modifier = Modifier.toggleable(value = areaVisible, onValueChange = { areaVisible = it }),
            leadingContent = { Checkbox(checked = areaVisible, onCheckedChange = null) },
            headlineContent = { Text("show the area") },
        )
        if (areaVisible) {
            // retirado: estos componentes desaparecen, con su estado local
            Shop()
            CartSummary()
            LocalCounter("Local state")
            // retirado también, pero su estado se CONSERVA en keptStates, bajo la clave "counter"
            keptStates.SaveableStateProvider("counter") {
                LocalCounter("Local state, kept by a SaveableStateHolder")
            }
        }
        Text(
            "Outside the area, a second summary of the SAME cart (it stays there when the area disappears):",
            Modifier.padding(vertical = 8.dp),
        )
        CartSummary()
    }
}
  • línea 54: [by lazy]: el objeto se crea en el primer uso (el contexto de la aplicación aún no existe cuando se construye la actividad);
  • líneas 66–67: se leen las preferencias; [?: return]: nada que mostrar hasta que se hayan leído (unos pocos milisegundos);
  • líneas 71–79: el tema oscuro o claro y el tamaño del texto (TODOS los textos: [fontScale] y [LocalDensity]); cambiar una preferencia lanza una corrutina;
  • Líneas 89–112: [rememberSaveableStateHolder]: un guardián que GUARDA el estado local ([rememberSaveable]) del contenido retirado de la pantalla y lo restaura si el contenido regresa.

Image

Image

Image

A la izquierda, dos ítems y clics en ambos contadores; en el centro, tema oscuro y área oculta: el resumen fuera del área sigue mostrando el carrito de compras; a la derecha, el área se muestra de nuevo: el carrito está intacto, el contador local volvió a 0 y el contador guardado recuperó su valor original. Detenga y vuelva a iniciar la aplicación: solo se conservaron las preferencias (tema, tamaño del texto).