Skip to content

6. Asynchrone Verarbeitung und gemeinsamer Zustand

6.1. Beispiel 19: Coroutines, Flow und Timer

Vieles geschieht „später“: Timer-Ticks, Tastenanschläge, die Antwort eines Servers. Wo [Dart] sein [Future] und [Stream] hat, hat [Kotlin] die COROUTINES:

  • Eine [suspend]-Funktion kann WARTEN ([delay], eine Serverantwort ...), ohne das Smartphone einzufrieren: Während des Wartens bleibt der Bildschirm aktiv. Sie liefert später EINEN Wert: Das entspricht einer Funktion [async], die ein [Future] zurückgibt;
  • ein [Flow<T>] ist eine FOLGE von Werten über die Zeit, die mit Operatoren ([map], [debounce] ...) transformiert werden: das Äquivalent eines [Stream];
  • Eine Coroutine wird in einem SCOPE gestartet ([LaunchedEffect], [rememberCoroutineScope], [viewModelScope] ...); sie wird ABGEBROCHEN, wenn ihr Scope endet.
// =========================================================================
// ex19/Ex19Activity.kt - Coroutinen, Flow, Timer
// -------------------------------------------------------------------------
// Viele Dinge geschehen "später": die Ticks eines Timers, die
// Tastendrücke, die Antwort eines Servers. Kotlin hat dafür
// COROUTINEN:
//   - eine "suspend"-Funktion kann WARTEN (delay, die Antwort eines
//     Servers ...), ohne das Smartphone zu blockieren: Während des Wartens
//     lebt der Bildschirm weiter. Sie gibt EINEN Wert zurück, später;
//   - ein Flow<T> ist eine FOLGE von Werten über die Zeit (Ticks,
//     Eingaben ...), mit Operatoren transformiert (map, debounce ...);
//   - eine Coroutine wird in einem SCOPE gestartet: LaunchedEffect,
//     rememberCoroutineScope ...; sie wird abgebrochen, wenn ihr Scope verschwindet.
// Compose kann einen Flow anzeigen und sich bei jedem Wert rekomponieren:
// 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")

// ein simulierter "Server": eine SUSPEND-Funktion, deren Antwort
// nach einer zufälligen Verzögerung eintrifft
suspend fun search(text: String): List<String> {
    delay(200L + Random.nextLong(600))
    return doctors.filter { it.lowercase().contains(text) }
}

// 1. ein mit dem Builder flow { } erzeugter Flow: Jedes emit SENDET einen
// Wert an den, der ihn sammelt
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")

    // der Flow wird EINMAL erzeugt (remember): Ohne das würde jede Rekomposition
    // den Countdown neu starten!
    val countdownFlow = remember { countdown(20) }
    // collectAsStateWithLifecycle: ein Zustand, der den Werten des Flows folgt
    // (null vor dem ersten); die Erfassung stoppt, wenn die Anwendung
    // in den Hintergrund geht
    val remaining by countdownFlow.collectAsStateWithLifecycle(initialValue = null)

    // 2. die Suche während der Eingabe
    var input by remember { mutableStateOf("") }
    var results by remember { mutableStateOf(listOf<String>()) }
    LaunchedEffect(Unit) {
        // snapshotFlow: ein Flow der aufeinanderfolgenden Werte eines Compose-Zustands
        snapshotFlow { input }
            // das DEBOUNCE: Eine Eingabe wird erst nach 400 ms ohne Tastendruck weitergegeben
            .debounce(400)
            .map { it.trim().lowercase() }
            // mapLatest: Eine neue Eingabe BRICHT die vorherige Suche ab,
            // wenn sie nicht beendet ist: keine veraltete Antwort
            .mapLatest { text ->
                // weniger als zwei Buchstaben: keine Suche, kein Ergebnis
                if (text.length < 2) return@mapLatest emptyList()
                trace("search sent: \"$text\"")
                try {
                    search(text)
                } catch (e: CancellationException) {
                    trace("search cancelled (stale): \"$text\"")
                    throw e // eine abgebrochene Coroutine muss abgebrochen bleiben
                }
            }
            // collect: verarbeitet die Werte des Flows, einen nach dem anderen
            .collect { results = it }
    }

    // 3. ein Wert, der nach einer Sekunde eintrifft: produceState startet eine
    // Coroutine, die einen Zustand ERZEUGT
    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)
                // solange der Wert nicht eingetroffen ist: der Wartetext
                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) }
    }
}
  • Zeilen 65–67: ein simulierter „Server“: eine suspendierte Funktion, deren Antwort nach einer zufälligen Verzögerung eintrifft;
  • Zeilen 72–75: ein [Flow], erzeugt mit [flow [ ... ]]: Jedes [emit] sendet einen Wert an den, der ihn sammelt; [downTo]: eine absteigende Schleife;
  • Zeilen 96–100: Der [Flow] wird EINMAL erzeugt ([remember]): Andernfalls würde jede Recomposition den Countdown neu starten! [collectAsStateWithLifecycle] erzeugt tatsächlich einen Zustand, der seinen Werten folgt; das Sammeln stoppt, wenn die App in den Hintergrund geht;
  • Zeilen 107–125: Suche während der Eingabe. [snapshotFlow [ input ]]: der [Flow] der aufeinanderfolgenden Werte eines [Compose]-Zustands; [debounce(400)], DEBOUNCE: Eine Eingabe wird erst nach 400 ms ohne Tastenanschläge gesendet; [mapLatest]: Eine neue Eingabe BRICHT die vorherige Suche ab, falls diese nicht abgeschlossen ist: keine veraltete Antwort;
  • Zeilen 119–121: Eine abgebrochene Coroutine erhält eine [CancellationException]: Sie kann protokolliert werden, muss aber erneut ausgelöst werden ([throw e]), damit der Abbruch abgeschlossen wird;
  • Zeilen 130–132: [produceState]: eine Coroutine, die einen Zustand ERZEUGT (hier ein Wert, der nach einer Sekunde eintrifft).

Image

Image

Links beim Start; rechts, nachdem schnell „pel“, „du“ und dann „dup“ getippt wurde: Nur die Tastenanschläge, auf die eine Pause folgte, haben eine Suche ausgelöst, und die Anzeige zeigt das Ergebnis der letzten.

6.2. Beispiel 20: Ein gemeinsamer Zustand

Ein „Store“ ist ein Zustand, der AUSSERHALB der Bildschirme lebt, als EINE einzige Instanz, die von allen geteilt wird, die ihn lesen. Beispiel 14 hat das manuell gemacht; [Android] stellt dafür Folgendes bereit: ein auf Anforderung erzeugtes Objekt ([viewModel()]), das dann jedem, der es anfordert, identisch geliefert wird und das bei einem Activity-Wechsel (Bildschirmdrehung, Sprachwechsel) erhalten bleibt. Das entspricht den Paketen [provider] oder [riverpod] von [Flutter].

// =========================================================================
// ex20/stores/Cart.kt - ein GEMEINSAMER ZUSTAND in einem ViewModel
// -------------------------------------------------------------------------
// Ein "Store" ist ein Zustand, der AUSSERHALB der Bildschirme lebt, in EINER einzigen
// Kopie, die von allen geteilt wird, die ihn lesen. Beispiel 14 hat das
// von Hand gemacht (CompositionLocal); Android stellt dafür das ViewModel bereit:
//   - ein Objekt, das bei der ERSTEN Anfrage erzeugt und dann identisch an
//     alle Funktionen der Activity zurückgegeben wird, die es anfordern: viewModel();
//   - das die Neuerzeugung der Activity ÜBERSTEHT (Bildschirmdrehung,
//     Sprachwechsel): Es wird erst zerstört, wenn die Activity endgültig
//     geschlossen wird.
// Übliche Organisation:
//   - der ZUSTAND: ein PRIVATER MutableStateFlow, ein beobachtbarer Wert; nach außen ist nur
//     eine schreibgeschützte Version davon sichtbar (StateFlow);
//   - die AKTIONEN: Funktionen, die als einzige den Zustand ändern;
//   - die berechneten Werte: weitere StateFlows, aus dem ersten abgeleitet (map),
//     die sich NUR ändern, wenn sich ihr Wert ändert.
// =========================================================================
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()

    // ABGELEITETE Werte: stateIn macht daraus StateFlows, die so lange leben
    // wie das 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: ersetzt den Wert durch einen neuen, aus dem alten berechneten
    fun add(item: Item) = _items.update { it + item }

    fun clear() {
        _items.value = emptyList()
    }
}
  • Zeilen 34–35: der ZUSTAND: ein PRIVATER [MutableStateFlow], ein beobachtbarer Wert; nach außen ist nur eine schreibgeschützte Version ([StateFlow]) sichtbar;
  • Zeilen 39–40: ABGELEITETE Werte: [map], dann [stateIn], das wiederum [StateFlow] erzeugt, die so lange existieren wie das [ViewModel] ([viewModelScope]). Ein [StateFlow] emittiert nur, wenn sich sein Wert ÄNDERT;
  • Zeilen 43–46: Die AKTIONEN sind die Einzigen, die den Zustand ändern; [update] ersetzt den Wert durch einen neuen, aus dem alten berechneten.

Damit Daten das BEENDEN der Anwendung überleben, müssen sie auf dem Gerät gespeichert werden. Die Bibliothek [DataStore] von [Jetpack] stellt ein kleines Wörterbuch von Schlüsseln zu Werten bereit, das in einer für die Anwendung spezifischen Datei gespeichert wird:

// =========================================================================
// ex20/stores/Preferences.kt - ein Zustand, der das Beenden übersteht
// -------------------------------------------------------------------------
// Damit ein Datum das Beenden der Anwendung übersteht, muss es
// AUF DEM GERÄT gespeichert werden. Die Bibliothek Jetpack DataStore bietet ein kleines
// Schlüssel-Wert-Wörterbuch (Boolean, Int, Float, String ...), spezifisch für die
// Anwendung und in einer Datei des Smartphones gehalten:
//   - Lesen ist ein Flow: Er liefert die gespeicherten Werte (asynchron
//     gelesen, ohne den Bildschirm zu blockieren), dann jeden neuen Wert;
//   - Schreiben ist eine suspend-Funktion (edit).
// Speichern Sie dort NIEMALS sensible Daten (Passwort, Token): Sie werden
// im Klartext geschrieben.
// =========================================================================
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

// DIE Einstellungsdatei des Beispiels: eine Erweiterungseigenschaft von
// Context, delegiert an preferencesDataStore (ein einziger DataStore pro Datei)
val Context.storage: DataStore<Preferences> by preferencesDataStore(name = "example20")

// was gespeichert ist
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")

    // was das Gerät gespeichert hat, andernfalls die Standardwerte
    val settings: Flow<Settings> = storage.data.map { p -> Settings(p[darkKey] ?: false, p[sizeKey] ?: 16f) }

    // ein optionaler benannter Parameter pro Einstellung: Nur das Angegebene wird geändert
    suspend fun update(dark: Boolean? = null, size: Float? = null) {
        storage.edit { p ->
            if (dark != null) p[darkKey] = dark
            if (size != null) p[sizeKey] = size
        }
    }
}
  • Zeile 28: DIE Einstellungsdatei des Beispiels: eine Erweiterungseigenschaft von [Context], delegiert an [preferencesDataStore] (nur ein [DataStore] pro Datei);
  • Zeile 38: Der Lesevorgang ist ein [Flow]: Er gibt die gespeicherten Werte aus (ohne den Bildschirm zu blockieren gelesen), dann jeden neuen Wert;
  • Zeilen 41–44: Der Schreibvorgang ist eine suspendierte Funktion ([edit]). Sensible Daten (Passwörter, Token) werden dort NIEMALS gespeichert: Sie würden im Klartext geschrieben.

Komponenten, die den Warenkorb verwenden:

// =========================================================================
// ex20/components/Components.kt - drei Komponenten von Beispiel 20
// -------------------------------------------------------------------------
// viewModel(): der Cart der Activity, bei der ersten Anfrage erzeugt und dann
// DERSELBE für alle, die ihn anfordern.
// =========================================================================
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))

// FÜGT dem gemeinsamen Warenkorb HINZU: Der Shop LIEST den Warenkorb nicht, er
// wird nicht rekomponiert, wenn sich der Warenkorb ändert
@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})")
                }
            }
        }
    }
}

// LIEST denselben Warenkorb: nur die Anzahl und die Summe (rekomponiert
// nur, wenn sich eines von beiden ändert)
@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") }
        }
    }
}

// ein LOKALER Zustand (rememberSaveable), der mit der Komponente verschwindet ...
// es sei denn, er steht in einem SaveableStateProvider (vgl. 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)") } },
        )
    }
}
  • Zeile 42: [cart: Cart = viewModel()]: der Warenkorb der Activity, bei der ersten Anforderung erzeugt. Der Shop ([Shop]) FÜGT dem Warenkorb etwas hinzu, ohne ihn zu lesen: Er wird nicht neu erzeugt, wenn sich der Warenkorb ändert;
  • Zeilen 60–61: Die Zusammenfassung liest nur die Menge und den Gesamtbetrag; sie wird nur neu erzeugt, wenn sich einer von beiden ändert;
  • Zeilen 75–76: ein (LOKALER) Zähler, der zusammen mit der Komponente verschwindet.

Der Bildschirm:

// =========================================================================
// ex20/Ex20Activity.kt - drei "Gültigkeitsbereiche" von Daten
// -------------------------------------------------------------------------
//   - der LOKALE Zustand einer Komponente (LocalCounter) verschwindet mit ihr;
//   - der Zustand eines STORES (der Warenkorb, ein ViewModel) wird von allen
//     Komponenten geteilt und übersteht ihre Entfernung und sogar eine Drehung
//     des Bildschirms - aber nicht das Beenden der Anwendung;
//   - der auf dem Gerät gespeicherte Zustand (die Einstellungen, DataStore) übersteht
//     das Beenden.
// Und der SaveableStateHolder: Er BEHÄLT den lokalen Zustand (rememberSaveable)
// eines vom Bildschirm entfernten Inhalts und gibt ihn zurück, wenn er wiederkehrt.
// Deaktivieren und aktivieren Sie "show the area" erneut, beenden Sie dann die Anwendung und starten Sie sie neu:
// vergleichen Sie.
// =========================================================================
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: Das Objekt wird bei der ersten Verwendung erzeugt (der Anwendungskontext
    // existiert noch nicht, wenn die Activity konstruiert wird)
    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) {
    // die gespeicherten Einstellungen: null, solange sie nicht gelesen wurden
    val settings by preferences.settings.collectAsStateWithLifecycle(initialValue = null)
    val s = settings ?: return // vor dem Lesen nichts anzuzeigen (einige Millisekunden)
    val scope = rememberCoroutineScope()

    // das dunkle Theme oder das helle
    ExamplesTheme(dark = s.dark) {
        // die Textgröße: fontScale multipliziert die Größe ALLER Texte
        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) }
    // der Verwalter der Zustände der entfernten Inhalte
    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) {
            // entfernt: Diese Komponenten verschwinden mit ihrem lokalen Zustand
            Shop()
            CartSummary()
            LocalCounter("Local state")
            // ebenfalls entfernt, aber sein Zustand wird von keptStates unter dem Schlüssel "counter" BEHALTEN
            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()
    }
}
  • Zeile 54: [by lazy]: Das Objekt wird bei der ersten Verwendung erzeugt (der Anwendungskontext existiert noch nicht, wenn die Activity aufgebaut wird);
  • Zeilen 66–67: Die Einstellungen werden gelesen; [?: return]: nichts anzuzeigen, bis sie gelesen wurden (einige Millisekunden);
  • Zeilen 71–79: das dunkle oder helle Theme und die Textgröße (ALLE Texte: [fontScale] und [LocalDensity]); Das Ändern einer Einstellung startet eine Coroutine;
  • Zeilen 89–112: [rememberSaveableStateHolder]: ein Verwalter, der den lokalen Zustand ([rememberSaveable]) von Inhalten SPEICHERT, die vom Bildschirm entfernt wurden, und ihn wiederherstellt, wenn der Inhalt zurückkehrt.

Image

Image

Image

Links zwei Artikel und Klicks auf beide Zähler; in der Mitte dunkles Theme und ausgeblendeter Bereich: Die Zusammenfassung außerhalb des Bereichs zeigt weiterhin den Warenkorb; rechts der erneut angezeigte Bereich: Der Warenkorb ist intakt, der lokale Zähler wurde auf 0 zurückgesetzt, und der gespeicherte Zähler hat wieder seinen ursprünglichen Wert. Beenden Sie die Anwendung und starten Sie sie neu: Nur die Einstellungen (Theme, Textgröße) bleiben erhalten.