Skip to content

4. Die Komponenten

Das vorige Kapitel hat die Komponenten von [Material 3] und den Zustand eingeführt. Dieses Kapitel zeigt, wie man EIGENE Komponenten schreibt: ihre Parameter, wie sie ihren Elternteil benachrichtigen, die Komposition, ihr Lebenszyklus, die ihnen aus der Ferne bereitgestellten Daten und wiederverwendbares Verhalten. Bei [Compose] ist eine Komponente eine einfache [@Composable]-Funktion: das Äquivalent der [Flutter]-Widgets.

4.1. Beispiel 10: Komponenten und ihre Parameter

Eine Karte, die einen Arzt anzeigt und auf einem Bildschirm mehrfach verwendet wird. Der Datentyp, den Eltern- und Kindkomponente gemeinsam nutzen:

// der vom Elternteil (DoctorsPage) und vom Kind (DoctorCard) gemeinsam genutzte Datentyp
package fr.stahe.examples.ex10

data class Doctor(
    val id: Int,
    val title: String,
    val firstName: String,
    val lastName: String,
    val specialty: String,
    val available: Boolean,
)

Das KIND, die Karte:

// =========================================================================
// ex10/DoctorCard.kt - eine KIND-Komponente
// -------------------------------------------------------------------------
// Sie erhält ihre Daten von ihrem Elternteil über ihre PARAMETER. Ihr Typ wird
// zur Compile-Zeit geprüft: DoctorCard(doctor = 42, ...) würde abgelehnt.
//   - ein Parameter ohne Standardwert: Das Elternteil MUSS ihn angeben;
//   - compact: Boolean = false: ein optionaler Parameter mit seinem Standard-
//     wert;
//   - modifier: Modifier = Modifier: die Compose-Konvention, das Elternteil
//     kann die Größe, die Abstände ... des Kindes anpassen.
//
// Goldene Regel: Eine Komponente ändert ihre Parameter NIEMALS (sie sind
// val). Die Daten fließen vom Elternteil zum Kind; um eine
// Änderung anzufordern, ruft das Kind eine Funktion auf, die das Elternteil ihm übergeben hat
// (vgl. Beispiel 11). Wenn das Elternteil seine Daten ändert, FÜHRT Compose
// das Kind mit neuen Parametern ERNEUT AUS.
// =========================================================================
package fr.stahe.examples.ex10

import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
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.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp

// der "Stil" der Karte: Konstanten, die für diese Datei PRIVAT sind. Keine andere
// Komponente kann sie sehen oder von ihnen gestört werden
private val initialsColor = Color(0xFF087EA4)

@Composable
fun DoctorCard(doctor: Doctor, rank: Int, modifier: Modifier = Modifier, compact: Boolean = false) {
    // ein aus den Parametern berechneter Wert
    val initials = "${doctor.firstName.first()}${doctor.lastName.first()}"
    Card(
        modifier = modifier.padding(vertical = 4.dp),
        shape = RoundedCornerShape(12.dp),
        // ein grüner Rand für einen verfügbaren Arzt (null: kein Rand)
        border = if (doctor.available) BorderStroke(2.dp, Color(0xFF4CAF50)) else null,
    ) {
        Row(Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
            // ein farbiger Kreis mit den Initialen in der Mitte
            Box(
                contentAlignment = Alignment.Center,
                modifier = Modifier.size(40.dp).background(initialsColor, CircleShape),
            ) {
                Text(initials, color = Color.White, fontWeight = FontWeight.Bold)
            }
            Spacer(Modifier.width(12.dp))
            // weight(1f): Der Text nimmt die gesamte restliche Breite ein
            Column(Modifier.weight(1f)) {
                Text("$rank. ${doctor.title} ${doctor.firstName} ${doctor.lastName}", style = MaterialTheme.typography.titleMedium)
                if (!compact) {
                    Text(doctor.specialty, color = Color.Gray)
                }
            }
        }
    }
}
  • Zeile 43: eine Konstante [private]: nur in dieser Datei sichtbar;
  • Zeile 46: die Parameter der Karte. Ihr Typ wird zur Kompilierzeit geprüft; [doctor] und [rank] sind erforderlich; [compact] ist optional; [modifier: Modifier = Modifier] ist die KONVENTION von [Compose]: Das Elternelement kann Größe, Ränder usw. des Kindes anpassen, das diesen [modifier] auf seine äußerste Komponente anwendet;
  • Zeile 48: ein aus den Parametern berechneter Wert;
  • Zeilen 49–53: [Card], eine [Material]-Karte mit einem grünen Rahmen für einen verfügbaren Arzt ([null]: kein Rahmen);
  • Zeilen 57–61: ein farbiger Kreis ([CircleShape]) mit den Initialen;
  • Zeilen 67–68: Die Fachrichtung wird nur im normalen Modus angezeigt.

Die goldene Regel: Eine Komponente ÄNDERT NIEMALS ihre Parameter (es sind [val]; tatsächlich verbietet der Compiler dies). Die Daten fließen vom Elternelement zum Kind; wenn das Elternelement seine Daten ändert, [Compose] FÜHRT das Kind mit seinen neuen Parametern ERNEUT AUS. Das ELTERNELEMENT:

// =========================================================================
// ex10/Ex10Activity.kt - die ELTERN-Komponente
// -------------------------------------------------------------------------
// Sie verwendet die Komponente DoctorCard so oft wie nötig, wie
// jede Compose-Komponente: Eine @Composable-Funktion ist ein
// WIEDERVERWENDBARER Teil der Oberfläche, mit eigenen Parametern und eigenem
// Stil. Eigene Komponenten zu schreiben ist das Herzstück der Arbeit mit
// Compose: Ein gut geschriebener Bildschirm besteht aus kleinen Komponenten.
// =========================================================================
package fr.stahe.examples.ex10

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.width
import androidx.compose.material3.ListItem
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme

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

@Composable
fun DoctorsPage() {
    var doctors by remember {
        mutableStateOf(
            listOf(
                Doctor(1, "Mme", "Marie", "PELISSIER", "general practitioner", true),
                Doctor(2, "Mr", "Paul", "TATOU", "pediatrician", false),
                Doctor(3, "Melle", "Sophie", "DUPONT", "general practitioner", true),
            ),
        )
    }
    var compact by remember { mutableStateOf(false) }

    ExamplePage("Example 10 - components and their parameters") {
        ListItem(
            headlineContent = { Text("compact display") },
            trailingContent = { Switch(checked = compact, onCheckedChange = { compact = it }) },
        )
        // das Elternteil ändert SEINE Daten: Compose führt diese Funktion erneut aus, die
        // die Kinder mit ihren neuen Parametern erneut aufruft
        OutlinedButton(onClick = { doctors = doctors.map { it.copy(available = !it.available) } }) {
            Text("Toggle availabilities")
        }
        Spacer(Modifier.height(8.dp))
        doctors.forEachIndexed { i, d ->
            // jede Karte erhält IHRE Parameter; key: ihre Identität (vgl. Beispiel 04)
            key(d.id) {
                DoctorCard(doctor = d, rank = i + 1, compact = compact)
            }
        }
        Spacer(Modifier.height(16.dp))
        Text("The same card, in compact version, by setting the parameter:", color = Color.Gray)
        // das Elternteil legt auch die BREITE des Kindes fest, über den Parameter modifier
        DoctorCard(doctor = doctors[0], rank = 1, compact = true, modifier = Modifier.width(260.dp))
    }
}
  • Zeile 63: Das Elternelement ändert SEINE Daten: eine neue Liste, in der jeder Arzt durch eine Kopie ersetzt wird;
  • Zeilen 67–70: ein Eintrag pro Arzt, jeweils mit SEINEN Parametern; [key(d.id)]: die Identität des Arztes (siehe Beispiel 04);
  • Zeile 76: Das Elternelement legt über den Parameter [modifier] auch die BREITE des Kindes fest.

Image

Image

4.2. Beispiel 11: Das Kind benachrichtigt sein Elternelement

Daten werden über Parameter nach unten gereicht; Informationen STEIGEN über Funktionen NACH OBEN, die das Elternelement dem Kind übergibt (per Konvention beginnen ihre Namen mit [on]). Ein erstes Kind, ein Zähler, der einen eigenen Zustand hat und sein Elternelement benachrichtigt:

// =========================================================================
// ex11/Counter.kt - ein Kind, das sein Elternteil BENACHRICHTIGT
// -------------------------------------------------------------------------
// Das Elternteil übergibt ihm FUNKTIONEN als Parameter (per Konvention beginnt ihr
// Name mit "on"), und das Kind ruft sie auf, wenn etwas
// passiert:
//     Counter(label = "Coffees", max = 3, onIncrement = { ... }, onLimit = { ... })
// Der Typ einer Funktion wird (Parameter) -> Ergebnis geschrieben:
//   - (Int) -> Unit : eine Funktion, die einen Int erhält und nichts zurückgibt;
//   - () -> Unit    : eine Funktion ohne Parameter, die nichts zurückgibt.
// =========================================================================
package fr.stahe.examples.ex11

import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun Counter(label: String, max: Int, onIncrement: (Int) -> Unit, onLimit: () -> Unit) {
    // der Zustand, der für diesen Zähler SPEZIFISCH ist: Jeder Counter hat seinen eigenen
    var value by remember { mutableIntStateOf(0) }

    fun plus() {
        if (value >= max) {
            onLimit()
            return
        }
        value++
        // wir BENACHRICHTIGEN das Elternteil und übergeben ihm den neuen Wert
        onIncrement(value)
    }

    Row(verticalAlignment = Alignment.CenterVertically) {
        Text(label, Modifier.width(110.dp))
        OutlinedButton(onClick = { plus() }) { Text("+1") }
        Spacer(Modifier.width(12.dp))
        SuggestionChip(onClick = {}, label = { Text("$value / $max") })
    }
}
  • Zeile 30: Der Typ einer Funktion wird als [(parameters) -> result] geschrieben: [(Int) -> Unit] erhält einen [Int] und gibt nichts zurück; [() -> Unit] hat keine Parameter;
  • Zeile 32: der EIGENE Zustand des Zählers: Jeder [Counter] hat seinen eigenen;
  • Zeilen 34–41: Wenn der Zähler das Maximum erreicht, benachrichtigt er das Elternelement ([onLimit()]); andernfalls erhöht er sich und übermittelt seinen neuen Wert ([onIncrement(value)]).

Ein zweites Kind, eine GESTEUERTE Komponente, die wie die Felder von [Compose] verwendet wird: Der Wert gehört dem Elternelement, das ihn dem Kind übergibt ([value]) und das das Kind bei jedem Tastenanschlag benachrichtigt ([onChange]). Die Komponente hat keinen Zustand:

// =========================================================================
// ex11/TextField.kt - eine GESTEUERTE Komponente
// -------------------------------------------------------------------------
// Ein "selbstgebautes" Formularfeld (Label + Feld + Hilfe + Zeichen-
// zähler), das wie die Compose-Felder verwendet wird:
//     TextField(value = firstName, onChange = { firstName = it }, ...)
// Der Wert gehört dem ELTERNTEIL, das ihn übergibt (value) und das
// bei jedem Tastendruck benachrichtigt wird (onChange). Das Elternteil entscheidet.
// Die Komponente hat keinen Zustand: Sie zeigt an, was ihr übergeben wird. Wenn das
// Elternteil den Wert selbst ändert (Schaltfläche "Clear"), folgt das Feld,
// ohne dass etwas Weiteres zu schreiben ist.
// =========================================================================
package fr.stahe.examples.ex11

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier

@Composable
fun TextField(value: String, onChange: (String) -> Unit, label: String, max: Int, help: String = "") {
    val full = value.length == max
    OutlinedTextField(
        value = value,
        // das Feld weist die überzähligen Zeichen zurück: Der Tastendruck wird nur an das
        // Elternteil weitergegeben, wenn der Text max Zeichen nicht überschreitet
        onValueChange = { text -> if (text.length <= max) onChange(text) },
        label = { Text(label) },
        singleLine = true,
        // der Rand wird rot, wenn das Feld voll ist
        isError = full,
        supportingText = { Text(if (full) "Maximum length reached - ${value.length}/$max" else "$help - ${value.length}/$max") },
        modifier = Modifier.fillMaxWidth(),
    )
}
  • Zeile 28: Der Tastenanschlag wird nur dann an das Elternelement gesendet, wenn der Text [max] Zeichen nicht überschreitet: Das Feld „weist“ überzählige Zeichen „zurück“;
  • Zeilen 32–33: Der Rahmen wird rot, wenn das Feld voll ist, und der Tooltip weist darauf hin.

Das Elternelement:

// =========================================================================
// ex11/Ex11Activity.kt - das Elternteil hört auf seine Kinder
// -------------------------------------------------------------------------
// Die Daten fließen nach unten (Parameter); die Information steigt über
// Funktionen auf, die als Parameter übergeben werden:
//   1. "Ereignisse" des Kindes: onIncrement, onLimit;
//   2. eine gesteuerte Komponente: value + onChange, wie ein TextField.
//      Der Zustand bleibt Eigentum des Elternteils, das ihn selbst ändern kann
//      (Clear).
// =========================================================================
package fr.stahe.examples.ex11

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.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme

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

@Composable
fun ParentPage() {
    var total by remember { mutableIntStateOf(0) }
    var message by remember { mutableStateOf("") }
    var firstName by remember { mutableStateOf("Marie") }
    var lastName by remember { mutableStateOf("PELISSIER") }

    // die von einem Counter aufgerufene Funktion: Sie erhält den Wert, den der Counter weitergibt
    fun onIncrement(label: String, value: Int) {
        total++
        message = "$label is now $value"
    }

    val titleStyle = MaterialTheme.typography.titleSmall
    ExamplePage("Example 11 - the child notifies its parent") {
        Card {
            Column(Modifier.padding(12.dp)) {
                Text("1. Functions called by the children", style = titleStyle)
                Counter(
                    label = "Coffees",
                    max = 3,
                    onIncrement = { v -> onIncrement("Coffees", v) },
                    onLimit = { message = "No more than 3 coffees!" },
                )
                Counter(
                    label = "Glasses of water",
                    max = 8,
                    onIncrement = { v -> onIncrement("Glasses of water", v) },
                    onLimit = { message = "Enough drinking." },
                )
                Spacer(Modifier.height(8.dp))
                Text("Total of clicks: $total - $message", fontStyle = FontStyle.Italic)
            }
        }
        Card {
            Column(Modifier.padding(12.dp)) {
                Text("2. Controlled components", style = titleStyle)
                TextField(value = firstName, onChange = { firstName = it }, label = "First name", max = 20, help = "Required")
                TextField(value = lastName, onChange = { lastName = it }, label = "Last name", max = 20, help = "Displayed in upper case")
                Spacer(Modifier.height(8.dp))
                Text(
                    buildAnnotatedString {
                        append("Data of the parent: ")
                        withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append("$firstName ${lastName.uppercase()}") }
                    },
                )
                Spacer(Modifier.height(8.dp))
                OutlinedButton(onClick = {
                    firstName = ""
                    lastName = ""
                }) { Text("Clear (from the parent)") }
            }
        }
    }
}
  • Zeilen 57–59: die von den Zählern aufgerufene Funktion;
  • Zeilen 68–71: Jeder Zähler erhält zwei Lambda-Ausdrücke; der erste erhält den übergebenen Wert ([v]) und hängt das Label des Zählers daran an;
  • Zeilen 86–87: die gesteuerten Felder: der Wert und das, was bei jedem Tastenanschlag zu tun ist;
  • Zeilen 97–99: Das Elternelement ändert seine eigenen Daten: Die Felder folgen, ohne dass etwas anderes zu schreiben ist.

Image

Image

Links wurde die maximale Anzahl an Kaffees erreicht, und der Name ist 20 Zeichen lang; rechts nach „Clear (from the parent)“.

4.3. Beispiel 12: Komposition

Die Parameter einer Komponente übergeben DATEN ... aber auch INHALT: Ein Parameter kann eine [@Composable]-Funktion sein, die die Komponente aufruft, wo sie möchte. Das macht [Compose] überall so ([Card], [Scaffold], das [label] eines Feldes ...). Ein erstes Template, eine Karte mit drei Slots:

// =========================================================================
// ex12/Card.kt - ein wiederverwendbares TEMPLATE
// -------------------------------------------------------------------------
// Die Parameter einer Komponente übergeben DATEN ... aber auch
// INHALT: Ein Parameter kann eine @Composable-Funktion sein, die die
// Komponente aufruft, wo sie will. Compose nutzt das überall: den Inhalt
// einer Card, die topBar eines Scaffold, das Label eines Feldes ...
//   - content: per Konvention der LETZTE Parameter, der "Haupt"-
//     Inhalt. Er wird nach den Klammern des Aufrufs geschrieben:
//         Card(color = ...) { Text("the content") }
//   - header, footer: weitere Stellen ("Slots"), vom
//     Elternteil bereitgestellt; der Header hat einen Standardinhalt, der Footer ist optional.
// Die Card legt den Rahmen fest (Rand, Header, Footer), das Elternteil liefert, was
// hineinkommt.
// =========================================================================
package fr.stahe.examples.ex12

import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.ProvideTextStyle
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp

@Composable
fun Card(
    color: Color? = null, // "?": optional (standardmäßig null)
    header: @Composable () -> Unit = { Text("Untitled") },
    footer: (@Composable () -> Unit)? = null,
    content: @Composable () -> Unit,
) {
    val fill = color ?: Color(0xFFE0E0E0) // "?:": die Farbe, andernfalls dieses Grau
    Card(
        modifier = Modifier.padding(vertical = 4.dp),
        shape = RoundedCornerShape(8.dp),
        border = BorderStroke(1.dp, fill),
    ) {
        Column {
            Box(Modifier.fillMaxWidth().background(fill).padding(10.dp)) {
                // ProvideTextStyle: der Stil ALLER Texte des Headers,
                // unabhängig vom vom Elternteil bereitgestellten Inhalt
                ProvideTextStyle(TextStyle(color = if (color == null) Color.Black else Color.White, fontWeight = FontWeight.Bold)) {
                    header()
                }
            }
            Box(Modifier.padding(10.dp)) { content() }
            // kein Footer angegeben: überhaupt kein Footer
            if (footer != null) {
                Box(Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp)) {
                    ProvideTextStyle(TextStyle(color = Color.Gray, fontSize = 12.sp)) { footer() }
                }
            }
        }
    }
}
  • Zeilen 38–41: drei Inhaltsparameter: [header] mit Standardinhalt; [footer], OPTIONAL ([(@Composable () -> Unit)?]: eine Funktion oder [null]); [content], der letzte, der beim Aufruf hinter den runden Klammern geschrieben wird;
  • Zeilen 53–54: [ProvideTextStyle] legt den Stil ALLER Texte des Headers fest, unabhängig vom Inhalt, den das Elternelement liefert;
  • Zeilen 59–61: kein Footer übergeben, also überhaupt kein Footer.

Ein zweites Template, eine GENERISCHE Tabelle: Sie kann die Zeilen durchlaufen, aber nicht EINE Zelle anzeigen; das Elternelement sagt ihr, was zu tun ist, indem es die Spalten beschreibt:

// =========================================================================
// ex12/DataTable.kt - eine GENERISCHE Tabelle
// -------------------------------------------------------------------------
// DataTable<T> ist eine generische Komponente: Sie zeigt Zeilen
// beliebigen Typs T an. Sie weiß, wie man die Zeilen durchläuft, aber nicht, wie man
// EINE Zelle anzeigt: Das sagt ihr das Elternteil, indem es seine
// Spalten beschreibt. Jede TableColumn<T> hat einen Titel, eine relative Breite (weight) und
// eine @Composable-FUNKTION, cell(row, index), die ihre Zelle anzeigt.
// Der vom Elternteil bereitgestellte Inhalt verwendet Daten, die dem
// Kind gehören (die Zeile, ihren Rang): Das ist das Prinzip der Compose-Listen
// (LazyColumn und ihre Funktion items { ... }).
// =========================================================================
package fr.stahe.examples.ex12

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.ProvideTextStyle
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp

// eine Spalte einer Tabelle von T
class TableColumn<T>(val title: String, val weight: Float = 1f, val cell: @Composable (row: T, index: Int) -> Unit)

@Composable
fun <T> DataTable(
    rows: List<T>,
    columns: List<TableColumn<T>>,
    // wird angezeigt, wenn es keine Zeile gibt
    empty: @Composable () -> Unit = { Text("No data.") },
) {
    Column {
        // die Zeile der Titel
        Row {
            for (c in columns) {
                Text(c.title, Modifier.weight(c.weight).padding(6.dp), fontWeight = FontWeight.Bold)
            }
        }
        HorizontalDivider()
        if (rows.isEmpty()) {
            Box(Modifier.padding(6.dp)) { ProvideTextStyle(TextStyle(color = Color.Gray)) { empty() } }
        }
        rows.forEachIndexed { i, row ->
            if (i > 0) HorizontalDivider(color = Color(0xFFE0E0E0))
            Row(verticalAlignment = Alignment.CenterVertically) {
                // die Zellen DIESER Zeile, angezeigt von den Funktionen des Elternteils
                for (c in columns) {
                    Box(Modifier.weight(c.weight).padding(6.dp)) { c.cell(row, i) }
                }
            }
        }
    }
}
  • Zeile 31: eine Spalte einer Tabelle mit [T]: ein Titel, eine relative Breite und eine [@Composable]-Funktion, die die Zelle in einer Zeile anzeigt;
  • Zeilen 55–56: die Zellen jeder Zeile, angezeigt von den Funktionen des Elternelements. Der vom Elternelement gelieferte Inhalt verwendet Daten, die dem Kind gehören (die Zeile, ihren Rang): Das ist das Prinzip hinter den Listen in [Compose] ([LazyColumn], siehe die Fallstudie).

Der Bildschirm, der beide Templates verwendet:

// =========================================================================
// ex12/Ex12Activity.kt - die Templates Card und DataTable verwenden
// =========================================================================
package fr.stahe.examples.ex12

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Icon
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme

// ein Zeitfenster; patient: null, wenn das Zeitfenster frei ist
data class Slot(val id: Int, val timeRange: String, val patient: String?)

val slots = listOf(
    Slot(1, "8:00 - 8:20", null),
    Slot(2, "8:20 - 8:40", "Mme Alice DURAND"),
    Slot(3, "8:40 - 9:00", null),
)

data class Person(val id: Int, val name: String)

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

@Composable
fun CompositionPage() {
    val free = slots.count { it.patient == null }
    ExamplePage("Example 12 - composition") {
        // header und footer: als Parameter übergebene @Composable-Funktionen;
        // der Inhalt: das Lambda, das NACH den Klammern geschrieben wird
        Card(
            color = Color(0xFF3F51B5),
            header = {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    Icon(Icons.Default.DateRange, contentDescription = null, tint = Color.White)
                    Spacer(Modifier.width(8.dp))
                    Text("Schedule of Mme PELISSIER")
                }
            },
            footer = { Text("$free free slot(s)") },
        ) {
            // DataTable<Slot>: T wird aus dem Typ von rows abgeleitet
            DataTable(
                rows = slots,
                columns = listOf(
                    // s erhält die Zeile, i ihren Rang
                    TableColumn("#", 0.4f) { _, i -> Text("${i + 1}") },
                    TableColumn("Slot", 1.2f) { s, _ -> Text(s.timeRange) },
                    TableColumn("Status", 1.6f) { s, _ ->
                        if (s.patient != null) {
                            SuggestionChip(onClick = {}, label = { Text(s.patient) })
                        } else {
                            SuggestionChip(
                                onClick = {},
                                label = { Text("Free") },
                                colors = SuggestionChipDefaults.suggestionChipColors(containerColor = Color(0xFFC8E6C9)),
                            )
                        }
                    },
                ),
            )
        }
        Card(color = Color(0xFF4CAF50), header = { Text("A card without a footer") }) {
            Text("The footer is not provided: the card does not display it.")
        }
        // kein Header angegeben: der Standardinhalt, "Untitled"
        Card {
            DataTable(
                rows = emptyList<Person>(),
                columns = listOf(TableColumn("Name") { p, _ -> Text(p.name) }),
                empty = { Text("Nobody for now.") },
            )
        }
    }
}
  • Zeilen 52–61: der Header und der Footer, als Lambda-Funktionen über ihren Namen übergeben; der Inhalt, die Lambda-Funktion, die NACH den runden Klammern geschrieben wird;
  • Zeilen 64–70: [DataTable<Slot>]: [T] wird ABGELEITET und legt den Zeilentyp fest. Jede Spalte erhält die Zeile und ihren Rang; [_]: ein nicht verwendeter Parameter;
  • Zeilen 88–92: eine Karte ohne Header (der Standardinhalt, „Untitled“) und eine leere Tabelle.

Image

4.4. Beispiel 13: Der Lebenszyklus einer Komponente

Eine Komponente BETRITT die Komposition (ihre Funktion wird zum ersten Mal ausgeführt), wird so oft wie nötig NEU ZUSAMMENGESETZT und VERLÄSST die Komposition schließlich für immer. [Compose] stellt „Effekte“ bereit, die an diesen Stellen ausgelöst werden:

  • [LaunchedEffect(key) [ ... ]]: startet beim Betreten eine COROUTINE (Code, der warten kann; siehe Beispiel 19), startet sie neu, wenn sich [key] ändert, und BRICHT sie beim Verlassen AB;
  • [DisposableEffect(key) { ... ; onDispose [ ... ] }]: Code beim Betreten und Aufräumen beim Verlassen.

Eine Uhr, die einen Timer startet ... und ihn stoppen muss, wenn sie verschwindet:

// =========================================================================
// ex13/Clock.kt - eine Komponente, die startet und stoppt
// -------------------------------------------------------------------------
// Das Leben einer Komponente im Bildschirm ("die Komposition"):
//   1. sie BETRITT die Komposition: Ihre Funktion wird zum ersten Mal
//      ausgeführt. Was gestartet werden muss, wird dort gestartet;
//   2. sie wird so oft REKOMPONIERT, wie nötig (ihr Zustand oder ihre Parameter
//      haben sich geändert);
//   3. sie VERLÄSST die Komposition: Sie verschwindet für immer vom Bildschirm.
//      Was gestartet wurde, wird dort GESTOPPT.
// Compose stellt "Effekte" bereit, um zu diesen Zeitpunkten zu handeln, außerhalb
// der Anzeige selbst:
//   - LaunchedEffect(key) { ... }: startet beim Betreten der Komposition eine COROUTINE (Code, der
//     warten kann, vgl. Beispiel 19), startet sie
//     neu, wenn sich key ändert, und BRICHT sie beim Verlassen AB;
//   - DisposableEffect(key) { ...; onDispose { ... } }: Code beim
//     Betreten und seine Bereinigung (onDispose) beim Verlassen.
// Eine Uhr startet einen Timer, wenn sie erscheint ... und muss ihn
// unbedingt stoppen, wenn sie verschwindet: Mit LaunchedEffect
// geschieht das automatisch.
// =========================================================================
package fr.stahe.examples.ex13

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.setValue
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.time.LocalTime
import java.time.format.DateTimeFormatter

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

@Composable
fun Clock(onLog: (String) -> Unit, color: Color = Color(0xFF3F51B5)) {
    var time by remember { mutableStateOf(currentTime()) }
    // die ZULETZT erhaltene Funktion onLog (die Effekte unten leben länger
    // als eine Ausführung der Funktion)
    val log by rememberUpdatedState(onLog)

    // Betreten der Komposition und Verlassen
    DisposableEffect(Unit) {
        log("Clock: entering the composition - timer started")
        onDispose { log("Clock: leaving the composition - timer stopped") }
    }

    // der Timer: eine Coroutine, die beim Verlassen automatisch ABGEBROCHEN wird
    LaunchedEffect(Unit) {
        while (true) {
            delay(1000) // eine Sekunde warten, ohne das Smartphone zu blockieren
            time = currentTime()
        }
    }

    // ein sich ändernder Parameter: Der Effekt wird neu gestartet (außer beim ersten Mal)
    var firstColor by remember { mutableStateOf(true) }
    LaunchedEffect(color) {
        if (firstColor) firstColor = false else log("Clock: recomposed with a new color")
    }

    Text(time, fontSize = 40.sp, fontFamily = FontFamily.Monospace, color = color)
}
  • Zeile 47: [rememberUpdatedState]: Die Effekte dauern länger als ein einzelner Funktionsaufruf; sie müssen die ZULETZT erhaltene Funktion ([onLog]) aufrufen, nicht die erste;
  • Zeilen 50–52: Eintritt in die Komposition und Austritt ([onDispose]);
  • Zeilen 57–59: der Timer, eine Endlosschleife ... in einer Coroutine: [delay(1000)] wartet eine Sekunde, OHNE das Smartphone zu blockieren; die Coroutine wird beim Verlassen der Komposition abgebrochen, und die Schleife mit ihr;
  • Zeile 65: ein Effekt, dessen Schlüssel ein Parameter ist: Er wird erneut ausgelöst, wenn sich die Farbe ändert.

Der Bildschirm:

// =========================================================================
// ex13/Ex13Activity.kt - der Lebenszyklus
// -------------------------------------------------------------------------
//   - if (withClock) Clock(...): Das Anhaken / Abhaken des Kästchens lässt
//     die Uhr die Komposition betreten / verlassen (vgl. Clock.kt);
//     das Ändern ihrer Farbe rekomponiert sie;
//   - ein Feld, das den Fokus erhält, sobald es erscheint (die Tastatur
//     des Smartphones öffnet sich);
//   - der Titel der Anwendung folgt der Eingabe (TaskTitle);
//   - das Leben der ACTIVITY selbst (ihr "Lifecycle"): Auf einem Smartphone
//     geht sie in den Hintergrund (eine andere Anwendung wird geöffnet, der Bildschirm
//     schaltet sich aus) und kommt dann zurück: Wir können darauf reagieren (speichern, einen
//     Timer stoppen ...).
// =========================================================================
package fr.stahe.examples.ex13

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.foundation.selection.toggleable
import androidx.compose.material3.Card
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.common.TaskTitle

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

@Composable
fun LifecyclePage() {
    var withClock by remember { mutableStateOf(true) }
    var red by remember { mutableStateOf(false) }
    val log = remember { mutableStateListOf<String>() }
    var search by remember { mutableStateOf("") }
    var showSearch by remember { mutableStateOf(false) }

    fun trace(message: String) {
        log.add("${currentTime()} $message")
    }

    // das Leben der Activity: Wir ABONNIEREN ihre Zustandsänderungen beim Betreten
    // der Komposition, wir KÜNDIGEN das Abonnement beim Verlassen (onDispose)
    val lifecycle = LocalLifecycleOwner.current.lifecycle
    DisposableEffect(lifecycle) {
        val observer = LifecycleEventObserver { _, event -> trace("Activity: ${event.name}") }
        lifecycle.addObserver(observer)
        onDispose { lifecycle.removeObserver(observer) }
    }

    TaskTitle(if (search.isEmpty()) "Example 13" else "Search: $search")

    ExamplePage("Example 13 - the lifecycle") {
        Card {
            Column(Modifier.padding(12.dp)) {
                CheckboxRow("show the clock", withClock) { withClock = it }
                CheckboxRow("in red", red) { red = it }
                if (withClock) {
                    Clock(onLog = { trace(it) }, color = if (red) Color.Red else Color(0xFF3F51B5))
                }
            }
        }
        Card {
            Column(Modifier.padding(12.dp)) {
                if (!showSearch) {
                    OutlinedButton(onClick = { showSearch = true }) { Text("Search...") }
                } else {
                    // ein Feld, das den Fokus erhält, sobald es erscheint
                    val focus = remember { FocusRequester() }
                    OutlinedTextField(
                        value = search,
                        onValueChange = { search = it },
                        placeholder = { Text("the title follows the input") },
                        modifier = Modifier.fillMaxWidth().focusRequester(focus),
                    )
                    LaunchedEffect(Unit) { focus.requestFocus() }
                }
            }
        }
        Text("Log", style = MaterialTheme.typography.titleSmall)
        log.forEachIndexed { i, line -> Text("${i + 1}. $line", fontSize = 12.sp) }
    }
}

// ein Kontrollkästchen und sein Label; die ganze Zeile reagiert auf das Drücken.
// onChange ist der LETZTE Parameter: Er kann nach den Klammern geschrieben werden
@Composable
fun CheckboxRow(label: String, checked: Boolean, onChange: (Boolean) -> Unit) {
    ListItem(
        modifier = Modifier.toggleable(value = checked, onValueChange = onChange),
        leadingContent = { Checkbox(checked = checked, onCheckedChange = null) },
        headlineContent = { Text(label) },
    )
}
  • Zeilen 74–78: der Lebenszyklus der ACTIVITY selbst: Auf einem Smartphone geht sie in den Hintergrund (eine andere App, der Bildschirm schaltet sich aus) und kommt dann zurück. Wir abonnieren ihre Änderungen ([addObserver]) beim Betreten der Komposition und beenden das Abonnement beim Verlassen;
  • Zeilen 4–89: [if (withClock) Clock(...)]: Wird das Kontrollkästchen deaktiviert, VERLÄSST die Uhr die Komposition; wird es erneut aktiviert, entsteht eine NEUE;
  • Zeilen 99–106: ein Feld, das den Fokus erhält, sobald es erscheint: [LaunchedEffect] läuft NACH der Anzeige, wenn das Feld existiert.

Image

Das Protokoll zeigt die Abfolge: Die Activity wird erstellt, gestartet und fortgesetzt ([ON_CREATE], [ON_START], [ON_RESUME]); die Uhr wird zum Layout hinzugefügt; ihre Farbe ändert sich; dann wird sie deaktiviert und erneut aktiviert.

4.5. Beispiel 14: Die bereitgestellten Daten

Wie lassen sich Daten zwischen weit voneinander entfernten Komponenten teilen, ohne sie von Parameter zu Parameter durch alle Zwischenstationen zu reichen? Mit einem [CompositionLocal], einem Datum, das „lokal zur Komposition“ ist: Es wird einmal DEKLARIERT; eine Komponente stellt es allen ihren Nachfahren bereit ([CompositionLocalProvider]); jeder Nachfahre LIEST es. [Compose] nutzt es selbst: [MaterialTheme.colorScheme], [LocalContext.current], [LocalDensity.current] ... Das entspricht [InheritedWidget] und dem Paket [provider] von [Flutter].

Ein Protokoll, im Vollbild angezeigt:

// =========================================================================
// ex14/providers/Log.kt - ein Datum für die GANZE Anwendung
// -------------------------------------------------------------------------
// Wie teilt man Daten und Funktionen zwischen weit entfernten Komponenten,
// ohne sie von Parameter zu Parameter durch alle
// Zwischenstufen zu reichen? Mit einem CompositionLocal, einem Datum, das "lokal zur
// Komposition" ist:
//   1. es wird einmal DEKLARIERT: val LocalLog = staticCompositionLocalOf<Log> { ... };
//   2. eine hoch im Baum platzierte Komponente STELLT es allen ihren
//      Nachfahren BEREIT: CompositionLocalProvider(LocalLog provides log) { ... };
//   3. jeder Nachfahre, in beliebiger Tiefe, LIEST es:
//      LocalLog.current.
// Das ist der Mechanismus, den Compose selbst verwendet: MaterialTheme.colorScheme,
// LocalContext.current, LocalDensity.current ... sind Lesezugriffe auf
// CompositionLocal.
//
// Das Log selbst ist ein gewöhnliches Objekt, dessen Zustand (seine Zeilen)
// von Compose BEOBACHTET wird (mutableStateListOf): Eine Komponente, die seine
// Zeilen liest, wird rekomponiert, wenn sie sich ändern.
// =========================================================================
package fr.stahe.examples.ex14.providers

import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.staticCompositionLocalOf
import java.time.LocalTime
import java.time.format.DateTimeFormatter

class Log {
    // die beobachtete Liste; nach außen ist sie nur als UNVERÄNDERLICHE List sichtbar
    private val _lines = mutableStateListOf<String>()
    val lines: List<String> get() = _lines

    fun trace(message: String) {
        _lines.add(0, "${LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))} $message")
        if (_lines.size > 6) _lines.removeAt(_lines.lastIndex)
    }
}

// die Deklaration: der Typ des Datums und was passiert, wenn niemand es
// bereitstellt (hier ein expliziter Fehler).
// static: Das bereitgestellte Log ändert sich nie (es ist sein INHALT, der sich ändert)
val LocalLog = staticCompositionLocalOf<Log> { error("LocalLog: no log provided above this component") }
  • Zeilen 30–31: der Zustand des Protokolls, eine beobachtete Liste, die nach außen nur als UNVERÄNDERLICHE [List] zugänglich gemacht wird;
  • Zeile 8: die Deklaration: der Datentyp und was geschieht, wenn niemand ihn bereitstellt (ein expliziter Fehler). [static]: Die bereitgestellten Daten ändern sich nie (es ändert sich ihr INHALT);

Ein Warenkorb, der einem Teil des Bildschirms von einer Provider-Komponente bereitgestellt wird, die ihn erzeugt:

// =========================================================================
// ex14/providers/Cart.kt - ein Datum, das von EINER Komponente bereitgestellt wird
// -------------------------------------------------------------------------
// Der Warenkorb wird nur einem Teil des Baums bereitgestellt: den Komponenten,
// die CartProvider umhüllt (vgl. Ex14Activity.kt). Zwei Provider,
// die an zwei Stellen des Bildschirms platziert sind, würden zwei voneinander unabhängige Warenkörbe ergeben.
// Der Provider ERZEUGT den Warenkorb (remember); er
// verwendet seinerseits das Log.
// =========================================================================
package fr.stahe.examples.ex14.providers

import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.staticCompositionLocalOf

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

class Cart(private val log: Log) {
    private val _items = mutableStateListOf<Item>()
    val items: List<Item> get() = _items

    // ein berechneter Wert: sumOf addiert einen Wert jedes Artikels
    val total: Double get() = _items.sumOf { it.price }

    fun add(item: Item) {
        _items.add(item)
        log.trace("cart: + ${item.label}")
    }

    fun remove(index: Int) {
        log.trace("cart: - ${_items[index].label}")
        _items.removeAt(index)
    }
}

val LocalCart = staticCompositionLocalOf<Cart> { error("LocalCart: no cart provided above this component") }

// der Provider: Er erzeugt den Warenkorb EINMAL und stellt ihn seinem Inhalt bereit
@Composable
fun CartProvider(content: @Composable () -> Unit) {
    val log = LocalLog.current
    val cart = remember { Cart(log) }
    CompositionLocalProvider(LocalCart provides cart, content = content)
}
  • Zeile 25: [total], eine berechnete Eigenschaft; [sumOf] summiert den Wert jedes Artikels;
  • Zeilen 42–45: Der Provider erzeugt den Warenkorb EINMAL ([remember]) und befüllt ihn mit seinem Inhalt; er liest das weiter oben bereitgestellte Protokoll selbst;

Eine Uhr, bereitgestellt mit einer konfigurierbaren Periode:

// =========================================================================
// ex14/providers/Clock.kt - ein PARAMETRISIERTER Provider
// -------------------------------------------------------------------------
// Eine Uhr, deren Aktualisierungsintervall ein Parameter des
// Providers ist: ClockProvider(periodMs = 5000) { ... }.
// Zwei verschachtelte Provider: Eine Komponente liest den, der ihr
// am NÄCHSTEN darüber liegt.
// Diesmal ÄNDERN sich die bereitgestellten Daten (die Uhrzeit, bei jedem Tick):
// compositionLocalOf (und nicht staticCompositionLocalOf). Compose rekomponiert dann nur
// die Komponenten, die die Uhrzeit LESEN.
// Die Uhr stoppt, wenn ihr Provider verschwindet (LaunchedEffect).
// =========================================================================
package fr.stahe.examples.ex14.providers

import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import kotlinx.coroutines.delay
import java.time.LocalDateTime

// der Standardwert: ein eingefrorenes Datum, gelesen von einer Komponente ohne Provider
val LocalClock = compositionLocalOf { LocalDateTime.of(2026, 1, 1, 0, 0) }

@Composable
fun ClockProvider(periodMs: Long = 1000, content: @Composable () -> Unit) {
    var now by remember { mutableStateOf(LocalDateTime.now()) }
    // wenn sich das Intervall ändert, wird die Coroutine abgebrochen und neu gestartet
    LaunchedEffect(periodMs) {
        while (true) {
            delay(periodMs)
            now = LocalDateTime.now()
        }
    }
    CompositionLocalProvider(LocalClock provides now, content = content)
}
  • Zeile 27: Diesmal ÄNDERN sich die bereitgestellten Daten (die Uhrzeit, bei jedem Tick): [compositionLocalOf], nicht [staticCompositionLocalOf]. [Compose] baut dann nur die Komponenten neu auf, die die Uhrzeit LESEN;
  • Zeilen 33–36: Wenn sich die Periode ändert, wird die Coroutine abgebrochen und neu gestartet.

Zwei Nachfahren, die den Warenkorb verwenden:

// ex14/Catalog.kt - ein Nachfahre, der dem Warenkorb HINZUFÜGT
package fr.stahe.examples.ex14

import androidx.compose.foundation.layout.Column
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ShoppingCart
import androidx.compose.material3.Card
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import fr.stahe.examples.ex14.providers.Item
import fr.stahe.examples.ex14.providers.LocalCart

val catalog = listOf(Item("Consultation", 30.0), Item("Vaccine", 12.5), Item("Certificate", 5.0))

@Composable
fun Catalog() {
    // der von ShopPage bereitgestellte Warenkorb (ein Fehler, wenn ihn niemand bereitstellt)
    val cart = LocalCart.current
    Card {
        Column {
            for (item in catalog) {
                ListItem(
                    headlineContent = { Text("${item.label} (€${item.price})") },
                    trailingContent = {
                        IconButton(onClick = { cart.add(item) }) {
                            Icon(Icons.Default.ShoppingCart, contentDescription = "add ${item.label}")
                        }
                    },
                )
            }
        }
    }
}
// =========================================================================
// ex14/CartSummary.kt
// -------------------------------------------------------------------------
// Ein weiterer Nachfahre: DERSELBE Warenkorb wie Catalog, aber SEINE EIGENE
// Uhr, die alle 5 Sekunden aktualisiert wird. Eine Komponente liest nur die
// Provider, die OBERHALB von ihr platziert sind: CartSummary platziert daher einen zweiten
// ClockProvider um seinen Inhalt, den es an eine kleine
// Komponente, Content, übergibt, die die NÄCHSTE Uhr liest: die 5-s-Uhr.
// =========================================================================
package fr.stahe.examples.ex14

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.examples.ex14.providers.ClockProvider
import fr.stahe.examples.ex14.providers.LocalClock
import fr.stahe.examples.ex14.providers.LocalCart

@Composable
fun CartSummary() {
    ClockProvider(periodMs = 5000) { Content() }
}

@Composable
private fun Content() {
    val cart = LocalCart.current
    val now = LocalClock.current // die nächste: die 5-s-Uhr
    Card {
        Column(Modifier.padding(12.dp)) {
            Text(
                "Cart (${cart.items.size} item(s)) - ${now.toLocalTime().withNano(0)}",
                style = MaterialTheme.typography.titleSmall,
            )
            cart.items.forEachIndexed { i, item ->
                Row(verticalAlignment = Alignment.CenterVertically) {
                    Text(item.label)
                    TextButton(onClick = { cart.remove(i) }) { Text("remove") }
                }
            }
            Text("Total: €${cart.total}", fontWeight = FontWeight.Bold)
        }
    }
}
  • Zeilen 29–30: [CartSummary] platziert einen ZWEITEN Uhr-Provider (5 Sekunden) um seinen Inhalt: Eine Komponente liest den NÄCHSTGELEGENEN Uhr-Provider oberhalb von ihr.

Der Bildschirm:

// =========================================================================
// ex14/Ex14Activity.kt - drei Ebenen bereitgestellter Daten
// -------------------------------------------------------------------------
//   - das Log: ganz oben von der Activity dem ganzen Bildschirm bereitgestellt;
//   - der Warenkorb, von ShopPage bereitgestellt: von Catalog und
//     CartSummary gemeinsam genutzt, die DENSELBEN Warenkorb sehen;
//   - die Uhr, von ShopPage (Standardintervall, 1 s) UND von
//     CartSummary (5 s) bereitgestellt: jede ihre eigene.
// =========================================================================
package fr.stahe.examples.ex14

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex14.providers.ClockProvider
import fr.stahe.examples.ex14.providers.CartProvider
import fr.stahe.examples.ex14.providers.Log
import fr.stahe.examples.ex14.providers.LocalClock
import fr.stahe.examples.ex14.providers.LocalLog

class Ex14Activity : ComponentActivity() {
    // das Log: ein mit der Activity erzeugtes Objekt
    private val log = Log()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            // das Log, dem GANZEN Bildschirm bereitgestellt
            CompositionLocalProvider(LocalLog provides log) {
                ExamplesTheme { ShopPage() }
            }
        }
    }
}

// die Uhrzeit der Uhr der Seite: eine kleine Komponente, UNTER dem Provider platziert
@Composable
private fun PageTime() {
    Text("Clock of the page: ${LocalClock.current.toLocalTime().withNano(0)}", color = Color.Gray)
}

@Composable
fun ShopPage() {
    // die Seite liest das Log: Sie wird bei jeder neuen Zeile rekomponiert
    val log = LocalLog.current
    ClockProvider {
        CartProvider {
            ExamplePage("Example 14 - provided data") {
                PageTime()
                Catalog()
                CartSummary()
                Spacer(Modifier.height(12.dp))
                Text("Log (provided to the whole screen)", style = MaterialTheme.typography.titleSmall)
                for (line in log.lines) {
                    Text(line, fontSize = 12.sp)
                }
            }
        }
    }
}
  • Zeilen 43–44: das Protokoll, ein Activity-Objekt, auf dem Bildschirm dargestellt;
  • Zeilen 60–65: die Uhr (1 s) und der Warenkorb, der Seite bereitgestellt; [Catalog] und [CartSummary] sehen DENSELBEN Warenkorb.

Image

4.6. Beispiel 15: Verhalten wiederverwenden

Die Wiederverwendung einer ANZEIGE erfordert das Schreiben einer Komponente. Um ein VERHALTEN (und seinen Zustand) wiederzuverwenden, bietet [Compose] zwei Werkzeuge: eine „Wrapper“-Komponente oder eine [remember...]-Funktion. Ein Wrapper, der seinen Inhalt hervorhebt, wenn er berührt wird:

// =========================================================================
// ex15/Highlighter.kt - ein Verhalten in einer "Wrapper"-Komponente
// -------------------------------------------------------------------------
// Die erste Möglichkeit, ein VERHALTEN (mit seinem Zustand) wiederzuverwenden: eine
// Komponente, die beliebigen Inhalt umhüllt und ihm dieses
// Verhalten hinzufügt:
//     Highlighter(color = ...) { ListItem(...) }
// Diese hebt ihren Inhalt hervor, solange er BERÜHRT wird (der Finger auf
// dem Bildschirm) und, mit einer Maus (Tablet, ChromeOS), solange er
// ÜBERFAHREN wird. Jeder Highlighter hat seinen eigenen Zustand: Zwei Zeilen stören sich nicht.
// =========================================================================
package fr.stahe.examples.ex15

import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.awaitEachGesture
import androidx.compose.foundation.gestures.awaitFirstDown
import androidx.compose.foundation.gestures.waitForUpOrCancellation
import androidx.compose.foundation.hoverable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.interaction.collectIsHoveredAsState
import androidx.compose.foundation.layout.Box
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput

@Composable
fun Highlighter(color: Color = Color(0xFFFFF3CD), content: @Composable () -> Unit) {
    var touched by remember { mutableStateOf(false) }
    // Überfahren mit einer Maus: eine "Interaction Source", deren
    // Zustand "hovered" beobachtet wird
    val interactions = remember { MutableInteractionSource() }
    val hovered by interactions.collectIsHoveredAsState()
    // ein ANIMIERTER Farbwechsel (200 ms)
    val fill by animateColorAsState(if (touched || hovered) color else Color.Transparent, tween(200), label = "fill")
    Box(
        Modifier
            .background(fill)
            .hoverable(interactions)
            // die Kontakte des Fingers, auf der niedrigsten Ebene: Der Finger berührt den Bildschirm,
            // dann hebt er ab (oder die Geste wird abgebrochen). requireUnconsumed = false:
            // auch wenn der Inhalt (eine Schaltfläche) den Druck bereits behandelt hat
            .pointerInput(Unit) {
                awaitEachGesture {
                    awaitFirstDown(requireUnconsumed = false)
                    touched = true
                    waitForUpOrCancellation()
                    touched = false
                }
            },
    ) {
        content()
    }
}
  • Zeilen 38–39: Mauszeiger über der Komponente (Tablet, [ChromeOS]): eine „Interaction Source“, deren Zustand „hovered“ beobachtet wird;
  • Zeile 41: [animateColorAsState]: ein ANIMIERTER Farbwechsel;
  • Zeilen 49–54: Fingerberührungen auf unterster Ebene: Für jede Geste ([awaitEachGesture]) warten wir, bis der Finger den Bildschirm berührt, und dann, bis er sich hebt. [requireUnconsumed = false]: auch wenn der Inhalt (eine Schaltfläche) das Drücken bereits verarbeitet hat.

Eine Komponente mit Animation: eine Schaltfläche, die eine Sekunde lang gedrückt gehalten werden muss, während sich ein Ring füllt:

// =========================================================================
// ex15/LongPressButton.kt - eine Schaltfläche für langes Drücken
// -------------------------------------------------------------------------
//     LongPressButton(durationMs = 1000, onAction = { remove() }) { Text(...) }
// Die Aktion wird nur ausgeführt, wenn die Schaltfläche die
// gesamte Dauer gedrückt gehalten wird: ein Schutz vor versehentlichem Drücken. Ein Ring
// füllt sich während des Drückens.
// Das Füllen ist eine ANIMATION: Ein Animatable ist ein Wert (von 0 bis 1),
// den eine Coroutine Bild für Bild verändert (animateTo). Das Abbrechen der
// Coroutine (der Finger hebt zu früh ab) stoppt die Animation.
// =========================================================================
package fr.stahe.examples.ex15

import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch

@Composable
fun LongPressButton(durationMs: Int = 1000, onAction: () -> Unit, content: @Composable () -> Unit) {
    val progress = remember { Animatable(0f) }
    // der Scope der Coroutinen der Komponente: Sie werden abgebrochen, wenn sie verschwindet
    val scope = rememberCoroutineScope()
    val action by rememberUpdatedState(onAction)

    Row(
        verticalAlignment = Alignment.CenterVertically,
        modifier = Modifier.pointerInput(Unit) {
            detectTapGestures(
                // onPress: Der Finger berührt den Bildschirm; tryAwaitRelease WARTET, bis er abhebt
                onPress = {
                    val filling = scope.launch {
                        progress.animateTo(1f, tween(durationMs, easing = LinearEasing))
                        // die Animation ist bis zum Ende gelaufen: Das Drücken dauerte lange genug
                        progress.snapTo(0f)
                        action()
                    }
                    tryAwaitRelease()
                    // der Finger hebt zu früh ab: Das Füllen wird gestoppt, der Ring leert sich
                    if (filling.isActive) {
                        filling.cancel()
                        scope.launch { progress.animateTo(0f, tween(200)) }
                    }
                },
            )
        },
    ) {
        CircularProgressIndicator(
            progress = { progress.value },
            modifier = Modifier.size(22.dp),
            color = Color.Red,
            strokeWidth = 3.dp,
            trackColor = Color(0xFFFFEBEE),
        )
        Spacer(Modifier.width(8.dp))
        content()
    }
}
  • Zeilen 37–39: ein [Animatable], ein Wert (von 0 bis 1), den eine Coroutine Bild für Bild erhöht; [rememberCoroutineScope]: ein Scope, um Coroutines aus einem Ereignis heraus zu starten;
  • Zeilen 47–58: Der Finger wird aufgesetzt: Die Füllung wird gestartet ([animateTo(1f)], in [durationMs]); erreicht sie das Ende, wird die Aktion ausgeführt. [tryAwaitRelease()] WARTET darauf, dass der Finger gehoben wird: Läuft die Füllung noch, wird sie abgebrochen, und der Ring leert sich.

Eine [remember...]-Funktion, die nach dem Einrichten von Zustand und Effekten ein Objekt ZURÜCKGIBT (das ist die Konvention für [Compose]: [rememberScrollState()], [rememberCoroutineScope()] ...), sieht so aus:

// =========================================================================
// ex15/FocusOnStart.kt - ein Verhalten in einer "remember..."-Funktion
// -------------------------------------------------------------------------
// Die zweite Möglichkeit, ein Verhalten wiederzuverwenden: eine
// @Composable-Funktion, die ein Objekt ZURÜCKGIBT, nachdem sie ihren Zustand und
// ihre Effekte eingerichtet hat. Das ist die Compose-Konvention (rememberScrollState(),
// rememberCoroutineScope() ...): Ihr Name beginnt mit "remember".
//     val focus = rememberFocusOnStart()
//     OutlinedTextField(..., modifier = Modifier.focusRequester(focus))
// Das Feld, das diesen FocusRequester verwendet, erhält den Fokus, sobald der Bildschirm
// angezeigt wird.
// =========================================================================
package fr.stahe.examples.ex15

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.remember
import androidx.compose.ui.focus.FocusRequester

@Composable
fun rememberFocusOnStart(): FocusRequester {
    val focus = remember { FocusRequester() }
    // nach der ersten Anzeige: Das Feld existiert, ihm wird der Fokus gegeben
    LaunchedEffect(Unit) { focus.requestFocus() }
    return focus
}

Der Bildschirm:

// =========================================================================
// ex15/Ex15Activity.kt - Verhalten wiederverwenden
// -------------------------------------------------------------------------
// Drei Compose-Werkzeuge, um ein VERHALTEN (und seinen Zustand) wiederzuverwenden,
// und nicht bloß eine Anzeige:
//   - eine "Wrapper"-Komponente (Highlighter);
//   - eine Komponente, die eine Animation trägt (LongPressButton);
//   - eine "remember..."-Funktion (rememberFocusOnStart).
// =========================================================================
package fr.stahe.examples.ex15

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.material3.ListItem
import androidx.compose.material3.ListItemDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme

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

@Composable
fun BehavioursPage() {
    val doctors = remember { mutableStateListOf("Mme Marie PELISSIER", "Mr Paul TATOU", "Melle Sophie DUPONT") }
    var message by remember { mutableStateOf("") }
    // der von rememberFocusOnStart vorbereitete FocusRequester
    val focus = rememberFocusOnStart()
    var input by remember { mutableStateOf("") }

    ExamplePage("Example 15 - reusing behaviours") {
        OutlinedTextField(
            value = input,
            onValueChange = { input = it },
            placeholder = { Text("this field received the focus on its own") },
            modifier = Modifier.fillMaxWidth().focusRequester(focus),
        )
        Spacer(Modifier.height(12.dp))
        Text("Touch the lines; hold a button down for one second to delete.", color = Color.Gray)
        doctors.forEachIndexed { i, d ->
            key(d) {
                // jede zweite Zeile: die Standardfarbe; die anderen grün
                Highlighter(color = if (i % 2 == 0) Color(0xFFFFF3CD) else Color(0xFFD1E7DD)) {
                    ListItem(
                        // ein transparenter Hintergrund: Der des Highlighters scheint durch
                        colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                        headlineContent = { Text(d) },
                        trailingContent = {
                            LongPressButton(onAction = {
                                doctors.remove(d)
                                message = "$d has been deleted."
                            }) {
                                Text("Delete", color = Color.Red)
                            }
                        },
                    )
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        if (message.isNotEmpty()) {
            Text(message, color = Color(0xFF3F51B5))
        }
    }
}

Image

Image

Links ruht der Finger auf der ersten Zeile: Sie ist hervorgehoben; rechts wurde die Schaltfläche „Delete“ eine Sekunde lang gedrückt gehalten.

4.7. Beispiel 16: Ein wiederverwendbares Bestätigungsfenster

Bei [Compose] ist ein Fenster ([AlertDialog]) eine Komponente wie jede andere: Es wird angezeigt, solange ein Zustand es anfordert. Um eine Frage zu stellen und die Antwort zu liefern, schreiben wir eine kleine Klasse, deren Funktion [confirm] eine SUSPEND-Funktion ist (siehe Beispiel 19):

// =========================================================================
// ex16/Confirmation.kt - "Sind Sie sicher?"
// -------------------------------------------------------------------------
// Mit Compose ist ein Dialog (AlertDialog) eine Komponente wie jede andere:
// Er wird angezeigt, solange ein Zustand ihn verlangt. Um eine Frage zu stellen
// und auf die Antwort zu WARTEN, schreiben wir eine kleine Klasse, Confirmation, deren
// Funktion confirm eine SUSPEND-Funktion ist (suspend, vgl. Beispiel
// 19): Sie öffnet den Dialog und wartet dann, ohne das Smartphone zu blockieren,
// auf die Antwort des Benutzers. Der aufrufende Code lässt sich dann sehr einfach
// in einer Coroutine schreiben:
//
//     if (confirmation.confirm("Delete this doctor?")) { ... }
//
// Das Schließen des Dialogs OHNE Antwort (Drücken außerhalb, die Zurück-Taste
// des Smartphones) wird als "Nein" behandelt.
// Der Dialog selbst wird von ConfirmDialog(confirmation) angezeigt,
// das einmal im Bildschirm platziert wird.
// =========================================================================
package fr.stahe.examples.ex16

import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.graphics.Color
import kotlinx.coroutines.CompletableDeferred

class Confirmation {
    // die gestellte Frage (null: kein Dialog)
    var question by mutableStateOf<String?>(null)
        private set

    // die erwartete Antwort: ein Wert, der SPÄTER eintrifft
    private var answer: CompletableDeferred<Boolean>? = null

    suspend fun confirm(message: String): Boolean {
        val waiting = CompletableDeferred<Boolean>()
        answer = waiting
        question = message // der Dialog wird angezeigt
        try {
            return waiting.await() // die Coroutine ist bis zur Antwort suspendiert
        } finally {
            question = null // der Dialog verschwindet
        }
    }

    fun respond(yes: Boolean) {
        answer?.complete(yes)
    }
}

// remember: Die Confirmation übersteht die Rekompositionen des Bildschirms
@Composable
fun rememberConfirmation(): Confirmation = remember { Confirmation() }

@Composable
fun ConfirmDialog(confirmation: Confirmation) {
    // ?: return: keine Frage, nichts anzuzeigen
    val question = confirmation.question ?: return
    // AlertDialog: ein Material-Dialog mit Titel, Inhalt und Schaltflächen
    AlertDialog(
        onDismissRequest = { confirmation.respond(false) }, // ohne Antwort geschlossen: "Nein"
        title = { Text("Confirmation") },
        text = { Text(question) },
        dismissButton = { TextButton(onClick = { confirmation.respond(false) }) { Text("No, go back") } },
        confirmButton = {
            Button(
                onClick = { confirmation.respond(true) },
                colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFD32F2F)),
            ) { Text("Yes, confirm") }
        },
    )
}
  • Zeilen 36–37: die gestellte Frage ([null]: kein Fenster), ein beobachteter Zustand;
  • Zeilen 42–49: [CompletableDeferred]: ein Wert, der SPÄTER eintrifft. [confirm] zeigt das Fenster an und WARTET dann auf die Antwort ([await()]), ohne das Smartphone einzufrieren; [finally]: In jedem Fall verschwindet das Fenster;
  • Zeilen 53–54: Eine Schaltfläche des Fensters LIEFERT die Antwort: Die wartende Coroutine wird fortgesetzt;
  • Zeilen 63–68: das Fenster: nichts, wenn es keine Frage gibt ([?: return]); Das Schließen ohne Antwort (Tippen außerhalb des Fensters oder Drücken der Zurück-Taste des Smartphones) wird als „Nein“ gewertet.

Der Bildschirm: eine Kontaktliste und nach jedem Löschen eine Popup-Meldung ([Snackbar]) mit einer Schaltfläche „Rückgängig“ – eine weitere, auf Mobilgeräten sehr verbreitete Methode, den Benutzer vor einem Fehler zu schützen:

// =========================================================================
// ex16/Ex16Activity.kt - den Bestätigungsdialog verwenden
// -------------------------------------------------------------------------
// Ein Löschvorgang, dann eine kurzlebige Meldung am unteren Bildschirmrand (Snackbar),
// mit einer Schaltfläche "Undo": die andere, auf dem Smartphone sehr verbreitete Art,
// den Benutzer vor einem Fehler zu schützen.
// Die beiden Wartevorgänge (die Antwort auf die Frage, die Schaltfläche "Undo" der
// Meldung) laufen in einer COROUTINE, die von rememberCoroutineScope gestartet wird.
// =========================================================================
package fr.stahe.examples.ex16

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.SnackbarDuration
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.SnackbarResult
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.launch

data class Contact(val id: Int, val name: String)

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

@Composable
fun ContactsPage() {
    val contacts = remember { mutableStateListOf(Contact(1, "Jean MARTIN"), Contact(2, "Alice DURAND"), Contact(3, "Luc GERMAN")) }
    var message by remember { mutableStateOf("") }
    val confirmation = rememberConfirmation()
    // der Bereich für die kurzlebigen Meldungen und ein Scope, um Coroutinen zu starten
    val messages = remember { SnackbarHostState() }
    val scope = rememberCoroutineScope()

    // eine suspend-Funktion: Sie "wartet" auf die Antwort des Benutzers
    suspend fun remove(c: Contact) {
        if (!confirmation.confirm("Delete the contact ${c.name}?")) {
            message = "Deletion abandoned."
            return
        }
        val position = contacts.indexOf(c)
        contacts.remove(c)
        message = "${c.name} has been deleted."
        // eine kurzlebige Meldung am unteren Bildschirmrand; showSnackbar wartet auf ihr
        // Verschwinden und gibt an, ob ihre Schaltfläche berührt wurde
        val result = messages.showSnackbar("${c.name} deleted", actionLabel = "Undo", duration = SnackbarDuration.Short)
        if (result == SnackbarResult.ActionPerformed) {
            contacts.add(position, c)
            message = "${c.name} is back."
        }
    }

    suspend fun removeAll() {
        if (confirmation.confirm("Delete the ${contacts.size} contacts?")) {
            contacts.clear()
            message = "All the contacts have been deleted."
        }
    }

    ExamplePage("Example 16 - a confirmation dialog", messages = messages) {
        for (c in contacts) {
            ListItem(
                leadingContent = { Icon(Icons.Default.Person, contentDescription = null) },
                headlineContent = { Text(c.name) },
                trailingContent = {
                    // launch: eine Coroutine, um die suspend-Funktion aufrufen zu können
                    IconButton(onClick = { scope.launch { remove(c) } }) {
                        Icon(Icons.Outlined.Delete, contentDescription = "delete ${c.name}", tint = Color.Red)
                    }
                },
            )
        }
        if (contacts.isEmpty()) {
            ListItem(headlineContent = { Text("No contact.", color = Color.Gray) })
        }
        Spacer(Modifier.height(12.dp))
        Button(
            onClick = { scope.launch { removeAll() } },
            // die Schaltfläche ist deaktiviert, wenn die Liste leer ist
            enabled = contacts.isNotEmpty(),
            colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFD32F2F)),
        ) { Text("Delete all") }
        Spacer(Modifier.height(12.dp))
        if (message.isNotEmpty()) {
            Text(message, color = Color(0xFF3F51B5))
        }
    }
    // der Dialog, wenn eine Frage gestellt wird
    ConfirmDialog(confirmation)
}
  • Zeilen 60–61: der Bereich für Popup-Meldungen, an [ExamplePage] übergeben (die ihn an [Scaffold] weitergibt), und ein Coroutine-Scope;
  • Zeilen 64–77: eine suspendierte Funktion, die sich wie gewöhnlicher Code liest: eine Anfrage stellen, auf die Antwort warten; löschen; die Meldung anzeigen, auf ihr Verschwinden WARTEN ([showSnackbar] gibt an, ob ihre Schaltfläche angetippt wurde) und gegebenenfalls abbrechen;
  • Zeile 95: [scope.launch [ ... ]]: eine Coroutine, um aus einem Ereignis heraus eine suspendierte Funktion aufrufen zu können;
  • Zeile 117: das Fenster, einmal auf dem Bildschirm platziert.

Image

Image