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.


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.


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.

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.

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.

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))
}
}
}
|


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.

