Skip to content

6. Processamento assíncrono e estado compartilhado

6.1. Exemplo 19: corrotinas, Flow e temporizadores

Muitas coisas acontecem “depois”: tiques de temporizador, teclas digitadas, a resposta de um servidor. Onde o [Dart] tem seu [Future] e seu [Stream], o [Kotlin] tem as CORROTINAS:

  • uma função [suspend] pode ESPERAR ([delay], uma resposta do servidor...) sem congelar o celular: durante a espera, a tela permanece ativa. Ela retorna UM valor mais tarde: é o equivalente de uma função [async] que retorna um [Future];
  • um [Flow<T>] é uma SEQUÊNCIA de valores ao longo do tempo, que são transformados por meio de operadores ([map], [debounce]...): o equivalente de um [Stream];
  • uma corrotina é iniciada em um ESCOPO ([LaunchedEffect], [rememberCoroutineScope], [viewModelScope]...); ela é CANCELADA quando seu escopo termina.
// =========================================================================
// ex19/Ex19Activity.kt - corotinas, Flow, timers
// -------------------------------------------------------------------------
// Muitas coisas acontecem "mais tarde": os tiques de um timer, as
// teclas digitadas, a resposta de um servidor. O Kotlin tem
// COROTINAS para isso:
//   - uma função "suspend" pode ESPERAR (delay, a resposta de um
//     servidor...) sem bloquear o celular: durante a espera, a tela
//     continua viva. Ela retorna UM valor, mais tarde;
//   - um Flow<T> é uma SEQUÊNCIA de valores, ao longo do tempo (tiques,
//     entradas...), transformada com operadores (map, debounce...);
//   - uma corotina é lançada em um ESCOPO: LaunchedEffect,
//     rememberCoroutineScope...; ela é cancelada quando seu escopo desaparece.
// O Compose pode exibir um Flow, recompondo-se a 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")

// um "servidor" simulado: uma função SUSPEND, cuja resposta chega
// após um atraso aleatório
suspend fun search(text: String): List<String> {
    delay(200L + Random.nextLong(600))
    return doctors.filter { it.lowercase().contains(text) }
}

// 1. um Flow construído pelo builder flow { }: cada emit ENVIA um
// valor a quem o coleta
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")

    // o Flow é criado UMA ÚNICA VEZ (remember): sem isso, cada recomposição
    // reiniciaria a contagem regressiva!
    val countdownFlow = remember { countdown(20) }
    // collectAsStateWithLifecycle: um estado que acompanha os valores do Flow
    // (null antes do primeiro); a coleta para se o aplicativo
    // for para segundo plano
    val remaining by countdownFlow.collectAsStateWithLifecycle(initialValue = null)

    // 2. a pesquisa enquanto se digita
    var input by remember { mutableStateOf("") }
    var results by remember { mutableStateOf(listOf<String>()) }
    LaunchedEffect(Unit) {
        // snapshotFlow: um Flow dos valores sucessivos de um estado do Compose
        snapshotFlow { input }
            // o DEBOUNCE: uma entrada só é repassada após 400 ms sem nenhuma tecla digitada
            .debounce(400)
            .map { it.trim().lowercase() }
            // mapLatest: uma nova entrada CANCELA a pesquisa anterior,
            // se ela não tiver terminado: nenhuma resposta obsoleta
            .mapLatest { text ->
                // menos de duas letras: nenhuma pesquisa, nenhum 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 // uma corotina cancelada deve permanecer cancelada
                }
            }
            // collect: consome os valores do Flow, um a um
            .collect { results = it }
    }

    // 3. um valor que chega após um segundo: produceState lança uma
    // corotina que PRODUZ um 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)
                // enquanto o valor não chegou: o 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) }
    }
}
  • linhas 65–67: um “servidor” simulado: uma função suspensa cuja resposta chega após um atraso aleatório;
  • linhas 72–75: um [Flow] criado por [flow [ ... ]]: cada [emit] envia um valor a quem o coleta; [downTo]: um laço decrescente;
  • linhas 96–100: o [Flow] é criado UMA ÚNICA VEZ ([remember]): caso contrário, cada recomposição reiniciaria a contagem regressiva! [collectAsStateWithLifecycle] cria de fato um estado que acompanha seus valores; a coleta é interrompida quando o aplicativo vai para segundo plano;
  • linhas 107–125: busca enquanto se digita. [snapshotFlow [ input ]]: o [Flow] dos valores sucessivos de um estado do [Compose]; [debounce(400)], DEBOUNCE: uma entrada só é enviada após 400 ms sem teclas digitadas; [mapLatest]: uma nova entrada CANCELA a busca anterior, se ela não estiver concluída: nenhuma resposta expirada;
  • linhas 119–121: uma corrotina cancelada recebe uma [CancellationException]: ela pode ser registrada, mas deve ser relançada ([throw e]) para que o cancelamento se conclua;
  • linhas 130–132: [produceState]: uma corrotina que PRODUZ um estado (aqui, um valor que chega após um segundo).

Image

Image

À esquerda, na inicialização; à direita, depois de digitar rapidamente “pel”, “du” e depois “dup”: apenas as digitações seguidas de uma pausa dispararam uma busca, e a tela mostra o resultado da última.

6.2. Exemplo 20: um estado compartilhado

Um “store” é um estado que vive FORA das telas, como UMA ÚNICA instância, compartilhada por todos que o leem. O Exemplo 14 fazia isso manualmente; o [Android] fornece o seguinte para esse fim: um objeto criado sob demanda ([viewModel()]), depois entregue de forma idêntica a todos que o solicitam, e que é recriado quando a activity muda (rotação da tela, mudança de idioma). É o equivalente dos pacotes [provider] ou [riverpod] do [Flutter].

// =========================================================================
// ex20/stores/Cart.kt - um ESTADO COMPARTILHADO, em um ViewModel
// -------------------------------------------------------------------------
// Um "store" é um estado que vive FORA das telas, em UMA ÚNICA
// cópia, compartilhada por todos que o leem. O exemplo 14 fez isso
// à mão (CompositionLocal); o Android fornece o ViewModel para isso:
//   - um objeto criado na PRIMEIRA solicitação, depois devolvido de forma idêntica a
//     todas as funções da activity que o pedem: viewModel();
//   - que SOBREVIVE à recriação da activity (rotação da tela,
//     mudança de idioma): ele só é destruído quando a activity é
//     fechada de vez.
// Organização usual:
//   - o ESTADO: um MutableStateFlow PRIVADO, um valor observável; fora, só
//     se vê uma versão somente leitura dele (StateFlow);
//   - as AÇÕES: funções, as únicas que modificam o estado;
//   - os valores calculados: outros StateFlows, deduzidos do primeiro (map),
//     que SÓ mudam se seu valor mudar.
// =========================================================================
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 DEDUZIDOS: stateIn faz deles StateFlows, que vivem enquanto
    // o ViewModel viver (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: substitui o valor por um novo, calculado a partir do antigo
    fun add(item: Item) = _items.update { it + item }

    fun clear() {
        _items.value = emptyList()
    }
}
  • linhas 34–35: o ESTADO: um [MutableStateFlow] PRIVADO, um valor observável; externamente, apenas uma versão somente leitura ([StateFlow]) é visível;
  • linhas 39–40: valores DEDUZIDOS: [map], depois [stateIn], que por sua vez cria [StateFlow] que existem enquanto o [ViewModel] existir ([viewModelScope]). Um [StateFlow] só emite se seu valor MUDAR;
  • Linhas 43–46: as AÇÕES são as únicas que modificam o estado; [update] substitui o valor por um novo, calculado a partir do antigo.

Para que os dados sobrevivam ao ENCERRAMENTO do aplicativo, é preciso armazená-los no dispositivo. A biblioteca [DataStore] do [Jetpack] fornece um pequeno dicionário de chave para valor, armazenado em um arquivo específico do aplicativo:

// =========================================================================
// ex20/stores/Preferences.kt - um estado que sobrevive à parada
// -------------------------------------------------------------------------
// Para que um dado sobreviva à parada do aplicativo, ele deve ser armazenado
// NO DISPOSITIVO. A biblioteca Jetpack DataStore oferece um pequeno
// dicionário chave -> valor (Boolean, Int, Float, String...), específico do
// aplicativo e mantido em um arquivo do celular:
//   - a leitura é um Flow: ele emite os valores armazenados (lidos
//     de forma assíncrona, sem bloquear a tela), depois cada novo valor;
//   - a escrita é uma função suspend (edit).
// NUNCA armazene dados sensíveis nele (senha, token): eles são
// gravados em texto puro.
// =========================================================================
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

// O arquivo de preferências do exemplo: uma propriedade de extensão de
// Context, delegada a preferencesDataStore (um único DataStore por arquivo)
val Context.storage: DataStore<Preferences> by preferencesDataStore(name = "example20")

// o que é armazenado
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")

    // o que o dispositivo armazenou, senão os valores padrão
    val settings: Flow<Settings> = storage.data.map { p -> Settings(p[darkKey] ?: false, p[sizeKey] ?: 16f) }

    // um parâmetro nomeado opcional por preferência: só o que é informado é alterado
    suspend fun update(dark: Boolean? = null, size: Float? = null) {
        storage.edit { p ->
            if (dark != null) p[darkKey] = dark
            if (size != null) p[sizeKey] = size
        }
    }
}
  • linha 28: O arquivo de preferências DO exemplo: uma propriedade de extensão de [Context], delegada a [preferencesDataStore] (apenas um [DataStore] por arquivo);
  • linha 38: a operação de leitura é um [Flow]: ele emite os valores armazenados (lidos sem bloquear a tela) e depois cada novo valor;
  • linhas 41–44: a operação de escrita é uma função suspensa ([edit]). Dados sensíveis (senhas, tokens) NUNCA são armazenados ali: seriam gravados em texto simples.

Componentes que usam o carrinho de compras:

// =========================================================================
// ex20/components/Components.kt - três componentes do exemplo 20
// -------------------------------------------------------------------------
// viewModel(): o Cart da activity, criado na primeira solicitação, depois
// o MESMO para todos que o pedem.
// =========================================================================
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))

// ADICIONA ao carrinho compartilhado: a loja não LÊ o carrinho, ela
// não é recomposta quando o carrinho muda
@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})")
                }
            }
        }
    }
}

// LÊ o mesmo carrinho: apenas a contagem e o total (recomposto
// somente se um dos dois mudar)
@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") }
        }
    }
}

// um estado LOCAL (rememberSaveable), que desaparece com o componente...
// a menos que seja colocado em um 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)") } },
        )
    }
}
  • Linha 42: [cart: Cart = viewModel()]: o carrinho de compras da activity, criado na primeira solicitação. A loja ([Shop]) ADICIONA ao carrinho sem lê-lo: ela não é regenerada quando o carrinho muda;
  • Linhas 60–61: o resumo lê apenas a quantidade e o total; ele só é regenerado se um dos dois mudar;
  • linhas 75–76: um contador (LOCAL), que desaparece junto com o componente.

A tela:

// =========================================================================
// ex20/Ex20Activity.kt - três "escopos" de dados
// -------------------------------------------------------------------------
//   - o estado LOCAL de um componente (LocalCounter) desaparece com ele;
//   - o estado de um STORE (o carrinho, um ViewModel) é compartilhado por todos
//     os componentes e sobrevive à remoção deles, e até a uma rotação da
//     tela - mas não à parada do aplicativo;
//   - o estado armazenado no dispositivo (as preferências, DataStore) sobrevive
//     à parada.
// E o SaveableStateHolder: ele MANTÉM o estado local (rememberSaveable)
// de um conteúdo removido da tela e o devolve se ele voltar.
// Desmarque e marque de novo "show the area", depois pare e reinicie
// o aplicativo: 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: o objeto é criado no primeiro uso (o contexto do aplicativo
    // ainda não existe quando a activity é construída)
    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) {
    // as preferências armazenadas: null enquanto não tiverem sido lidas
    val settings by preferences.settings.collectAsStateWithLifecycle(initialValue = null)
    val s = settings ?: return // nada a exibir antes da leitura (alguns milissegundos)
    val scope = rememberCoroutineScope()

    // o tema escuro, ou o claro
    ExamplesTheme(dark = s.dark) {
        // o tamanho do texto: fontScale multiplica o tamanho de TODOS os 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) }
    // o guardião dos estados dos conteúdos removidos
    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) {
            // removido: esses componentes desaparecem, com seu estado local
            Shop()
            CartSummary()
            LocalCounter("Local state")
            // também removido, mas seu estado é MANTIDO por keptStates, sob a chave "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()
    }
}
  • linha 54: [by lazy]: o objeto é criado no primeiro uso (o contexto do aplicativo ainda não existe quando a activity é construída);
  • linhas 66–67: as preferências são lidas; [?: return]: nada a exibir até que tenham sido lidas (alguns milissegundos);
  • linhas 71–79: o tema escuro ou claro e o tamanho do texto (TODOS os textos: [fontScale] e [LocalDensity]); alterar uma preferência inicia uma corrotina;
  • Linhas 89–112: [rememberSaveableStateHolder]: um guardião que SALVA o estado local ([rememberSaveable]) do conteúdo removido da tela e o restaura se o conteúdo voltar.

Image

Image

Image

À esquerda, dois itens e cliques nos dois contadores; no meio, tema escuro e área oculta: o resumo fora da área continua mostrando o carrinho de compras; à direita, a área exibida novamente: o carrinho está intacto, o contador local voltou a 0 e o contador salvo voltou ao valor original. Pare e reinicie o aplicativo: somente as preferências (tema, tamanho do texto) foram preservadas.