3. Erste Schritte mit Kotlin und Jetpack Compose
3.1. Beispiel 01: Die Struktur einer Android-App
3.1.1. Das Projekt
Das Beispielprojekt wurde von [Android Studio] erstellt (Vorlage [Empty Activity], siehe vorheriges Kapitel) und anschließend ergänzt. Ein [Android]-Projekt ist ein [Gradle]-Projekt: das Werkzeug, das die Bibliotheken herunterlädt, den [Kotlin]-Code kompiliert und die auf dem Smartphone installierte Datei [.apk] erzeugt. Es wird durch einige Dateien beschrieben, die in [Kotlin] geschrieben sind (die [.kts]-Dateien, „Kotlin Script“).
3.1.2. Die Datei settings.gradle.kts
| // =========================================================================
// settings.gradle.kts - die GLOBALE Konfiguration des Gradle-Projekts
// (von Android Studio generiert; nur rootProject.name wurde geändert)
// =========================================================================
// wo Gradle seine PLUGINS findet (das Android-Plugin, das Compose-Plugin ...)
pluginManagement {
repositories {
google {
content {
includeGroupByRegex("com\\.android.*")
includeGroupByRegex("com\\.google.*")
includeGroupByRegex("androidx.*")
}
}
mavenCentral()
gradlePluginPortal()
}
}
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}
// wo Gradle die BIBLIOTHEKEN findet: google() für AndroidX und Compose,
// mavenCentral() für OkHttp, kotlinx.serialization, AndroidSVG
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
}
}
rootProject.name = "examples_kotlin"
// ein einziges Modul: die Anwendung, im Ordner app/
include(":app")
|
- Zeilen 7–17: wo [Gradle] seine PLUGINS sucht (Erweiterungen von [Gradle]: das [Android]-Plugin, der [Compose]-Compiler ...): das Google-Repository und das zentrale Repository für Java-Bibliotheken ([Maven Central]);
- Zeilen 25–29: wo [Gradle] die BIBLIOTHEKEN der Anwendung sucht;
- Zeilen 3–11: der Projektname und sein einziges Modul, die Anwendung, im Ordner [app/].
3.1.3. Der Versionskatalog: gradle/libs.versions.toml
Alle Versionen von Plugins und Bibliotheken sind in einer einzigen Datei im TOML-Format zusammengefasst:
| # =========================================================================
# gradle/libs.versions.toml - der "Version Catalog" des Projekts
# -------------------------------------------------------------------------
# ALLE Versionen der Plugins und Bibliotheken an einer einzigen Stelle.
# Die Dateien build.gradle.kts verweisen über Namen darauf
# (libs.okhttp, libs.plugins.kotlin.compose ...). Das entspricht dem
# Abschnitt dependencies der pubspec.yaml von Flutter.
# =========================================================================
[versions]
agp = "9.4.1"
kotlin = "2.2.10"
coreKtx = "1.17.0"
lifecycle = "2.9.4"
activityCompose = "1.11.0"
composeBom = "2026.02.01"
appcompat = "1.7.1"
navigation = "2.9.5"
datastore = "1.1.7"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
androidsvg = "1.4"
junit = "4.13.2"
junitVersion = "1.3.0"
espressoCore = "3.7.0"
testRunner = "1.7.0"
[libraries]
# von Android Studio generiert (Vorlage "Empty Activity")
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
# für die Beispiele hinzugefügt
# die grundlegenden Material-Icons (Add, Delete, Search ...)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# der Lebenszyklus der Activity aus Sicht von Compose (Beispiele 13, 20)
androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
# viewModel() in einer @Composable-Funktion (Beispiele 20, 24, 25)
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# die EIGENE Sprache der Anwendung (Beispiele 21, 25)
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
# der Router (Beispiele 17, 18)
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
# ein kleines Schlüssel-Wert-Wörterbuch, auf dem Gerät gespeichert (Beispiel 20)
androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }
# der HTTP-Client (Beispiele 22 bis 25)
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# JSON-(De-)Serialisierung (Beispiele 17, 18, 22 bis 25)
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
# Zeichnen eines SVG-Bilds (Beispiel 03, CAPTCHA der Beispiele 22 bis 25)
androidsvg = { group = "com.caverock", name = "androidsvg-aar", version.ref = "androidsvg" }
[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# erzeugt den (De-)Serialisierungscode der @Serializable-Klassen
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
- Abschnitt [[versions]]: Versionsnummern, mit Namen versehen;
- Abschnitt [[libraries]]: die Bibliotheken, identifiziert durch ihre Gruppe und ihren Namen ([Maven]) sowie ihre Version. Die [Compose]-Bibliotheken haben keine Version: Die „BOM“ ([compose-bom], „Bill of Materials“) legt kompatible Versionen für alle auf einmal fest;
- Abschnitt [[plugins]]: die Plugins für [Gradle]. Die Dateien [build.gradle.kts] verweisen über ihren Namen darauf: [libs.okhttp], [libs.plugins.kotlin.compose] (Bindestriche werden durch Punkte ersetzt).
Der Zweck jeder Bibliothek wird in den Kommentaren erläutert; jede wird in dem Beispiel gezeigt, das sie verwendet.
3.1.4. Die Datei app/build.gradle.kts
Die eigentliche Konfiguration der Anwendung:
| // =========================================================================
// app/build.gradle.kts - die Konfiguration des Moduls "app": die Anwendung
// der 25 Beispiele. Von Android Studio generiert (Vorlage "Empty Activity"),
// dann ergänzt (mit "added" markierte Zeilen).
// =========================================================================
plugins {
// das Android-Plugin: kompiliert den Kotlin-Code (das Android-9-Plugin
// enthält selbst die Kotlin-Unterstützung) und erzeugt die .apk-Datei
alias(libs.plugins.android.application)
// der Compose-Compiler: transformiert die @Composable-Funktionen
alias(libs.plugins.kotlin.compose)
// hinzugefügt: das kotlinx.serialization-Plugin (@Serializable-Klassen)
alias(libs.plugins.kotlin.serialization)
}
android {
// das Basis-"Paket" des Codes (R-Klasse, BuildConfig ...)
namespace = "fr.stahe.examples"
// die Version der Android-API, die zum KOMPILIEREN verwendet wird
compileSdk {
version = release(37)
}
defaultConfig {
// die EINDEUTIGE Kennung der Anwendung auf dem Smartphone
applicationId = "fr.stahe.examples"
// die älteste unterstützte Android-Version: Android 8.0 (API 26)
minSdk = 26
// die Android-Version, für die die Anwendung getestet wurde
targetSdk = 37
versionCode = 1
versionName = "1.0"
// hinzugefügt: die Adresse des JSON-Servers (Beispiele 22 bis 25), änderbar zur
// Compile-Zeit: gradlew installDebug -Pserver=http://192.168.1.20:8080
val server = providers.gradleProperty("server").getOrElse("http://localhost:8080")
buildConfigField("String", "SERVER_URL", "\"$server\"")
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
optimization {
enable = false
}
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
buildFeatures {
compose = true
// hinzugefügt: die Klasse BuildConfig (BuildConfig.SERVER_URL)
buildConfig = true
}
}
dependencies {
// die Compose-"BOM": zueinander kompatible Versionen aller
// Compose-Bibliotheken, unten OHNE Versionsnummer deklariert
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.compose.material3)
implementation(libs.androidx.compose.ui)
implementation(libs.androidx.compose.ui.graphics)
implementation(libs.androidx.compose.ui.tooling.preview)
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
// für die Beispiele hinzugefügt
implementation(libs.androidx.compose.material.icons.core)
implementation(libs.androidx.lifecycle.runtime.compose)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.appcompat)
implementation(libs.androidx.navigation.compose)
implementation(libs.androidx.datastore.preferences)
implementation(libs.okhttp)
implementation(libs.kotlinx.serialization.json)
implementation(libs.androidsvg)
// die Tests: hier die Erstellung der Kurs-Screenshots (Ordner androidTest)
testImplementation(libs.junit)
androidTestImplementation(platform(libs.androidx.compose.bom))
androidTestImplementation(libs.androidx.compose.ui.test.junit4)
androidTestImplementation(libs.androidx.espresso.core)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.test.runner)
debugImplementation(libs.androidx.compose.ui.test.manifest)
debugImplementation(libs.androidx.compose.ui.tooling)
}
|
- Zeilen 6–13: die auf das Modul angewendeten Plugins: das [Android]-Plugin (das auch [Kotlin] kompiliert), der [Compose]-Compiler (der die [@Composable]-Funktionen umwandelt) und das Plugin [kotlinx.serialization] (das den Code für die JSON-Konvertierung der [@Serializable]-Klassen schreibt; siehe Beispiel 05);
- Zeilen 18–21: [namespace], das Basis-Codepaket (das der Ressourcenklasse [R]); [compileSdk], die für die Kompilierung verwendete Version der API und von [Android] ;
- Zeilen 24–32: [applicationId], die eindeutige Kennung der Anwendung auf dem Smartphone; [minSdk = 26]: Die Anwendung lässt sich ab [Android] 8.0 installieren; [targetSdk], die Version, für die sie getestet wurde;
- Zeilen 33–36: ein Feld der Klasse [BuildConfig], das zur Kompilierzeit erzeugt wird: die Adresse des JSON-Servers (Beispiele 22–25), die zur Kompilierzeit geändert werden kann ([-Pserver=...]);
- Zeilen 52–55: [compose = true] aktiviert [Compose]; [buildConfig = true] die Klasse [BuildConfig];
- Zeilen 59–88: die Bibliotheken für die Anwendung ([implementation]), die instrumentierten Tests ([androidTestImplementation]) und die reine Debug-Version ([debugImplementation]).
3.1.5. Die Datei AndroidManifest.xml
Das Manifest ist der „Personalausweis“ der Anwendung für das [Android]-System: ihre Berechtigungen, ihre Klasse [Application], ihre ACTIVITIES – die Bildschirme, die [Android] starten kann:
| <?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
AndroidManifest.xml - der "Personalausweis" der Anwendung
............................................................................
Ihre Berechtigungen, ihre Application-Klasse, ihre Activities (eine pro
Beispiel, plus das Menü).
===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- Netzwerkzugriff (Beispiele 22 bis 25): wird automatisch erteilt, ohne
den Benutzer zu fragen -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- android:name: die Application-Klasse (ExamplesApplication.kt).
android:usesCleartextTraffic="true": erlaubt HTTP im Klartext
(http:// und nicht https://), seit Android 9 standardmäßig blockiert: Der
JSON-Server dieses Kurses lauscht über einfaches HTTP.
android:localeConfig: die Sprachen der Anwendung (Beispiel 21) -->
<application
android:name=".ExamplesApplication"
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:localeConfig="@xml/locales_config"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.Examples"
android:usesCleartextTraffic="true"
tools:targetApi="33">
<!-- das Menü: die Activity, die über das Icon der Anwendung gestartet wird
(der Filter MAIN / LAUNCHER) -->
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- die Beispiele. exported="false": Nur die Anwendung kann sie
öffnen (adb kann es allerdings immer).
windowSoftInputMode="adjustResize": Die Tastatur verkleinert den Bildschirm,
anstatt ihn zu verdecken -->
<activity android:name=".ex01.Ex01Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex02.Ex02Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex03.Ex03Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex04.Ex04Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex05.Ex05Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex06.Ex06Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex07.Ex07Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex08.Ex08Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex09.Ex09Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex10.Ex10Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex11.Ex11Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex12.Ex12Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex13.Ex13Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex14.Ex14Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex15.Ex15Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex16.Ex16Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex19.Ex19Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex20.Ex20Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex21.Ex21Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex22.Ex22Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex23.Ex23Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex24.Ex24Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex25.Ex25Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<!-- Beispiele 17 und 18: Adressen app://examples/... und
app://examples18/... ("Deep Links"), die eine andere
Anwendung (oder adb) öffnen kann: ein VIEW-Intent-Filter -->
<activity android:name=".ex17.Ex17Activity" android:exported="true" android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="app" android:host="examples" />
</intent-filter>
</activity>
<activity android:name=".ex18.Ex18Activity" android:exported="true" android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="app" android:host="examples18" />
</intent-filter>
</activity>
<!-- Beispiel 21: Vor Android 13 speichert AppCompat die
von der Anwendung gewählte Sprache (autoStoreLocales) -->
<service
android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
android:enabled="false"
android:exported="false">
<meta-data
android:name="autoStoreLocales"
android:value="true" />
</service>
</application>
</manifest>
|
- Zeile 13: Berechtigung für den Netzwerkzugriff (Beispiele 22 bis 25);
- Zeilen 20–32: die Anwendung: ihre Klasse [Application] (Beispiel 23), ihr Symbol, ihr Name ([@string/app_name], eine Ressource, siehe Beispiel 21), ihr Theme und der HTTP-Verkehr im Klartext („plaintext“) (der Server dieses Kurses verwendet kein HTTPS);
- Zeilen 37–43: das Menü, die Start-Activity: Der Intent-Filter [MAIN] / [LAUNCHER] bezeichnet die Activity, die durch das Anwendungssymbol gestartet wird;
- Zeilen 49–71: eine Beispiel-Activity; [exported="false"]: nur die Anwendung selbst kann sie öffnen.
3.1.6. Die Activity: Ex01Activity.kt
Code von Beispiel 01:
| // =========================================================================
// ex01/Ex01Activity.kt - eine erste Anwendung
// -------------------------------------------------------------------------
// Ein Bildschirm einer Android-Anwendung ist eine ACTIVITY: eine Klasse, die
// von ComponentActivity erbt und vom System beim Start der
// Anwendung erzeugt wird. Mit Jetpack Compose tut die Activity fast nichts:
// Sie überlässt ihren Bildschirm den @Composable-Funktionen (setContent).
// Eine @Composable-Funktion BESCHREIBT einen Teil des Bildschirms (einen Text,
// eine Schaltfläche, eine Spalte ...), indem sie andere @Composable-Funktionen aufruft:
// Diese bilden einen BAUM. Compose führt diese Funktionen aus, um
// den Bildschirm aufzubauen; es FÜHRT SIE ERNEUT AUS, wenn sich ein von ihnen gelesenes Datum (ein "Zustand")
// ändert: Das ist die REKOMPOSITION. Wir ändern den Bildschirm nie selbst.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex01
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.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplesTheme
import java.time.LocalTime
import java.time.format.DateTimeFormatter
// "gewöhnliche" Daten außerhalb der @Composable-Funktionen: Sie ändern sich nie
const val TITLE = "Welcome to Kotlin"
val languages = listOf("Kotlin", "Jetpack Compose", "Material Design")
// "12:05:09": die aktuelle Uhrzeit
fun currentTime(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
// die Activity: der Einstiegspunkt des Bildschirms (in AndroidManifest.xml deklariert)
class Ex01Activity : ComponentActivity() {
// onCreate: wird von Android aufgerufen, wenn die Activity erzeugt wird
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// die Anwendung zeichnet auch unter der Statusleiste und der Navigationsleiste
enableEdgeToEdge()
// setContent: Compose übernimmt den Bildschirm und zeigt darin die
// übergebene @Composable-Funktion an, eingehüllt in das Theme der Beispiele
setContent {
ExamplesTheme {
HomePage()
}
}
}
}
// eine @Composable-Funktion: Ihr Name beginnt mit einem Großbuchstaben, wie bei einer
// Klasse (sie ist ein Teil der Oberfläche), und sie gibt nichts zurück (Unit)
@Composable
fun HomePage() {
// der ZUSTAND: von Compose beobachtete Variablen. Ihre Änderung führt zur
// erneuten Ausführung (Rekomposition) der Funktionen, die sie lesen.
// rememberSaveable: Der Wert bleibt von einer Ausführung der Funktion
// zur nächsten erhalten ... und sogar, wenn Android die Activity neu erzeugt (Bildschirm-
// drehung, Sprachwechsel)
var counter by rememberSaveable { mutableIntStateOf(0) }
var time by rememberSaveable { mutableStateOf(currentTime()) }
// Scaffold: die Struktur eines Material-Bildschirms (Top-Bar, Inhalt ...)
Scaffold(
topBar = { TopAppBar(title = { Text("Example 01 - a first application") }) },
) { insets ->
// Column: Kinder untereinander angeordnet; die Insets
// des Scaffold (der Platz für die Top-Bar), dann 16 dp mehr
Column(modifier = Modifier.padding(insets).padding(16.dp)) {
Text(TITLE, style = MaterialTheme.typography.headlineSmall)
Spacer(Modifier.height(12.dp))
Text(
"This screen is built by Jetpack Compose, from the activity " +
"Ex01Activity and the function HomePage.",
)
Spacer(Modifier.height(8.dp))
// ${expression} fügt den Wert eines Ausdrucks in einen String ein
Text("It is written in ${languages.joinToString(", ")} (${languages.size} technologies).")
Spacer(Modifier.height(16.dp))
// onClick: die Funktion (hier ein "Lambda"), die beim Drücken aufgerufen wird.
// Wir ändern den ZUSTAND; Compose aktualisiert den Bildschirm
Button(onClick = {
counter++
time = currentTime()
}) {
Text("Click me")
}
Spacer(Modifier.height(16.dp))
Text(
"You clicked $counter times (last click: $time).",
fontWeight = FontWeight.Bold,
color = Color(0xFF087EA4),
)
}
}
}
|
- Zeile 16: das Paket ([package]) der Datei: Jedes Beispiel hat sein eigenes, sodass identische Namen (eine Funktion [HomePage]) in zwei Beispielen vorkommen können;
- Zeile 14: [@file:OptIn(...)]: Einige Funktionen von [Material 3] ([TopAppBar]) sind noch als „experimentell“ markiert; wir erklären, dass wir sie in voller Kenntnis der Risiken verwenden;
- Zeilen 47–48: gewöhnliche Daten außerhalb jeder [@Composable]-Funktion; [const val]: eine zur Kompilierzeit bekannte Konstante;
- Zeile 54: die ACTIVITY, eine Klasse, die von [ComponentActivity] erbt. [Android] erzeugt sie, wenn der Bildschirm gestartet wird, und ruft dann ihre Funktion [onCreate] auf;
- Zeilen 59–64: [enableEdgeToEdge()]: Die Anwendung zeichnet auch unter der Statusleiste und unter der Navigationsleiste des Smartphones (das gilt seit [Android] 15 als Regel); [setContent [ ... ]]: [Compose] übernimmt die Kontrolle über den Bildschirm und zeigt dort den Inhalt des Blocks an. [ExamplesTheme] (Datei [common/Theme.kt]) wendet die Farben von [Material 3] auf alles an, was es enthält;
- Zeilen 7–73: eine [@Composable]-Funktion: Sie BESCHREIBT einen Teil des Bildschirms, indem sie andere [@Composable]-Funktionen aufruft. Ihr Name beginnt per Konvention mit einem Großbuchstaben, wie bei einer Klasse; sie gibt nichts zurück;
- Zeilen 79–80: der ZUSTAND. [mutableIntStateOf(0)] erzeugt einen von [Compose] BEOBACHTETEN Wert: Wenn er sich ändert, führt [Compose] die Funktionen, die ihn lesen, erneut aus (Recomposition). [by] bindet die Variable [counter] an diesen Zustand: [counter++] schreibt sich wie bei einer gewöhnlichen Variable. [rememberSaveable]: Der Wert bleibt von einer Ausführung der Funktion zur nächsten erhalten (ohne [remember] würde jede Ausführung den Zustand auf 0 zurücksetzen) ... und sogar dann, wenn [Android] die Activity NEU ERZEUGT – was bei jeder Drehung des Bildschirms geschieht;
- Zeilen 83–85: [Scaffold], die Struktur eines [Material]-Bildschirms: eine obere Leiste ([topBar]) und der Inhalt. Der Inhalt ist ein Lambda, das die einzuhaltenden RÄNDER erhält (die Position der oberen Leiste);
- Zeile 88: [Column] ordnet ihre Kindelemente untereinander an. [Modifier]: die Methode von [Compose], um eine Komponente anzupassen (Ränder, Größe, Hintergrund, Reaktion auf Gesten usw.): Modifier werden in der Reihenfolge verkettet, in der sie angewendet werden;
- Zeilen 89–97: Text und Abstand ([Spacer]); [MaterialTheme.typography.headlineSmall]: einer der Textstile des Themes; ["$[...]"] fügt einen Ausdruck in eine Zeichenkette ein;
- Zeilen 101–105: eine Schaltfläche. [onClick] erhält die Funktion (ein Lambda), die beim Drücken der Schaltfläche ausgeführt wird: Sie ändert den Zustand, mehr nicht. Wir greifen nie direkt auf den Bildschirm zu: [Compose] führt [HomePage] erneut aus, wodurch der neue Zähler angezeigt wird; das letzte Lambda, in geschweiften Klammern hinter den runden Klammern, ist der INHALT der Schaltfläche (ihr Text);
- Zeilen 109–111: ein Text, der den Zustand liest; er wird bei jedem Klick aktualisiert.
Das Theme für die Beispiele, [common/Theme.kt]:
| // =========================================================================
// common/Theme.kt - das von allen Beispielen gemeinsam genutzte Theme
// -------------------------------------------------------------------------
// MaterialTheme: die Farben, Texte und Formen von Material
// Design 3, die ALLE darin platzierten Material-Komponenten verwenden
// (Schaltflächen, Felder, Karten ...). Wir übergeben ein Farbset (ein
// ColorScheme), hell oder dunkel, aufgebaut um ein Indigoblau.
// ExamplesTheme(dark = true): das dunkle Theme (vgl. Beispiel 20).
// =========================================================================
package fr.stahe.examples.common
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
// die Farben des hellen Themes: die übrigen sind die Standardwerte von Material 3
private val lightColors = lightColorScheme(
primary = Color(0xFF4355B9),
onPrimary = Color.White,
primaryContainer = Color(0xFFDEE0FF),
onPrimaryContainer = Color(0xFF00105C),
secondaryContainer = Color(0xFFE0E1F9),
onSecondaryContainer = Color(0xFF181A2C),
surface = Color(0xFFFBF8FF),
surfaceContainer = Color(0xFFEFEDF4),
surfaceContainerLow = Color(0xFFF5F2FA),
)
// die Farben des dunklen Themes
private val darkColors = darkColorScheme(
primary = Color(0xFFBAC3FF),
onPrimary = Color(0xFF08218A),
primaryContainer = Color(0xFF293CA0),
onPrimaryContainer = Color(0xFFDEE0FF),
secondaryContainer = Color(0xFF434659),
onSecondaryContainer = Color(0xFFE0E1F9),
)
// eine @Composable-Funktion, die einen Inhalt "umhüllt": der Parameter
// content ist selbst eine @Composable-Funktion (vgl. Beispiel 12)
@Composable
fun ExamplesTheme(dark: Boolean = false, content: @Composable () -> Unit) {
MaterialTheme(
colorScheme = if (dark) darkColors else lightColors,
content = content,
)
}
|
- [lightColorScheme(...)], [darkColorScheme(...)]: die Farben für [Material 3], hell und dunkel; nicht angegebene Farben behalten ihre Standardwerte;
- [ExamplesTheme(dark, content)]: eine [@Composable]-Funktion, die ... eine weitere [@Composable]-Funktion als Inhalt erhält. Das ist der Kernmechanismus der Komposition (siehe Beispiel 12): [ExamplesTheme [ HomePage() ]] ruft [MaterialTheme] mit diesem Inhalt auf.
3.1.7. Ausführung
In [Android Studio]startet die Schaltfläche [Run] die Anwendung: Das Beispielmenü erscheint; die erste Zeile öffnet Beispiel 01. Nach zwei Klicks auf die Schaltfläche:


Drehen Sie das Smartphone (oder den Emulator mit der Drehen-Schaltfläche in seiner Symbolleiste): Die Activity wird von [Android] zerstört und neu erzeugt, dennoch bleibt der Zähler dank [rememberSaveable] erhalten. Ersetzen Sie [rememberSaveable] durch [remember]: Der Zähler wird bei jeder Drehung auf 0 zurückgesetzt. Das ist ein wesentlicher Unterschied zu [Flutter], wo der Bildschirm die Drehung überdauert: Bei [Android] ändern sich die Einstellungen des Geräts (Ausrichtung, Sprache, Textgröße usw.), und die Activity wird neu erzeugt.
3.2. Beispiel 02: Zustand und berechnete Werte
Ein einfacher Rechner für Preise inklusive Mehrwertsteuer, der zwischen dem Zustand (dem, was der Benutzer eingegeben hat) und der daraus resultierenden Berechnung unterscheidet. In diesem Beispiel ist die Struktur des Bildschirms (obere Leiste, scrollender Inhalt) ein für alle Mal in [common/ExamplePage.kt] festgelegt:
| // =========================================================================
// common/ExamplePage.kt - die gemeinsame Struktur der Beispielbildschirme
// -------------------------------------------------------------------------
// Alle Beispiele (ab 02) haben dieselbe Bildschirmstruktur: eine
// Top-Bar mit einem Titel, dann ein Inhalt in einer Spalte, die SCROLLT, wenn sie
// die Bildschirmhöhe überschreitet. Anstatt sie 25-mal neu zu schreiben,
// schreiben wir sie einmal, in einer @Composable-Funktion, die den Inhalt als
// Parameter erhält (vgl. Beispiel 12):
//
// ExamplePage("Example 02 - state") {
// Text("...") // der Inhalt: Komponenten, untereinander
// Button(...) { ... }
// }
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.common
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ColumnScope
import androidx.compose.foundation.layout.RowScope
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun ExamplePage(
title: String,
// ein Icon links neben dem Titel (standardmäßig keines)
icon: @Composable () -> Unit = {},
// Schaltflächen rechts in der Top-Bar (standardmäßig keine)
actions: @Composable RowScope.() -> Unit = {},
// der Bereich für die kurzlebigen Meldungen (Snackbar, vgl. Beispiel 16), optional
messages: SnackbarHostState? = null,
// der Inhalt: eine @Composable-Funktion, die INNERHALB einer Column aufgerufen wird
content: @Composable ColumnScope.() -> Unit,
) {
Scaffold(
topBar = {
TopAppBar(
title = { Text(title, style = MaterialTheme.typography.titleMedium, maxLines = 2) },
navigationIcon = icon,
actions = actions,
)
},
snackbarHost = { if (messages != null) SnackbarHost(messages) },
) { insets ->
Column(
modifier = Modifier
// die Insets des Scaffold: unterhalb der Top-Bar, oberhalb
// der Navigationsleiste des Smartphones
.padding(insets)
.consumeWindowInsets(insets)
// die Tastatur des Smartphones verdeckt den unteren Bildschirmbereich nicht
.imePadding()
.fillMaxSize()
// die Spalte scrollt, wenn sie höher als der Bildschirm ist
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(4.dp),
content = content,
)
}
}
|
- [content: @Composable ColumnScope.() -> Unit]: Der Inhalt ist eine [@Composable]-Funktion, die INNERHALB einer [Column] aufgerufen wird (sie kann daher spaltenspezifische Modifier wie [weight] verwenden);
- [verticalScroll(rememberScrollState())]: Die Spalte scrollt, wenn sie die Bildschirmhöhe überschreitet; [imePadding()]: Die Tastatur des Smartphones verdeckt den unteren Bildschirmbereich nicht;
- Sie wird mit einem abschließenden Lambda aufgerufen: [ExamplePage("title") [ Text(...) ; Button(...) ]].
Der Code des Beispiels:
| // =========================================================================
// ex02/Ex02Activity.kt - Zustand und berechnete Werte
// -------------------------------------------------------------------------
// Ein kleiner Rechner für Preise inklusive Mehrwertsteuer:
// - der ZUSTAND: mutableStateOf-Variablen; ihre Änderung führt die Funktion,
// die sie liest, erneut aus (Rekomposition) und baut den Bildschirm mit den
// neuen Werten auf;
// - ein aus dem Zustand BERECHNETER Wert ist KEIN Zustand: Er ist eine
// einfache lokale Variable, die bei jeder Ausführung der Funktion neu berechnet wird.
// Sie ist immer aktuell, ohne etwas zu synchronisieren;
// - ein Datum, das von den AUFEINANDERFOLGENDEN Werten des Zustands abhängt (der Verlauf
// der Summen), wird dort aktualisiert, wo sich der Zustand ändert;
// - der Titel der Anwendung in der Liste der zuletzt verwendeten Anwendungen
// folgt dem Zustand, wie der Rest des Bildschirms (TaskTitle).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex02
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.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.KeyboardArrowDown
import androidx.compose.material3.Card
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SegmentedButton
import androidx.compose.material3.SegmentedButtonDefaults
import androidx.compose.material3.SingleChoiceSegmentedButtonRow
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableDoubleStateOf
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.common.TaskTitle
import java.text.NumberFormat
import java.util.Locale
// ein Formatierer für Eurobeträge, auf englische Art (€1,234.50), vgl. Beispiel 09
val euros: NumberFormat = NumberFormat.getCurrencyInstance(Locale.US).apply { currency = java.util.Currency.getInstance("EUR") }
// die vorgeschlagenen Mehrwertsteuersätze
val rates = listOf(5.5, 10.0, 20.0)
// "2,5" oder "2.5" -> 2.5; ein Text, der keine Zahl ist -> 0
fun price(text: String): Double = text.replace(',', '.').toDoubleOrNull() ?: 0.0
// die Summe inkl. MwSt.: eine REINE Funktion (ihr Ergebnis hängt nur von ihren Parametern ab)
fun totalInclVat(priceExclVat: Double, quantity: Int, vatRate: Double): Double = quantity * priceExclVat * (1 + vatRate / 100)
class Ex02Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { CalculatorPage() } }
}
}
@Composable
fun CalculatorPage() {
// der Zustand: was der Benutzer eingegeben oder gewählt hat
var label by rememberSaveable { mutableStateOf("Pen") }
var priceText by rememberSaveable { mutableStateOf("2.5") } // der Text des Feldes, wie eingegeben
var quantity by rememberSaveable { mutableIntStateOf(1) }
var vatRate by rememberSaveable { mutableDoubleStateOf(20.0) }
// der Verlauf der letzten 5 Änderungen der Summe inkl. MwSt.: eine UNVERÄNDERLICHE
// Liste, die bei jeder Änderung durch eine neue Liste ersetzt wird
var history by rememberSaveable { mutableStateOf(listOf<String>()) }
// BERECHNETE Werte: einfache lokale Variablen, die bei
// jeder Ausführung der Funktion neu berechnet werden
val priceExclVat = price(priceText)
val totalExclVat = quantity * priceExclVat
val vatAmount = totalExclVat * vatRate / 100
val inclVat = totalExclVat + vatAmount
// ALLE Änderungen des Zustands laufen über diese lokale Funktion: Sie
// merkt sich die Summe inkl. MwSt. vor der Änderung, wendet die Änderung an und
// ergänzt den Verlauf, wenn sich die Summe geändert hat
fun change(update: () -> Unit) {
val old = inclVat
update()
// die Zustandsvariablen haben BEREITS ihren neuen Wert
val newTotal = totalInclVat(price(priceText), quantity, vatRate)
if (newTotal != old) {
history = (listOf("${euros.format(old)} -> ${euros.format(newTotal)}") + history).take(5)
}
}
// der Titel der Anwendung FOLGT dem Zustand, wie alles andere
TaskTitle("Incl. VAT: ${euros.format(inclVat)}")
val totalStyle = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold)
ExamplePage("Example 02 - state") {
Card {
Column(Modifier.padding(16.dp)) {
// ein GESTEUERTES Feld: Es zeigt value an und ruft onValueChange
// bei jedem Tastendruck mit dem neuen Text auf
OutlinedTextField(
value = label,
// der Wechsel des Artikels setzt die Menge auf 1 zurück: Das geschieht dort, wo
// wir wissen, WARUM sich der Zustand ändert
onValueChange = { newValue ->
change {
label = newValue
quantity = 1
}
},
label = { Text("Item") },
modifier = Modifier.fillMaxWidth(),
)
OutlinedTextField(
value = priceText,
onValueChange = { text -> change { priceText = text } },
label = { Text("Unit price excl. VAT") },
// die numerische Tastatur des Smartphones
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(12.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
// weight(1f): Der Text nimmt die gesamte restliche Breite ein
Text("Quantity (back to 1 if the item changes)", Modifier.weight(1f))
// enabled = false: Die Schaltfläche ist deaktiviert
IconButton(onClick = { change { quantity-- } }, enabled = quantity > 0) {
Icon(Icons.Default.KeyboardArrowDown, contentDescription = "minus")
}
Text("$quantity", style = totalStyle)
IconButton(onClick = { change { quantity++ } }) {
Icon(Icons.Default.Add, contentDescription = "plus")
}
}
Spacer(Modifier.height(8.dp))
// Schaltflächen, von denen nur EINE ausgewählt ist: der Mehrwertsteuersatz
SingleChoiceSegmentedButtonRow(Modifier.fillMaxWidth()) {
rates.forEachIndexed { i, t ->
SegmentedButton(
selected = t == vatRate,
onClick = { change { vatRate = t } },
shape = SegmentedButtonDefaults.itemShape(index = i, count = rates.size),
) {
Text("${t.toString().removeSuffix(".0")} %")
}
}
}
Spacer(Modifier.height(12.dp))
OutlinedButton(onClick = {
change {
label = "Pen"
priceText = "2.5"
quantity = 1
vatRate = 20.0
}
}) {
Text("Reset")
}
}
}
Card {
Column(Modifier.padding(16.dp)) {
Text("$quantity x $label", style = MaterialTheme.typography.titleLarge)
HorizontalDivider(Modifier.padding(vertical = 8.dp))
Line("Total excl. VAT", euros.format(totalExclVat))
Line("VAT ($vatRate %)", euros.format(vatAmount))
Line("Total incl. VAT", euros.format(inclVat), totalStyle)
}
}
Card {
Column(Modifier.padding(16.dp).fillMaxWidth()) {
Text("History of the total incl. VAT", style = MaterialTheme.typography.titleSmall)
// eine Textzeile pro Element des Verlaufs (vgl. Beispiel 03)
for (line in history) {
Text("• $line")
}
}
}
}
}
// eine Zeile "Bezeichnung ....... Betrag": eine @Composable-Funktion, die
// andere aufbaut. style: ein optionaler Parameter mit seinem Standardwert
@Composable
fun Line(label: String, amount: String, style: TextStyle = MaterialTheme.typography.bodyLarge) {
Row(Modifier.padding(vertical = 4.dp)) {
Text(label, Modifier.weight(1f), style = style)
Text(amount, style = style)
}
}
|
- Zeilen 72–75: REINE Funktionen, außerhalb des Bildschirms: der eingegebene Preis (["2,5"] oder ["2.5"]) als Zahl umgewandelt, der Gesamtbetrag inklusive Mehrwertsteuer;
- Zeilen 88–94: der Zustand. [history] ist eine UNVERÄNDERLICHE Liste ([listOf]): Sie wird bei jeder Änderung durch eine neue Liste ersetzt, was [Compose] erkennt (die Zuweisung des Zustands);
- Zeilen 98–101: Die BERECHNETEN Werte sind einfach lokale Variablen. Die Funktion wird bei jeder Zustandsänderung erneut ausgeführt: Sie sind also immer aktuell, es gibt nichts zu synchronisieren;
- Zeilen 106–112: eine LOKALE Funktion, über die alle Änderungen laufen: Sie merkt sich den Gesamtbetrag vor der Änderung, wendet die Änderung an ([update()]: die als Parameter übergebene Funktion), berechnet den neuen Gesamtbetrag und aktualisiert den Verlauf. Die Zustandsvariablen haben unmittelbar nach der Zuweisung bereits ihre neuen Werte; [take(5)] behält die ersten fünf Zeilen;
- Zeile 117: Der Titel der Anwendung in der Liste der zuletzt verwendeten Anwendungen folgt dem Zustand (Funktion [TaskTitle] aus [common/TaskTitle.kt], die [setTaskDescription] der Activity aufruft);
- Zeilen 125–136: ein GESTEUERTES Feld: Es zeigt [value] an und ruft bei jedem Tastenanschlag [onValueChange] mit dem neuen Text auf. Bei [Compose] ist der Text eines Feldes nur ein weiterer Zustand: Es muss kein Controller erstellt oder freigegeben werden, und [Reset] muss lediglich den Zustand ändern;
- Zeile 143: [KeyboardOptions(keyboardType = KeyboardType.Decimal)]: die numerische Tastatur des Smartphones;
- Zeilen 147–156: die Menge: [enabled = quantity > 0] deaktiviert die Schaltfläche „Minus“ bei 0; [Modifier.weight(1f)]: Der Text nimmt die gesamte verbleibende Breite der Zeile ein;
- Zeilen 44–168: „segmentierte“ Schaltflächen, von denen nur EINE ausgewählt ist: der Mehrwertsteuersatz. [forEachIndexed] durchläuft die Liste mit dem Rang jedes Elements; [itemShape] rundet die Ecken des ersten und des letzten Elements ab;
- Zeilen 209–212: [Line], eine [@Composable]-Funktion mit Parametern, von denen einer optional ist ([style], mit seinem Standardwert).


Links nach zweimaligem Tippen auf [+], Auswahl von 10 % und Eingabe von 3.2; rechts hat sich der Artikel geändert: Die Menge ist auf 1 zurückgekehrt, und der Verlauf hat jede Änderung des Gesamtbetrags festgehalten.
3.3. Beispiel 03: Einen Komponentenbaum schreiben
[Compose] hat keine Template-Sprache: Für Bedingungen und Schleifen verwenden wir die Anweisungen von [Kotlin] direkt in der [@Composable]-Funktion. Eine nach einer Eingabe gefilterte Liste von Ärzten:
| // =========================================================================
// ex03/Ex03Activity.kt - einen Baum von Komponenten schreiben
// -------------------------------------------------------------------------
// Compose hat keine Template-Sprache (kein HTML, kein XML): Die
// Bildschirme werden in Kotlin geschrieben, mit verschachtelten Aufrufen von @Composable-
// Funktionen. Und für Bedingungen und Schleifen verwenden wir ... die
// gewöhnlichen Kotlin-Anweisungen, DIREKT in der Funktion:
// - if (condition) { Component() } : eine Komponente, die nur EXISTIERT,
// wenn die Bedingung wahr ist;
// - if (c) { A() } else { B() } : die eine ODER die andere;
// - for (x in list) { Component(x) } : eine Komponente pro Element;
// - when (value) { case -> ... } : ein Wert unter mehreren.
// Eine @Composable-Funktion ist eine Funktion wie jede andere: Die ganze
// Sprache steht zur Beschreibung des Bildschirms zur Verfügung.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex03
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.Face
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
import androidx.compose.material3.Switch
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.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.alpha
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.R
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
// eine "Aufzählung": die einzig möglichen Werte einer Fachrichtung
enum class Specialty { GENERAL_PRACTITIONER, PEDIATRICIAN, CARDIOLOGIST }
// eine DATA-Klasse: Ihre Eigenschaften sind val, ein Doctor-Objekt ändert sich nie.
// Kotlin ergänzt equals, hashCode, toString und copy
data class Doctor(
val id: Int,
val title: String,
val firstName: String,
val lastName: String,
val specialty: Specialty,
val available: Boolean,
)
val doctors = listOf(
Doctor(1, "Mme", "Marie", "PELISSIER", Specialty.GENERAL_PRACTITIONER, true),
Doctor(2, "Mr", "Paul", "TATOU", Specialty.PEDIATRICIAN, false),
Doctor(3, "Melle", "Sophie", "DUPONT", Specialty.CARDIOLOGIST, true),
)
// "ein Wert unter mehreren, abhängig von einem Wert": ein when-AUSDRUCK.
// Der Compiler prüft, dass alle Fälle der Aufzählung behandelt werden
fun label(s: Specialty): String = when (s) {
Specialty.GENERAL_PRACTITIONER -> "general practitioner"
Specialty.PEDIATRICIAN -> "pediatrician"
Specialty.CARDIOLOGIST -> "cardiologist"
}
// ein Icon und seine Farbe: ein "Paar" von Werten (Pair), mit "to" geschrieben
fun icon(s: Specialty): Pair<ImageVector, Color> = when (s) {
Specialty.PEDIATRICIAN -> Icons.Default.Face to Color(0xFFFF9800)
Specialty.CARDIOLOGIST -> Icons.Default.Favorite to Color.Red
else -> Icons.Default.AddCircle to Color(0xFF009688) // else: alle übrigen Fälle
}
class Ex03Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { DoctorsPage() } }
}
}
@Composable
fun DoctorsPage() {
var filter by rememberSaveable { mutableStateOf("") } // der gesuchte Text
var onlyAvailable by rememberSaveable { mutableStateOf(false) }
var showHelp by rememberSaveable { mutableStateOf(true) }
// die angezeigte Liste: eine gewöhnliche Variable, bei jeder Ausführung neu berechnet
val text = filter.trim().lowercase()
val displayed = doctors.filter { d ->
(!onlyAvailable || d.available) &&
"${d.firstName} ${d.lastName} ${label(d.specialty)}".lowercase().contains(text)
}
ExamplePage(
title = "Example 03 - components",
// ein mit der Anwendung ausgeliefertes Vektorbild (res/drawable/doctor.xml)
icon = {
Image(
painter = painterResource(R.drawable.doctor),
contentDescription = null,
modifier = Modifier.padding(12.dp).size(28.dp),
)
},
) {
OutlinedTextField(
value = filter,
onValueChange = { filter = it }, // it: der einzige Parameter eines Lambdas
placeholder = { Text("search...") },
leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
modifier = Modifier.fillMaxWidth(),
)
// ein Schalter mit seiner Beschriftung
ListItem(
headlineContent = { Text("available only") },
trailingContent = { Switch(checked = onlyAvailable, onCheckedChange = { onlyAvailable = it }) },
)
TextButton(onClick = { showHelp = !showHelp }) {
Text(if (showHelp) "Hide help" else "Show help")
}
// ein if: Diese Komponente EXISTIERT nur, wenn showHelp true ist
if (showHelp) {
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFE1F5FE))) {
Text(
"Type a name or a specialty. Unavailable doctors are greyed out.",
Modifier.padding(12.dp),
)
}
}
// "einer der drei Blöcke": ein when ohne Argument, wie eine Folge von if
when {
doctors.isEmpty() -> Text("No doctor.")
displayed.isEmpty() -> Text("No doctor matches \"$filter\".", color = Color(0xFFFF5722))
else -> Column {
// eine Komponente pro Arzt, mit seinem Rang: withIndex()
for ((i, d) in displayed.withIndex()) {
DoctorRow(i + 1, d)
}
}
}
Spacer(Modifier.height(12.dp))
// ein BERECHNETER Stil: Die Textgröße hängt von der Anzahl der angezeigten Ärzte ab
Text(
"${displayed.size} doctor(s) displayed - the size of this text depends on it.",
fontSize = (12 + displayed.size * 2).sp,
)
}
}
// eine Zeile der Liste: eine @Composable-Funktion mit Parametern
@Composable
fun DoctorRow(rank: Int, d: Doctor) {
val (image, color) = icon(d.specialty) // eine "Destrukturierung" des Paars
ListItem(
// alpha: Nicht verfügbare Ärzte werden ausgegraut
modifier = Modifier.alpha(if (d.available) 1f else 0.5f),
leadingContent = { Text("$rank", style = MaterialTheme.typography.titleMedium) },
headlineContent = { Text("${d.title} ${d.firstName} ${d.lastName}") },
// FlowRow: wie eine Row, bricht aber in die nächste Zeile um, wenn der Platz fehlt
supportingContent = {
FlowRow(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
Icon(image, contentDescription = null, tint = color, modifier = Modifier.size(18.dp))
Text(label(d.specialty))
}
},
trailingContent = {
SuggestionChip(
onClick = {},
label = { Text(if (d.available) "available" else "unavailable") },
// eine durch einen bedingten Ausdruck gewählte Farbe
colors = SuggestionChipDefaults.suggestionChipColors(
containerColor = if (d.available) Color(0xFFC8E6C9) else Color(0xFFE0E0E0),
),
)
},
)
}
|
- Zeilen 68–78: eine Aufzählung und eine Datenklasse ([data class]): [Kotlin] schreibt [equals], [hashCode], [toString] und [copy];
- Zeilen 89–99: ein [when]-AUSDRUCK: ein Wert unter mehreren; der Compiler prüft, dass alle Fälle der Aufzählung behandelt werden ([else]: alle übrigen). [to] erzeugt ein Paar ([Pair]);
- Zeilen 117–120: die angezeigte Liste, bei jeder Ausführung anhand des Zustands berechnet ([filter]);
- Zeilen 126–130: [icon]: ein Slot von [ExamplePage] für das Symbol der oberen Leiste. [painterResource(R.drawable.doctor)]: ein Bild der Anwendung (eine VECTOR-Datei, das Vektorformat von [Android], aus der SVG-Datei des Flutter-Beispiels mit [New / Vector Asset] von [Android Studio] umgewandelt). [R]: die generierte Klasse, die jeder Ressource eine Nummer zuweist;
- Zeile 136: [it]: der Name des einzigen Parameters eines Lambdas;
- Zeile 150: ein [if]: Die Komponente EXISTIERT nur, wenn die Bedingung wahr ist;
- Zeilen 159–165: ein [when] ohne Argument (eine Folge von [if]): einer der drei Blöcke; eine [for]-Schleife mit dem Rang jedes Elements ([withIndex()] und eine Destrukturierung [(i, d)]);
- Zeile 173: ein berechneter Stil: Die Textgröße hängt von der Anzahl der Ärzte ab ([sp]: die Einheit für Text, die der Einstellung der Textgröße des Smartphones folgt; [dp]: die Einheit für Abstände);
- Zeilen 180–199: eine Listenzeile ([ListItem], mit ihren Positionen [leadingContent], [headlineContent] ...), durch [Modifier.alpha] ausgegraut, wenn der Arzt nicht verfügbar ist; [FlowRow]: eine Zeile, die in die nächste umbricht, wenn der Platz nicht reicht; ein Aufzählungspunkt ([SuggestionChip]), dessen Farbe vom Arzt abhängt.



3.4. Beispiel 04: Ereignisse
Eine To-do-Liste: Man kann Einträge hinzufügen, abhaken und löschen (mit einer Schaltfläche oder durch Wischen der Zeile – die typische Geste auf einem Mobilgerät), dazu ein berührungsempfindlicher Bereich. Eine interaktive Komponente erhält FUNKTIONEN als Parameter, die aufgerufen werden, wenn etwas geschieht: Das sind die „Ereignisse“ von [Compose].
| // =========================================================================
// ex04/Ex04Activity.kt - auf die Aktionen des Benutzers reagieren
// -------------------------------------------------------------------------
// Eine interaktive Komponente erhält als Parameter die FUNKTIONEN, die aufzurufen sind,
// wenn etwas passiert ("Callbacks", Kotlin-Lambdas):
// - onClick = { ... } : beim Drücken aufgerufen (Schaltflächen);
// - onClick = { remove(t) } : das Lambda übergibt seine eigenen Argumente;
// - onValueChange, onCheckedChange : die Funktion erhält einen Wert (den
// Text, das angekreuzte Kästchen ...);
// - Modifier.pointerInput : fügt JEDER Komponente Gesten hinzu (Tippen,
// Doppeltippen,
// langes Drücken ...);
// - SwipeToDismissBox : eine Zeile wischen, um sie
// zu entfernen, die typische mobile Geste.
// Um einem Feld per Code den Fokus zu geben, verknüpfen wir einen
// FocusRequester damit.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex04
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SwipeToDismissBox
import androidx.compose.material3.Text
import androidx.compose.material3.rememberSwipeToDismissBoxState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
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.input.key.Key
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.style.TextDecoration
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 java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.math.roundToInt
// eine Aufgabe: eine UNVERÄNDERLICHE Data-Klasse; um sie "abzuhaken",
// erstellen wir eine Kopie davon: task.copy(done = true)
data class Task(val id: Int, val label: String, val done: Boolean = false)
class Ex04Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { TasksPage() } }
}
}
@Composable
fun TasksPage() {
// von Compose BEOBACHTETE Listen: Das Hinzufügen, Entfernen oder Ersetzen eines
// Elements löst die Rekomposition aus. (remember und nicht rememberSaveable:
// Sie gehen verloren, wenn die Activity neu erzeugt wird, vgl. Beispiel 20)
val tasks = remember {
mutableStateListOf(Task(1, "Install Android Studio", done = true), Task(2, "Read the chapter on events"))
}
val log = remember { mutableStateListOf<String>() }
var input by remember { mutableStateOf("") }
var nextId by remember { mutableIntStateOf(3) }
// der FocusRequester: eine Möglichkeit, dem Feld per Code den Fokus zu geben (den Cursor und die
// Tastatur des Smartphones)
val focus = remember { FocusRequester() }
fun trace(message: String) {
val time = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm"))
log.add(0, "$time $message")
}
// aufgerufen von der Schaltfläche UND von der "OK"-Taste der Tastatur (keyboardActions)
fun add() {
val label = input.trim()
if (label.isEmpty()) {
return
}
tasks.add(Task(nextId++, label))
trace("added \"$label\"")
input = ""
// der Fokus kehrt zum Feld zurück: Die nächste Aufgabe kann eingegeben werden
focus.requestFocus()
}
fun toggle(task: Task, done: Boolean) {
// wir ERSETZEN die Aufgabe durch eine geänderte Kopie
tasks[tasks.indexOf(task)] = task.copy(done = done)
trace("\"${task.label}\": ${if (done) "done" else "to do"}")
}
fun remove(task: Task, how: String) {
tasks.remove(task)
trace("removed \"${task.label}\" ($how)")
}
// die Bildschirmdichte: zur Umrechnung von Pixeln in dp
val density = LocalDensity.current.density
ExamplePage("Example 04 - events") {
Row(verticalAlignment = Alignment.CenterVertically) {
OutlinedTextField(
value = input,
onValueChange = { input = it },
placeholder = { Text("new task (Escape to clear)") },
singleLine = true,
// die "OK"-Taste der Smartphone-Tastatur fügt die Aufgabe hinzu
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
keyboardActions = KeyboardActions(onDone = { add() }),
modifier = Modifier
.weight(1f)
.focusRequester(focus)
// eine physische Tastatur (Emulator, Tablet): Escape leert das Feld
.onPreviewKeyEvent { event ->
if (event.key == Key.Escape) {
input = ""
true // das Ereignis ist behandelt
} else {
false // das Ereignis setzt seinen Weg fort
}
},
)
Spacer(Modifier.width(8.dp))
Button(onClick = { add() }) { Text("Add") }
}
Spacer(Modifier.height(12.dp))
for (t in tasks) {
// key(t.id): die IDENTITÄT der Zeile. Der Zustand jeder Zeile (ihr
// Wischen) folgt IHRER Aufgabe, auch wenn sich die Liste ändert (vgl. den Kurs)
key(t.id) {
TaskRow(
task = t,
onToggle = { done -> toggle(t, done) },
onRemove = { how -> remove(t, how) },
)
}
}
Spacer(Modifier.height(12.dp))
// pointerInput: Jede Komponente wird empfindlich für Gesten
Box(
contentAlignment = Alignment.Center,
modifier = Modifier
.fillMaxWidth()
.height(80.dp)
.background(Color(0xFFE7F5FF), RoundedCornerShape(8.dp))
.pointerInput(Unit) {
detectTapGestures(
// die Position des Drucks relativ zur Komponente (in Pixeln)
onPress = { p -> trace("press at (${(p.x / density).roundToInt()}, ${(p.y / density).roundToInt()})") },
onDoubleTap = { trace("double tap") },
onLongPress = { trace("long press") },
)
},
) {
Text("Touch this area (tap, double tap, long press)")
}
Spacer(Modifier.height(16.dp))
Text("Log", style = MaterialTheme.typography.titleSmall)
for (line in log) {
Text(line, fontSize = 12.sp)
}
}
}
// eine Zeile der Liste: die Aufgabe und ZWEI Funktionen, um den Aufrufer zu benachrichtigen
@Composable
fun TaskRow(task: Task, onToggle: (Boolean) -> Unit, onRemove: (String) -> Unit) {
// der Wischzustand der Zeile (wo befindet sie sich?)
val swipe = rememberSwipeToDismissBoxState()
// SwipeToDismissBox: Das Wischen der Zeile nach links entfernt sie
SwipeToDismissBox(
state = swipe,
enableDismissFromStartToEnd = false,
// onDismiss: wird aufgerufen, wenn die Zeile ganz weggewischt wurde
onDismiss = { onRemove("swipe") },
// was UNTER der Zeile erscheint, wenn sie gewischt wird
backgroundContent = {
Box(
contentAlignment = Alignment.CenterEnd,
modifier = Modifier.fillMaxSize().background(Color(0xFFFFCDD2)).padding(end = 16.dp),
) {
Icon(Icons.Default.Delete, contentDescription = null)
}
},
) {
ListItem(
// das Kästchen steht LINKS, wie bei einer Aufgabenliste; es
// gibt seinen neuen Wert (einen Boolean) weiter
leadingContent = { Checkbox(checked = task.done, onCheckedChange = onToggle) },
headlineContent = {
Text(
task.label,
style = if (task.done) {
TextStyle(textDecoration = TextDecoration.LineThrough, color = Color.Gray)
} else {
TextStyle.Default
},
)
},
trailingContent = {
IconButton(onClick = { onRemove("button") }) {
Icon(Icons.Outlined.Delete, contentDescription = "remove", tint = Color.Red)
}
},
)
}
}
|
- Zeile 84: eine Aufgabe, ein UNVERÄNDERLICHES Objekt; ihr Abhaken erzeugt eine Kopie ([copy(done = true)]), die sie ERSETZT;
- Zeilen 99–102: [mutableStateListOf]: eine von [Compose] BEOBACHTETE Liste; das Hinzufügen, Entfernen oder Ersetzen eines Elements löst einen Neuaufbau aus. Hier bleiben wir bei [remember] (nicht [rememberSaveable]): Diese Listen gehen verloren, wenn die Activity neu erzeugt wird;
- Zeile 107: ein [FocusRequester], über den der Code dem Feld nach jedem Hinzufügen den Fokus gibt (den Cursor und die Tastatur) ([focus.requestFocus()]);
- Zeilen 115–135: drei lokale Funktionen, die den Zustand ändern und das Protokoll führen;
- Zeilen 149–150: [imeAction = ImeAction.Done]: Die Bestätigungstaste der Smartphone-Tastatur wird zu „OK“, und [keyboardActions] legt fest, was beim Drücken geschehen soll: die Aufgabe hinzufügen;
- Zeilen 68–160: [onPreviewKeyEvent] empfängt Tastenanschläge einer PHYSISCHEN Tastatur (der PC-Tastatur im Emulator oder der Tastatur eines Tablets): [Escape] leert das Feld. Die Rückgabe von [true] stoppt das Ereignis;
- Zeilen 171–175: [key(t.id)] weist jeder Zeile eine IDENTITÄT zu. Ohne [key] ordnet [Compose] den Zustand einer Zeile (hier ihre Scrollposition) ihrer POSITION in der Liste zu: Nach einem Löschen würde die nächste Zeile den Zustand der gelöschten Zeile erben. Die beiden Lambda-Ausdrücke [onToggle] und [onRemove] „erfassen“ die Aufgabe [t] und reichen weiter, was die Zeile ihnen übergibt;
- Zeilen 187–192: [Modifier.pointerInput] macht JEDE Komponente gestenempfindlich: Er unterscheidet zwischen einem einfachen Tippen, einem doppelten Tippen und einem langen Drücken. Die Position wird in Pixeln angegeben: Sie wird anhand der Bildschirmdichte ([LocalDensity]) in [dp] umgerechnet;
- Zeile 208: [TaskRow] erhält die Aufgabe und ZWEI Funktionen, um ihren Aufrufer zu benachrichtigen: Sie ändert die Liste nicht selbst (siehe Beispiel 11);
- Zeilen 212–218: [SwipeToDismissBox]: Die Zeile bewegt sich nach links ([enableDismissFromStartToEnd = false] verhindert die Bewegung in die andere Richtung) und gibt [backgroundContent] frei; Am Ende der Bewegung wird [onDismiss] aufgerufen;
- Zeile 230: Die Checkbox übermittelt ihren neuen Wert ([Boolean]): [onToggle], das den passenden Typ [(Boolean) -> Unit] hat, wird ihr direkt übergeben.



Links wurde eine Aufgabe hinzugefügt, eine weitere abgehakt und der Bereich angetippt; in der Mitte gleitet die erste Zeile nach links; rechts wurde sie gelöscht, und das Protokoll bestätigt dies.
3.5. Beispiel 05: Alle Feldtypen
Bei [Compose] sind ALLE Felder GESTEUERT: Das Feld zeigt einen Wert aus dem Zustand an und meldet jede Änderung über eine Funktion, die den Zustand aktualisiert. Was diese Funktion übermittelt, hängt vom Feld ab:
- [OutlinedTextField]: der neue Text ([String]);
- [Checkbox], [Switch]: ein [Boolean];
- [RadioButton], [FilterChip]: nichts – der Eintrag IST ausgewählt;
- [Slider]: ein [Float];
- [DatePickerDialog]: ein Datum, nach der Bestätigung.
Für die Dropdown-Liste stellt [Material 3] keine einzelne, in sich geschlossene Komponente bereit: Sie wird ein für alle Mal in [common/DropdownList.kt] zusammengesetzt:
| // =========================================================================
// common/DropdownList.kt - eine Dropdown-Liste, gebrauchsfertig
// -------------------------------------------------------------------------
// Material 3 für Compose hat keine "Dropdown-Liste" als
// fertige Komponente: Sie wird aus drei Elementen zusammengesetzt - ExposedDropdownMenuBox,
// einem schreibgeschützten Textfeld und dem Menü ExposedDropdownMenu. Wir
// machen das hier ein für alle Mal (Beispiele 05 bis 08, 24, 25):
//
// DropdownList("Country", value = country, choices = listOf("fr", "be", "ch"),
// text = { countryNames[it] }, onChange = { country = it })
//
// Die Funktion ist GENERISCH (<T>): Die Auswahlmöglichkeiten können Strings,
// Zahlen, Ärzte ... sein. text gibt an, wie eine Auswahl ANGEZEIGT wird. Eine Auswahl
// kann null sein ("- choose -"), wenn T ein "nullable" Typ (Int?) ist.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.common
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuAnchorType
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
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
@Composable
fun <T> DropdownList(
label: String,
value: T,
choices: List<T>,
onChange: (T) -> Unit,
modifier: Modifier = Modifier,
text: (T) -> String = { it.toString() },
// eine Fehlermeldung unter dem Feld (vgl. Beispiele 07 und 25)
error: String? = null,
) {
// ist das Menü geöffnet? ein Zustand, der SPEZIFISCH für jede Dropdown-Liste ist
var open by remember { mutableStateOf(false) }
ExposedDropdownMenuBox(expanded = open, onExpandedChange = { open = it }, modifier = modifier) {
// das Feld, das die aktuelle Auswahl anzeigt; menuAnchor macht es zum
// Ankerpunkt des Menüs (die Berührung öffnet das Menü)
OutlinedTextField(
value = text(value),
onValueChange = {},
readOnly = true,
singleLine = true,
label = { Text(label) },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = open) },
isError = error != null,
supportingText = if (error == null) null else { { Text(error) } },
modifier = Modifier.menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable).fillMaxWidth(),
)
// das Menü: eine Zeile pro Auswahlmöglichkeit
ExposedDropdownMenu(expanded = open, onDismissRequest = { open = false }) {
for (c in choices) {
DropdownMenuItem(
text = { Text(text(c)) },
onClick = {
onChange(c)
open = false
},
)
}
}
}
}
|
- Zeilen 36–44: [fun <T> DropdownList]: eine GENERISCHE Funktion: Die Auswahlmöglichkeiten können Zeichenketten, Zahlen, Ärzte ... sein. [text] legt fest, wie eine Auswahl angezeigt wird (standardmäßig ihr [toString()]);
- Zeile 47: der für jede Liste spezifische Zustand: Ist das Menü geöffnet?
- Zeilen 48–49: [ExposedDropdownMenuBox] verbindet ein SCHREIBGESCHÜTZTES Feld ([readOnly = true]), das die aktuelle Option anzeigt, mit einem Menü; [menuAnchor] macht das Feld zum Ankerpunkt des Menüs;
- Zeilen 63–68: eine Menüzeile pro Option; ihr Antippen benachrichtigt den Aufrufer ([onChange(c)]) und schließt das Menü.
Der Code des Beispiels:
| // =========================================================================
// ex05/Ex05Activity.kt - alle Arten von Feldern
// -------------------------------------------------------------------------
// Mit Compose sind ALLE Felder GESTEUERT: Ein Feld zeigt einen
// Wert des Zustands an (value, checked, selected ...) und meldet jede
// Änderung über eine Funktion (onValueChange, onCheckedChange, onClick ...),
// die den Zustand aktualisiert. Der Zustand ist die einzige Quelle der Wahrheit: Die Änderung
// des Zustands (per Code) ändert das Feld. Was die Funktion weitergibt,
// hängt vom Feld ab:
// - OutlinedTextField -> der neue Text (String);
// - Checkbox, Switch -> Boolean;
// - RadioButton -> nichts: onClick ist die Auswahl;
// - DropdownList (common/) -> der Wert des gewählten Elements;
// - FilterChip -> nichts: onClick schaltet den Chip um;
// - Slider -> Float;
// - DatePickerDialog (ein Dialog) -> ein Datum, bei Bestätigung.
// Alles geschieht auf dem Smartphone, ohne Server.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex05
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.selectableGroup
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.Checkbox
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Slider
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
val titles = listOf("Mr", "Mme", "Melle")
val hobbies = listOf("sport", "music", "reading", "cinema")
val countries = mapOf("fr" to "France", "be" to "Belgium", "ch" to "Switzerland")
val languages = mapOf("fr" to "French", "en" to "English", "es" to "Spanish")
// alle Werte, in einem Objekt gebündelt (was an einen Server gesendet würde).
// @Serializable: Das kotlinx.serialization-Plugin kann es in JSON umwandeln
@Serializable
data class Model(
val title: String,
val name: String,
val age: Int?,
val presentation: String,
val newsletter: Boolean,
val hobbies: List<String>,
val country: String,
val languages: List<String>,
val birthDate: String?,
val satisfaction: Int,
)
// der JSON-Konverter: prettyPrint, eingerücktes JSON
val indentedJson = Json { prettyPrint = true }
class Ex05Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { FormPage() } }
}
}
@Composable
fun FormPage() {
// ein Zustand pro Feld des Formulars
var title by rememberSaveable { mutableStateOf("Mme") }
var name by rememberSaveable { mutableStateOf("") }
var age by rememberSaveable { mutableStateOf("30") }
var presentation by rememberSaveable { mutableStateOf("") } // der VALIDIERTE Wert
var draft by rememberSaveable { mutableStateOf("") } // der gerade eingegebene Text
var newsletter by rememberSaveable { mutableStateOf(false) }
var myHobbies by rememberSaveable { mutableStateOf(setOf("reading")) } // ein SET: keine Duplikate
var myCountry by rememberSaveable { mutableStateOf("fr") }
var myLanguages by rememberSaveable { mutableStateOf(setOf<String>()) }
var birthDate by rememberSaveable { mutableStateOf<LocalDate?>(null) } // null: noch nicht gewählt
var satisfaction by rememberSaveable { mutableFloatStateOf(3f) }
var sent by rememberSaveable { mutableStateOf<String?>(null) }
var calendarOpen by rememberSaveable { mutableStateOf(false) }
// das Modell: ein aus dem Zustand BERECHNETER Wert
val model = Model(
title = title,
name = name.trim(),
age = age.toIntOrNull(), // null, wenn das Feld leer ist
presentation = presentation,
newsletter = newsletter,
hobbies = myHobbies.toList(),
country = myCountry,
languages = myLanguages.toList(),
birthDate = birthDate?.toString(), // "2026-10-05": das Datumsformat der RdvMedecins-API
satisfaction = satisfaction.toInt(),
)
val titleStyle = MaterialTheme.typography.titleSmall
ExamplePage("Example 05 - controlled fields") {
Text("Title", style = titleStyle)
// selectableGroup: eine Gruppe von Radiobuttons (für die Barrierefreiheit)
Row(Modifier.selectableGroup(), verticalAlignment = Alignment.CenterVertically) {
for (t in titles) {
// selectable: die GANZE Zeile (Schaltfläche + Text) reagiert auf das Drücken
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.selectable(selected = title == t, onClick = { title = t }, role = Role.RadioButton),
) {
RadioButton(selected = title == t, onClick = null)
Text(t)
Spacer(Modifier.width(12.dp))
}
}
}
Row {
OutlinedTextField(value = name, onValueChange = { name = it }, label = { Text("Name") }, modifier = Modifier.weight(2f))
Spacer(Modifier.width(12.dp))
OutlinedTextField(
value = age,
onValueChange = { age = it },
label = { Text("Age") },
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
modifier = Modifier.weight(1f),
)
}
// onFocusChanged: meldet, wenn das Feld den Fokus ERHÄLT oder VERLIERT. Die
// Darstellung wird erst beim Verlassen des Feldes in den Zustand übernommen
OutlinedTextField(
value = draft,
onValueChange = { draft = it },
label = { Text("Presentation (updated when leaving the field)") },
minLines = 2,
modifier = Modifier.fillMaxWidth().onFocusChanged { state ->
if (!state.isFocused) presentation = draft
},
)
// ein einzelnes Kästchen: true / false. toggleable: Die ganze Zeile reagiert
ListItem(
modifier = Modifier.toggleable(value = newsletter, onValueChange = { newsletter = it }, role = Role.Checkbox),
leadingContent = { Checkbox(checked = newsletter, onCheckedChange = null) },
headlineContent = { Text("Receive the newsletter") },
)
Text("Hobbies", style = titleStyle)
// mehrere Chips für EINE Menge: Der Wert wird hinzugefügt oder entfernt
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
for (h in hobbies) {
FilterChip(
selected = h in myHobbies,
onClick = { myHobbies = if (h in myHobbies) myHobbies - h else myHobbies + h },
label = { Text(h) },
)
}
}
// eine Dropdown-Liste: value gibt an, welches Element gewählt ist
DropdownList(
label = "Country",
value = myCountry,
choices = countries.keys.toList(),
text = { code -> countries.getValue(code) },
onChange = { myCountry = it },
modifier = Modifier.width(220.dp),
)
Text("Spoken languages", style = titleStyle)
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
for ((code, label) in languages) {
FilterChip(
selected = code in myLanguages,
onClick = { myLanguages = if (code in myLanguages) myLanguages - code else myLanguages + code },
label = { Text(label) },
)
}
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text("Satisfaction: ${satisfaction.toInt()} / 5", style = titleStyle)
// ein Slider von 1 bis 5: 3 Zwischenschritte (2, 3, 4)
Slider(
value = satisfaction,
onValueChange = { satisfaction = it },
valueRange = 1f..5f,
steps = 3,
modifier = Modifier.weight(1f).padding(start = 8.dp),
)
}
ListItem(
leadingContent = { Icon(Icons.Default.DateRange, contentDescription = null) },
headlineContent = { Text("Date of birth") },
supportingContent = { Text(birthDate?.toString() ?: "not chosen") },
trailingContent = { OutlinedButton(onClick = { calendarOpen = true }) { Text("Choose") } },
)
// FlowRow: Die Schaltflächen brechen auf einem schmalen Bildschirm in die nächste Zeile um
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = { sent = Json.encodeToString(Model.serializer(), model) }) { Text("Send") }
// der Zustand, der PER CODE geändert wird: Die Felder folgen
OutlinedButton(onClick = {
title = "Mr"
name = "MARTIN"
age = "42"
myHobbies = setOf("sport", "cinema")
myCountry = "be"
}) { Text("Fill in by code") }
}
Spacer(Modifier.height(8.dp))
Text("The model, live", style = titleStyle)
Text(
indentedJson.encodeToString(Model.serializer(), model),
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp),
)
// ein Block, der erst nach einem Absenden existiert; ?.let: nur wenn sent nicht null ist
sent?.let { json ->
Text("Last submission", style = titleStyle)
Text(
json,
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFE8F5E9)).padding(8.dp),
)
}
}
// der Kalenderdialog: Er existiert nur, wenn calendarOpen true ist
if (calendarOpen) {
// der Zustand des Kalenders: das gewählte Datum in Millisekunden (UTC)
val calendarState = rememberDatePickerState(
initialSelectedDateMillis = (birthDate ?: LocalDate.of(2000, 1, 1)).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
)
DatePickerDialog(
onDismissRequest = { calendarOpen = false },
confirmButton = {
TextButton(onClick = {
calendarState.selectedDateMillis?.let { ms ->
birthDate = Instant.ofEpochMilli(ms).atZone(ZoneOffset.UTC).toLocalDate()
}
calendarOpen = false
}) { Text("OK") }
},
dismissButton = { TextButton(onClick = { calendarOpen = false }) { Text("Cancel") } },
) {
DatePicker(state = calendarState)
}
}
}
|
- Zeilen 89–101: alle Formularwerte, in einer Klasse [@Serializable] zusammengefasst: Das Plugin [kotlinx.serialization] erzeugt zur Kompilierzeit Code, der sie in JSON umwandelt ([Json.encodeToString(Model.serializer(), model)]);
- Zeilen 118–130: ein Zustand pro Feld. [myHobbies] ist eine UNVERÄNDERLICHE MENGE ([Set]): [myHobbies + h] und [myHobbies - h] erzeugen neue; [birthDate] ist ein „nullbares“ Datum ([LocalDate?]): [null], bis ein Wert ausgewählt wird;
- Zeilen 133–143: das Modell, ein bei jeder Ausführung BERECHNETER Wert; [toIntOrNull()]: die Zahl oder [null], wenn der Text keine Zahl ist;
- Zeilen 150–157: Radiobuttons. [Modifier.selectable] macht die GANZE Zeile (die Schaltfläche und den Text) anklickbar; die Schaltfläche selbst hat daher keine Aktion ([onClick = null]); [selectableGroup] gruppiert die Schaltflächen für Bedienungshilfen;
- Zeilen 177–182: Die Darstellung wird erst beim VERLASSEN des Feldes in den Zustand übernommen; [onFocusChanged] löst eine Benachrichtigung aus, wenn das Feld den Fokus erhält oder verliert;
- Zeilen 187–189: eine Checkbox, die genauso funktioniert wie die Radiobuttons ([Modifier.toggleable] über die gesamte Zeile);
- Zeilen 193–198: Kontrollkästchen ([FilterChip]) zur Auswahl mehrerer Werte; [FlowRow] bricht sie in die nächste Zeile um, wenn der Platz nicht reicht;
- Zeilen 203–208: die Dropdown-Liste aus [common/];
- Zeilen 224–228: ein Schieberegler von 1 bis 5: [steps = 3] mit Zwischenstufen;
- Zeilen 236–248: „Per Code ausfüllen“: Der Zustand wird geändert, und die Felder folgen;
- Zeilen 251–259: das Modell als eingerücktes JSON angezeigt ([Json [ prettyPrint = true ]]); [sent?.let [ ... ]]: Der Block existiert nur, wenn [sent] nicht [null] ist;
- Zeilen 271–288: Das Kalenderfenster existiert nur, wenn [calendarOpen] wahr ist. [DatePicker] arbeitet in Millisekunden seit dem 1. Januar 1970 (Zeit UTC): Die Umwandlung funktioniert in beide Richtungen mit [java.time] ([LocalDate], [Instant], [ZoneOffset.UTC]).



Der Kalender ([DatePickerDialog]) ist auf Englisch: [Material 3] folgt der Sprache der Anwendung (siehe Beispiel 21).
Beispiel 05 hatte eine Zustandsvariable pro Feld. Für ein echtes Formular bevorzugen wir EIN Objekt, das alle Werte enthält, und beschreiben seine Änderungen in einer einzigen REINEN Funktion, dem REDUCER: [reducer(currentState, action) -> newState]. Der Bildschirm ändert den Zustand nicht mehr: Er meldet, was geschehen ist („das Feld LASTNAME hat jetzt den Wert ‚Dupont‘“, „das Feld LASTNAME wurde verlassen“), und der Reducer leitet daraus den neuen Zustand ab.
| // =========================================================================
// ex06/Ex06Activity.kt - ein Formular, ein Objekt, ein Reducer
// -------------------------------------------------------------------------
// Beispiel 05 hatte eine Zustandsvariable pro Feld des Formulars. Für ein
// echtes Formular bevorzugen wir EIN Objekt, das alle Werte enthält, das
// MODELL (hier ein Profile-Objekt, unveränderlich), und wir beschreiben seine
// Änderungen in einer einzigen Funktion, dem REDUCER:
//
// reducer(currentState, action) -> newState
//
// Der Bildschirm ändert den Zustand nicht mehr: Er BESCHREIBT, was passiert ist, mit einem
// ProfileAction-Objekt (Update(Field.LASTNAME, "Dupont"), Leave(Field.LASTNAME) ...),
// und der Reducer leitet daraus den neuen Zustand ab. Die gesamte Logik steht an einer
// Stelle, in einer REINEN Funktion (gleiche Eingabe, gleiche Ausgabe, kein
// Seiteneffekt), leicht zu testen.
// Kotlin eignet sich gut dafür: Ein "sealed" Interface listet alle möglichen
// Aktionen auf, und ein when auf eine Aktion wird vom Compiler geprüft (ein
// vergessener Fall ist ein Fehler).
//
// Der Zustand merkt sich außerdem für jedes Feld, ob es "berührt" wurde (mindestens
// einmal verlassen); daraus leiten wir ab, ob es "geändert" ist (sein Wert weicht vom
// Anfangswert ab) und ob es deaktiviert ist.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex06
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.selection.selectable
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Slider
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
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.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.JsonObject
// der Name jedes Feldes des Formulars
enum class Field { TITLE, FIRSTNAME, LASTNAME, AGE, NEWSLETTER, EMAIL, COUNTRY, PRESENTATION }
// die Daten des Formulars: ein UNVERÄNDERLICHES Objekt (alles ist val). Um es
// zu "ändern", erstellen wir eine Kopie davon: profile.copy(lastName = "DUPONT"). Die
// Funktion copy wird von Kotlin für jede "data"-Klasse geschrieben
data class Profile(
val title: String,
val firstName: String,
val lastName: String,
val age: Int,
val newsletter: Boolean,
val email: String,
val country: String,
val presentation: String,
) {
// der Wert eines Feldes, über seinen Namen bezeichnet
fun value(f: Field): Any = when (f) {
Field.TITLE -> title
Field.FIRSTNAME -> firstName
Field.LASTNAME -> lastName
Field.AGE -> age
Field.NEWSLETTER -> newsletter
Field.EMAIL -> email
Field.COUNTRY -> country
Field.PRESENTATION -> presentation
}
// eine Kopie, in der EIN Feld, über seinen Namen bezeichnet, einen neuen Wert hat
fun withValue(f: Field, v: Any): Profile = when (f) {
Field.TITLE -> copy(title = v as String)
Field.FIRSTNAME -> copy(firstName = v as String)
Field.LASTNAME -> copy(lastName = v as String)
Field.AGE -> copy(age = v as Int)
Field.NEWSLETTER -> copy(newsletter = v as Boolean)
Field.EMAIL -> copy(email = v as String)
Field.COUNTRY -> copy(country = v as String)
Field.PRESENTATION -> copy(presentation = v as String)
}
// das JSON-Objekt des Profils: ein JSON-Feld pro Feld des Formulars
fun toJson(): JsonObject = JsonObject(
Field.entries.associate { f ->
val v = value(f)
f.name.lowercase() to when (v) {
is Int -> JsonPrimitive(v) // "is": ein Typtest; v ist dann ein Int
is Boolean -> JsonPrimitive(v)
else -> JsonPrimitive(v.toString())
}
},
)
}
val initial = Profile(
title = "Mme",
firstName = "Marie",
lastName = "PELISSIER",
age = 30,
newsletter = false,
email = "",
country = "fr",
presentation = "",
)
// der vollständige Zustand: die Werte und die bereits verlassenen Felder
data class State(val values: Profile, val touched: Set<Field>)
// die möglichen Aktionen. "sealed": Es gibt keine anderen als die
// hier deklarierten, der Compiler weiß das
sealed interface ProfileAction {
data class Update(val field: Field, val value: Any) : ProfileAction
data class Leave(val field: Field) : ProfileAction
data object Uppercase : ProfileAction // ein einzigartiges Objekt: Die Aktion hat keine Daten
data object Reset : ProfileAction
}
// der Reducer: Er ändert NIE den erhaltenen Zustand, er gibt einen neuen zurück.
// In jedem Zweig des when hat action den Typ des Zweigs ("Smart Cast"):
// action.field ist für ein Update zugänglich
fun reducer(state: State, action: ProfileAction): State = when (action) {
is ProfileAction.Update -> state.copy(values = state.values.withValue(action.field, action.value))
is ProfileAction.Leave -> state.copy(touched = state.touched + action.field)
ProfileAction.Uppercase -> state.copy(
values = state.values.copy(firstName = state.values.firstName.uppercase(), lastName = state.values.lastName.uppercase()),
)
ProfileAction.Reset -> State(initial, emptySet())
}
val titles = listOf("Mr", "Mme", "Melle")
val trackedFields = listOf(Field.FIRSTNAME, Field.LASTNAME, Field.AGE, Field.EMAIL)
val countryNames = mapOf("fr" to "France", "be" to "Belgium", "ch" to "Switzerland")
val indentedJson = Json { prettyPrint = true }
class Ex06Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { ProfilePage() } }
}
}
@Composable
fun ProfilePage() {
var state by remember { mutableStateOf(State(initial, emptySet())) }
// der EINZIGE Weg, den Zustand zu ändern: beschreiben, was passiert ist
fun dispatch(action: ProfileAction) {
state = reducer(state, action)
}
val v = state.values
// aus dem Zustand ABGELEITETE Werte
fun modified(f: Field) = v.value(f) != initial.value(f)
fun disabled(f: Field) = f == Field.EMAIL && !v.newsletter // die E-Mail setzt den Newsletter voraus
val formModified = Field.entries.any { modified(it) }
val titleStyle = MaterialTheme.typography.titleSmall
// ein an das Modell gebundenes Textfeld: eine LOKALE @Composable-Funktion
@Composable
fun TextField(field: Field, label: String, modifier: Modifier = Modifier, lines: Int = 1) {
// hatte das Feld bereits den Fokus? (ein für JEDES Feld spezifischer Zustand)
var hadFocus by remember { mutableStateOf(false) }
OutlinedTextField(
value = v.value(field) as String,
onValueChange = { text -> dispatch(ProfileAction.Update(field, text)) },
label = { Text(label) },
enabled = !disabled(field),
minLines = lines,
// das Feld wird VERLASSEN, wenn es den Fokus verliert ... nachdem es ihn hatte
modifier = modifier.onFocusChanged { f ->
if (f.isFocused) {
hadFocus = true
} else if (hadFocus) {
dispatch(ProfileAction.Leave(field))
}
},
)
}
ExamplePage("Example 06 - a reducer") {
Row(verticalAlignment = Alignment.CenterVertically) {
for (t in titles) {
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.selectable(selected = v.title == t, onClick = { dispatch(ProfileAction.Update(Field.TITLE, t)) }),
) {
RadioButton(selected = v.title == t, onClick = null)
Text(t)
Spacer(Modifier.width(12.dp))
}
}
}
Row {
TextField(Field.FIRSTNAME, "First name", Modifier.weight(1f))
Spacer(Modifier.width(12.dp))
TextField(Field.LASTNAME, "Last name", Modifier.weight(1f))
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text("Age: ${v.age}", style = titleStyle)
Slider(
value = v.age.toFloat(),
onValueChange = { a -> dispatch(ProfileAction.Update(Field.AGE, a.toInt())) },
valueRange = 0f..120f,
steps = 119,
// der Slider wird losgelassen: Das Feld wurde "verlassen"
onValueChangeFinished = { dispatch(ProfileAction.Leave(Field.AGE)) },
modifier = Modifier.weight(1f).padding(start = 8.dp),
)
}
ListItem(
headlineContent = { Text("Receive the newsletter") },
trailingContent = {
Switch(checked = v.newsletter, onCheckedChange = { yes -> dispatch(ProfileAction.Update(Field.NEWSLETTER, yes)) })
},
)
TextField(Field.EMAIL, "E-mail (if newsletter)", Modifier.fillMaxWidth())
DropdownList(
label = "Country",
value = v.country,
choices = countryNames.keys.toList(),
text = { countryNames.getValue(it) },
onChange = { c -> dispatch(ProfileAction.Update(Field.COUNTRY, c)) },
modifier = Modifier.width(220.dp),
)
TextField(Field.PRESENTATION, "About you", Modifier.fillMaxWidth(), lines = 2)
Spacer(Modifier.height(8.dp))
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
OutlinedButton(onClick = { dispatch(ProfileAction.Uppercase) }) { Text("Name in uppercase") }
OutlinedButton(onClick = { dispatch(ProfileAction.Reset) }) { Text("Reset") }
}
Spacer(Modifier.height(8.dp))
Text("The model, live", style = titleStyle)
Text(
indentedJson.encodeToString(JsonObject.serializer(), v.toJson()),
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp),
)
Spacer(Modifier.height(8.dp))
Text("The state of the fields", style = titleStyle)
// eine kleine Tabelle: eine Row pro Zeile, Spalten gleicher Breite (weight)
val headers = listOf("field", "touched", "modified", "disabled")
Row { for (h in headers) Text(h, Modifier.weight(1f), fontWeight = FontWeight.Bold) }
HorizontalDivider()
for (f in trackedFields) {
Row {
Text(f.name.lowercase(), Modifier.weight(1f))
Text("${f in state.touched}", Modifier.weight(1f))
Text("${modified(f)}", Modifier.weight(1f))
Text("${disabled(f)}", Modifier.weight(1f))
}
}
Spacer(Modifier.height(8.dp))
// ein Text mit mehreren Stilen: buildAnnotatedString
Text(
buildAnnotatedString {
append("form modified: ")
withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append("$formModified") }
},
)
}
}
|
- Zeile 77: der Name jedes Feldes, eine Liste;
- Zeilen 82–113: das Profil, das nicht verändert werden kann, mit zwei Funktionen, um das über seinen Namen bezeichnete Feld zu lesen oder zu ersetzen ([v as String]: eine Typumwandlung, zur Laufzeit geprüft);
- Zeilen 117–123: das Profil in JSON: [Field.entries], die Liste der Werte der Aufzählung; [associate] erzeugt eine [Map]; [is Int]: eine Typprüfung, nach der [v] als [Int] erkannt wird (der „Smart Cast“);
- Zeile 141: der vollständige Zustand: die Werte und alle Felder, die bereits verlassen wurden („touched“);
- Zeilen 145–149: die möglichen Aktionen. [sealed]: Es gibt keine anderen als die hier deklarierten, und der Compiler weiß das. [data object]: eine Aktion ohne Daten, ein einziges Objekt;
- Zeilen 155–161: der Reducer: ein [when] auf die Aktion, ohne [else]: Der Compiler prüft, dass ALLE Aktionen verarbeitet werden. In jedem Zweig hat [action] den Typ des Zweigs: [action.field] ist für ein [Update] zugänglich;
- Zeilen 179–183: der Zustand und der EINZIGE Weg, ihn zu ändern, [dispatch(action)];
- Zeilen 188–190: aus dem Zustand ABGELEITETE Werte: Ein Feld gilt als „geändert“, wenn sein Wert vom Anfangswert abweicht; die E-Mail ist ohne den Newsletter deaktiviert;
- Zeilen 195–209: eine LOKALE [@Composable]-Funktion (in einer anderen definiert): ein an das Modell gebundenes Textfeld. Jedes Feld hat seinen eigenen Zustand ([hadFocus]): Es wird „verlassen“, wenn es den Fokus verliert, nachdem es ihn hatte;
- Zeilen 236–241: der Schieberegler für das Alter: [onValueChangeFinished] wird aufgerufen, wenn er losgelassen wird;
- Zeilen 277–285: eine einfache Tabelle, eine [Row] pro Zeile, mit gleich breiten Spalten ([weight(1f)]);
- Zeilen 291–293: Text mit mehreren Stilen: [buildAnnotatedString].


Der Reducer ist eine gewöhnliche Funktion: Er lässt sich ohne Bildschirm mit einem einfachen Unit-Test testen ([assertEquals(expected, reducer(state, action))]).
Das Formular „Konto erstellen“ der Anwendung RdvMedecins, mit denselben Regeln wie der Server. Eine reine Funktion, [validate(account)], liefert Fehler; diese werden nur für Felder angezeigt, die bereits verlassen wurden, oder nach einem Versuch, das Formular abzusenden.
| // =========================================================================
// ex07/Ex07Activity.kt - ein Formular von Hand validieren
// -------------------------------------------------------------------------
// Eine REINE Funktion, validate(account), gibt die Fehler der Felder zurück; wir
// rufen sie bei jeder Ausführung der @Composable-Funktion auf: Die Fehler
// sind daher immer aktuell.
// Wir zeigen sie nicht sofort an (ein leeres, ganz rotes Formular ist
// unangenehm): nur für ein bereits verlassenes Feld ("touched"). Das Absenden
// markiert alle Felder als touched und handelt erst dann, wenn das Formular
// gültig ist. Ein OutlinedTextField zeigt einen Fehler unter dem Feld an, wenn
// ihm isError = true und ein supportingText übergeben werden.
//
// Dieselben Regeln wie beim RdvMedecins-Server (Formular "Create an account").
// WARNUNG: Diese Validierung ist nur ein KOMFORT für den Benutzer (eine
// sofortige Antwort, ohne Roundtrip zum Server). Sie schützt
// nichts: Jeder kann dem Server eine von Hand erstellte Anfrage senden
// (curl ...). Der Server validiert daher IMMER alles erneut (vgl. Beispiel 25).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex07
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
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.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
enum class Field { TITLE, FIRSTNAME, LASTNAME, LOGIN, PASSWORD, CONFIRMATION }
// das Konto, wie eingegeben
data class Account(
val title: String,
val firstName: String,
val lastName: String,
val login: String,
val password: String,
val confirmation: String,
)
val titles = listOf("Mr", "Mme", "Melle")
val loginFormat = Regex("^[a-z0-9._-]{1,30}$")
const val PASSWORD_MIN = 6
// die Regeln: eine reine Funktion, die nur von ihrem Argument abhängt. Sie
// gibt für jedes fehlerhafte Feld seine Meldung zurück. buildMap: wir füllen
// eine veränderliche Map, die Funktion gibt eine UNVERÄNDERLICHE Map zurück
fun validate(a: Account): Map<Field, String> = buildMap {
if (a.title !in titles) put(Field.TITLE, "Choose a title from the list.")
when {
a.firstName.isBlank() -> put(Field.FIRSTNAME, "The first name is required.")
a.firstName.length > 20 -> put(Field.FIRSTNAME, "The first name must not exceed 20 characters.")
}
when {
a.lastName.isBlank() -> put(Field.LASTNAME, "The last name is required.")
a.lastName.length > 20 -> put(Field.LASTNAME, "The last name must not exceed 20 characters.")
}
when {
a.login.isEmpty() -> put(Field.LOGIN, "The login is required.")
!loginFormat.matches(a.login) -> put(Field.LOGIN, "Unaccented lower-case letters, digits, dot, hyphen, underscore.")
}
when {
a.password.isEmpty() -> put(Field.PASSWORD, "The password is required.")
a.password.length < PASSWORD_MIN -> put(Field.PASSWORD, "At least $PASSWORD_MIN characters.")
}
// eine Regel, die ZWEI Felder vergleicht
if (a.confirmation != a.password) put(Field.CONFIRMATION, "The confirmation does not match the password.")
}
class Ex07Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { AccountPage() } }
}
}
@Composable
fun AccountPage() {
var account by remember { mutableStateOf(Account("Mr", "", "", "", "", "")) }
var touched by remember { mutableStateOf(setOf<Field>()) }
var submitAttempted by remember { mutableStateOf(false) }
var success by remember { mutableStateOf(false) }
// die Fehler: bei jeder Ausführung neu berechnet, nie im Zustand gespeichert
val errors = validate(account)
// der Fehler, der für ein Feld ANGEZEIGT wird: nur wenn es berührt wurde
fun error(f: Field): String? = if (f in touched) errors[f] else null
fun send() {
submitAttempted = true
touched = Field.entries.toSet() // alle Fehler erscheinen
// hier, das Konto würde an den Server gesendet (vgl. Beispiel 25)
success = errors.isEmpty()
}
// ein Textfeld: Label, Fehler und ein grünes Häkchen, wenn es
// berührt und gültig ist. value: der Wert des Feldes; update: die Funktion, die
// das geänderte Konto aufbaut
@Composable
fun AccountField(f: Field, label: String, value: String, update: (String) -> Account, secret: Boolean = false) {
var hadFocus by remember { mutableStateOf(false) }
val message = error(f)
OutlinedTextField(
value = value,
onValueChange = { text ->
account = update(text)
success = false
},
label = { Text(label) },
singleLine = true,
isError = message != null,
supportingText = message?.let { m -> { Text(m) } },
// die Zeichen eines Passworts werden verborgen
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
trailingIcon = if (f in touched && message == null) {
{ Icon(Icons.Default.CheckCircle, contentDescription = null, tint = Color(0xFF2E7D32)) }
} else {
null
},
// das verlassene Feld (nachdem es den Fokus hatte) wird "touched"
modifier = Modifier.fillMaxWidth().onFocusChanged { fs ->
if (fs.isFocused) hadFocus = true else if (hadFocus) touched = touched + f
},
)
}
ExamplePage("Example 07 - validation") {
DropdownList(
label = "Title",
value = account.title,
choices = titles,
onChange = { t -> account = account.copy(title = t) },
modifier = Modifier.width(200.dp),
)
AccountField(Field.FIRSTNAME, "First name", account.firstName, { account.copy(firstName = it) })
AccountField(Field.LASTNAME, "Last name", account.lastName, { account.copy(lastName = it) })
AccountField(Field.LOGIN, "Login", account.login, { account.copy(login = it) })
AccountField(Field.PASSWORD, "Password", account.password, { account.copy(password = it) }, secret = true)
AccountField(Field.CONFIRMATION, "Confirmation", account.confirmation, { account.copy(confirmation = it) }, secret = true)
Spacer(Modifier.height(16.dp))
Button(onClick = { send() }) { Text("Create the account") }
Spacer(Modifier.height(12.dp))
if (submitAttempted && errors.isNotEmpty()) {
Message("The form contains ${errors.size} error(s).", Color(0xFFFFEBEE))
}
if (success) {
Message("Valid form: it could be sent to the server.", Color(0xFFE8F5E9))
}
}
}
// eine kleine, für diese Datei private Komponente: eine Meldung auf farbigem Hintergrund
@Composable
private fun Message(text: String, color: Color) {
Text(text, Modifier.fillMaxWidth().background(color, RoundedCornerShape(8.dp)).padding(12.dp))
}
|
- Zeilen 69–70: ein regulärer Ausdruck ([Regex]) und eine Konstante;
- Zeilen 75–94: die Regeln. [buildMap [ ... ]]: Eine veränderliche [Map] wird (über [put]) befüllt; die Funktion gibt eine UNVERÄNDERLICHE [Map] zurück. Die letzte Regel vergleicht ZWEI Felder;
- Zeile 113: Die Fehler werden bei jeder Ausführung NEU BERECHNET und nie aus dem Zustand gelöscht: Sie sind immer aktuell;
- Zeile 116: der für ein Feld ANZUZEIGENDE Fehler: nur wenn es verändert wurde;
- Zeilen 118–122: Das Absenden markiert alle Felder als berührt (alle Fehler werden angezeigt) und gelingt nur, wenn es keine Fehler gibt;
- Zeilen 129–151: ein Feld des Kontos. [update] ist eine Funktion, die das geänderte Konto erzeugt ([[ account.copy(firstName = it) ]]); [isError] und [supportingText] zeigen den Fehler unter dem Feld an; [PasswordVisualTransformation] maskiert die Zeichen; ein grünes Häkchen ([trailingIcon]) für ein Feld, das geändert wurde und gültig ist;
- Zeile 183: [private]: eine Komponente, die nur in dieser Datei sichtbar ist.


ACHTUNG: Diese Validierung ist lediglich eine ANNEHMLICHKEIT für den Benutzer (eine sofortige Rückmeldung, ohne Hin und Zurück zum Server). Sie schützt nichts: Jeder kann eine von Hand erstellte Anfrage an den Server senden (mit [curl]; siehe das Kapitel über den Server). Der Server validiert deshalb IMMER alles erneut (siehe Beispiel 25).
3.8. Beispiel 08: Felder, die sich selbst validieren können
[Flutter] hat eigene Formulare ([Form], [FormField]); [Compose] nicht. Wir schreiben das Werkzeug daher selbst, in wenigen Zeilen, mit gewöhnlichen Klassen, die einen von [Compose] beobachteten Zustand HALTEN („State Holder“): Das ist der übliche Ansatz bei [Compose].
| // =========================================================================
// ex08/Form.kt - Felder, die sich selbst validieren können
// -------------------------------------------------------------------------
// Compose bietet kein Formular-Werkzeug (kein Äquivalent zu Form
// von Flutter oder zu den Formularen von Angular): Wir schreiben es selbst, in
// wenigen Zeilen, mit gewöhnlichen Klassen, die einen von Compose
// beobachteten Zustand HALTEN ("State Holder"):
// - eine REGEL ist eine Funktion: (value) -> null, wenn der Wert in Ordnung ist,
// andernfalls die Fehlermeldung;
// - ein FormField hält seinen Wert und seinen Fehler und validiert sich selbst:
// zuerst auf Anforderung (validate()), dann bei jedem Tastendruck, sobald
// der Benutzer es geändert hat;
// - ein Form gruppiert Felder: validate() validiert sie ALLE,
// zeigt ihre Fehler an und gibt true zurück, wenn alles in Ordnung ist.
// =========================================================================
package fr.stahe.examples.ex08
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
// typealias: ein aussagekräftigerer Name für einen Funktionstyp
typealias Rule = (String) -> String?
// Regel-FABRIKEN: Jede gibt eine Validierungsfunktion zurück
fun required(message: String): Rule = { v -> if (v.isBlank()) message else null }
// eine Regel, die eine andere ERGÄNZT: "?:" (der Elvis-Operator) liefert das
// Ergebnis von other, wenn es nicht null ist, andernfalls das von rest
fun maximum(max: Int, other: Rule): Rule = { v -> other(v) ?: if (v.length > max) "$max characters at most." else null }
class FormField(initialValue: String = "", private val rule: Rule = { null }) {
// der Zustand des Feldes: von Compose beobachtet, nur HIER änderbar (private set)
var value by mutableStateOf(initialValue)
private set
var error by mutableStateOf<String?>(null)
private set
// hat der Benutzer das Feld bereits geändert?
private var modified = false
// ein Tastendruck: Das Feld validiert sich selbst, sobald der Benutzer es geändert hat
fun change(newValue: String) {
value = newValue
modified = true
error = rule(value)
}
fun validate(): Boolean {
error = rule(value)
return error == null
}
// erneut validieren, nur wenn der Benutzer das Feld bereits geändert hat
fun revalidate() {
if (modified) validate()
}
}
// vararg: beliebig viele Felder, Form(firstName, lastName, login ...)
class Form(private vararg val fields: FormField) {
// map zuerst (ALLE Felder werden validiert und zeigen ihren Fehler an),
// all danach (sind alle in Ordnung?)
fun validate(): Boolean = fields.map { it.validate() }.all { it }
}
|
- Zeile 23: [typealias]: ein Name für einen Funktionstyp: Eine REGEL erhält den Wert und gibt [null] zurück, wenn er gültig ist, andernfalls eine Fehlermeldung;
- Zeilen 26–30: FABRIKEN für Regeln (Funktionen, die eine Funktion zurückgeben). [?:], der „Elvis“-Operator: der Wert links, wenn er nicht [null] ist; andernfalls der Wert rechts;
- Zeilen 32–56: ein Feld: Sein Wert und sein Fehler sind Zustände von [Compose] ([mutableStateOf]), die nur innerhalb der Klasse geändert werden können ([private set]). Ein Feld wird bei Bedarf validiert ([validate()]), danach bei jedem Tastenanschlag, sobald der Benutzer es geändert hat;
- Zeilen 61–64: Ein Formular fasst Felder zusammen ([vararg]: beliebig viele Parameter). Zuerst [map]: ALLE Felder werden validiert und zeigen eventuelle Fehler an; dann [all]: Sind alle gültig?
Beispiel 07, mit diesen Klassen neu geschrieben:
| // =========================================================================
// ex08/Ex08Activity.kt - ein wiederverwendbares Formular
// -------------------------------------------------------------------------
// Das Formular aus Beispiel 07, geschrieben mit den Klassen aus Form.kt:
// Die Regeln sind den Feldern zugeordnet, der Bildschirm muss nur noch jedes Feld
// anzeigen und beim Absenden form.validate() aufrufen.
// Die Felder werden in einer Klasse gespeichert, AccountForm, die EINMAL erzeugt wird
// (remember): Sie übersteht die Rekompositionen.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex08
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
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.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
val titles = listOf("Mr", "Mme", "Melle")
// die Felder des Formulars und ihre Regeln
class AccountForm {
var title by mutableStateOf("Mr")
val firstName = FormField(rule = maximum(20, required("The first name is required.")))
val lastName = FormField(rule = maximum(20, required("The last name is required.")))
// eine direkt geschriebene Regel: ein Lambda
val login = FormField(
rule = { v ->
when {
v.isEmpty() -> "The login is required."
!Regex("^[a-z0-9._-]{1,30}$").matches(v) -> "Unaccented lower-case letters, digits, dot, hyphen, underscore."
else -> null
}
},
)
val password = FormField(
rule = { v ->
when {
v.isEmpty() -> "The password is required."
v.length < 6 -> "At least 6 characters."
else -> null
}
},
)
// eine Regel, die ein ANDERES Feld liest
val confirmation = FormField(
rule = { v -> if (v == password.value) null else "The confirmation does not match the password." },
)
val form = Form(firstName, lastName, login, password, confirmation)
// die Werte als JSON (was an den Server gesendet würde)
fun toJson(): String = JsonObject(
mapOf(
"title" to JsonPrimitive(title),
"firstName" to JsonPrimitive(firstName.value.trim()),
"lastName" to JsonPrimitive(lastName.value.trim()),
"login" to JsonPrimitive(login.value),
"password" to JsonPrimitive(password.value),
),
).toString()
}
class Ex08Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { AccountPage() } }
}
}
@Composable
fun AccountPage() {
val account = remember { AccountForm() }
// null: noch kein Absenden; "": Absenden abgelehnt; andernfalls das gesendete JSON
var sent by remember { mutableStateOf<String?>(null) }
ExamplePage("Example 08 - a reusable form") {
DropdownList(
label = "Title",
value = account.title,
choices = titles,
onChange = { account.title = it },
modifier = Modifier.width(200.dp),
)
TextField(account.firstName, "First name")
TextField(account.lastName, "Last name")
TextField(account.login, "Login")
// das Passwort ändert sich: Die Bestätigung wird erneut validiert (wenn sie bereits eingegeben wurde)
TextField(account.password, "Password", secret = true, after = { account.confirmation.revalidate() })
TextField(account.confirmation, "Confirmation", secret = true)
Spacer(Modifier.height(16.dp))
Button(onClick = { sent = if (account.form.validate()) account.toJson() else "" }) {
Text("Create the account")
}
Spacer(Modifier.height(12.dp))
// ?.let: Dieser Block existiert nur, wenn sent nicht null ist
sent?.let { s ->
Text(
if (s.isEmpty()) "Invalid form." else "Valid form: $s",
Modifier
.fillMaxWidth()
.background(if (s.isEmpty()) Color(0xFFFFEBEE) else Color(0xFFE8F5E9), RoundedCornerShape(8.dp))
.padding(12.dp),
)
}
}
}
// die Anzeige eines FormField: sein Wert, sein Fehler. after: was nach jedem
// Tastendruck zu tun ist (standardmäßig nichts)
@Composable
fun TextField(field: FormField, label: String, secret: Boolean = false, after: () -> Unit = {}) {
OutlinedTextField(
value = field.value,
onValueChange = {
field.change(it)
after()
},
label = { Text(label) },
singleLine = true,
isError = field.error != null,
supportingText = field.error?.let { m -> { Text(m) } },
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
modifier = Modifier.fillMaxWidth(),
)
}
|
- Zeilen 48–77: die Formularfelder und ihre Regeln, in einer Klasse zusammengefasst; die Bestätigung hat eine Regel, die ein ANDERES Feld liest ([password.value]);
- Zeile 101: [remember [ AccountForm() ]]: Das Objekt wird EINMAL erzeugt und überlebt Recompositions;
- Zeile 120: das Absenden: [account.form.validate()] validiert alles und bestimmt, ob das Absenden möglich ist;
- Zeilen 140–152: die Anzeige eines Feldes: sein Wert, sein Fehler und [after], das festlegt, was nach jedem Tastenanschlag geschehen soll: Wenn sich das Passwort ändert, wird die Bestätigung erneut validiert.


In einer [@Composable]-Funktion werden Werte mit Standardfunktionen formatiert. Die in der Anwendung verwendeten Funktionen sind in einer einzigen Datei zusammengefasst:
| // =========================================================================
// ex09/Formatting.kt - "selbstgebaute" Formatierungsfunktionen
// -------------------------------------------------------------------------
// Compose hat keinen eigenen Mechanismus zur Formatierung (Angular hat seine
// "Pipes"): In einer @Composable-Funktion rufen wir gewöhnliche
// FUNKTIONEN auf, die in einer Datei stehen und separat testbar sind:
// timeRange(slot) -> "8:00 - 8:20"
// timeRange(slot, Part.START) -> "8:00"
// Kotlin erlaubt es außerdem, einem bestehenden Typ Funktionen und Eigenschaften HINZUZUFÜGEN,
// über ERWEITERUNGEN (Extensions): "marie pelissier".capitalized ->
// "Marie Pelissier".
// Für Datumsangaben, Zahlen, Beträge kennen die Java-Klassen
// (java.time, java.text) die Konventionen jeder Sprache
// (vgl. Ex09Activity.kt).
// =========================================================================
package fr.stahe.examples.ex09
// ein Zeitfenster, wie von der RdvMedecins-API beschrieben
data class Slot(val startHour: Int, val startMinute: Int, val endHour: Int, val endMinute: Int)
enum class Part { ALL, START, END }
// "8:05" statt "8:5"; private: außerhalb dieser Datei unsichtbar
private fun time(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"
// ein OPTIONALER Parameter mit seinem Standardwert: part = Part.ALL
fun timeRange(s: Slot, part: Part = Part.ALL): String = when (part) {
Part.START -> time(s.startHour, s.startMinute)
Part.END -> time(s.endHour, s.endMinute)
Part.ALL -> "${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}"
}
// ERWEITERUNGEN des Typs String: neue Eigenschaften für ALLE
// Strings. Im Rumpf bezeichnet this den String
// "marie pelissier" -> "Marie Pelissier"; \p{L}: ein Buchstabe, mit oder ohne Akzent
val String.capitalized: String
get() = Regex("\\p{L}+").replace(this) { m ->
m.value.lowercase().replaceFirstChar { it.uppercase() }
}
// "Marie PELISSIER" -> "MP"
val String.initials: String
get() = split(Regex("\\s+")).filter { it.isNotEmpty() }.joinToString("") { it.first().uppercase() }
|
- Zeilen 24–30: ein OPTIONALER Parameter mit seinem Standardwert ([part = Part.ALL]); [padStart(2, '0')]: „8:05“ statt „8:5“;
- Zeilen 36–43: ERWEITERUNGEN: [Kotlin] erlaubt es, einem bestehenden Typ Eigenschaften (und Funktionen) zuzuweisen – hier allen Zeichenketten. Im Rumpf bezeichnet [this] die Zeichenkette: ["marie pelissier".capitalized] ergibt „Marie Pelissier“.
Für Datumsangaben, Zahlen und Beträge folgen die Klassen von [Java] ([java.time], [java.text]) den Konventionen der jeweiligen Sprache:
| // =========================================================================
// ex09/Ex09Activity.kt - Werte formatieren
// -------------------------------------------------------------------------
// Jede Zeile der Tabelle zeigt ein Stück Code und das, was er anzeigt.
// Die Formatierer (DateTimeFormatter, NumberFormat) werden ein für alle
// Mal außerhalb der @Composable-Funktionen erzeugt: Sie zu bauen kostet mehr,
// als sie zu verwenden.
// Java kennt von Haus aus die Namen der Tage und Monate jeder Sprache:
// Es muss nichts geladen werden, bevor man sie verwendet.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex09
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.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
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.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.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
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 kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import java.text.NumberFormat
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle
import java.util.Locale
// Datumsangaben: "vorgefertigte" Formate (SHORT, MEDIUM, LONG, FULL) oder ein Muster
val shortDate: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale.US)
val fullDate: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(Locale.US)
val timeOnly: DateTimeFormatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM).withLocale(Locale.US)
val frenchDay: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).withLocale(Locale.FRANCE)
val pattern: DateTimeFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy HH:mm", Locale.US)
// Zahlen und Beträge
val euros: NumberFormat = NumberFormat.getCurrencyInstance(Locale.US).apply { currency = java.util.Currency.getInstance("EUR") }
val integer: NumberFormat = NumberFormat.getNumberInstance(Locale.US)
// apply: konfiguriert das gerade erzeugte Objekt und gibt es zurück
val percent: NumberFormat = NumberFormat.getPercentInstance(Locale.US).apply { minimumFractionDigits = 1 }
const val DAY = "2026-10-05" // ein Datum im Format der RdvMedecins-API
const val PRICE = 1234.5
const val RATE = 0.055
const val NAME = "marie pelissier"
val doctor = mapOf("title" to "Mme", "firstName" to "Marie", "lastName" to "PELISSIER")
val languages = listOf("Kotlin", "Compose", "Dart", "Swift", "SQL")
val slots = listOf(Slot(8, 0, 8, 20), Slot(8, 20, 8, 40), Slot(14, 5, 14, 25))
class Ex09Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { FormattingPage() } }
}
}
@Composable
fun FormattingPage() {
var now by remember { mutableStateOf(LocalDateTime.now()) }
// (angezeigter Code, Wert): eine Zeile der Tabelle, als Paar
val rows = listOf(
"shortDate.format(now)" to shortDate.format(now),
"fullDate.format(now)" to fullDate.format(now),
"timeOnly.format(now)" to timeOnly.format(now),
"pattern.format(now)" to pattern.format(now),
"fullDate.format(LocalDate.parse(DAY))" to fullDate.format(LocalDate.parse(DAY)),
"frenchDay.format(LocalDate.parse(DAY))" to frenchDay.format(LocalDate.parse(DAY)),
"now.toString()" to now.toString(),
"euros.format(PRICE)" to euros.format(PRICE),
"integer.format(PRICE)" to integer.format(PRICE),
"\"%.1f\".format(Locale.ROOT, PRICE)" to "%.1f".format(Locale.ROOT, PRICE),
"percent.format(RATE)" to percent.format(RATE),
"NAME.uppercase()" to NAME.uppercase(),
"NAME.capitalized" to NAME.capitalized,
"\"RDV\".lowercase()" to "RDV".lowercase(),
"languages.take(3).joinToString(\", \")" to languages.take(3).joinToString(", "),
"JsonObject(...).toString()" to JsonObject(doctor.mapValues { JsonPrimitive(it.value) }).toString(),
// zwei Transformationen hintereinander: Das Ergebnis der ersten geht an die zweite
"NAME.capitalized.initials" to NAME.capitalized.initials,
)
ExamplePage("Example 09 - formatting") {
// eine Tabelle: Die erste Spalte nimmt 55 % der Breite ein (weight)
Row(Modifier.padding(4.dp)) {
Text("In the code", Modifier.weight(0.55f), fontWeight = FontWeight.Bold)
Text("Displayed", Modifier.weight(0.45f), fontWeight = FontWeight.Bold)
}
// ein Paar kann "destrukturiert" werden: (code, value)
for ((code, value) in rows) {
HorizontalDivider()
Row(Modifier.padding(4.dp)) {
Text(code, Modifier.weight(0.55f), fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = Color(0xFFC7254E))
Text(value, Modifier.weight(0.45f))
}
}
Spacer(Modifier.height(16.dp))
Text("Going through the entries of a Map", style = MaterialTheme.typography.titleSmall)
for ((key, value) in doctor) {
Text("$key = $value")
}
Spacer(Modifier.height(16.dp))
Text("A home-made function: timeRange", style = MaterialTheme.typography.titleSmall)
for (s in slots) {
Text("${timeRange(s)} (start: ${timeRange(s, Part.START)})")
}
Spacer(Modifier.height(16.dp))
OutlinedButton(onClick = { now = LocalDateTime.now() }) { Text("Refresh the time") }
}
}
|
- Zeilen 51–62: die Formatierer, ein für alle Mal außerhalb der [@Composable]-Funktionen erzeugt (ihre Erzeugung kostet mehr als ihre Verwendung). [FormatStyle.MEDIUM], [FULL] ...: „vorgefertigte“ Formate; [ofPattern]: ein Muster; [apply [ ... ]] konfiguriert das gerade erzeugte Objekt und gibt es zurück;
- Zeilen 85–103: Jede Zeile der Tabelle ist ein Paar (angezeigter Code, Wert), erzeugt mit [to];
- Zeile 113: Ein Paar, wie ein Eintrag einer [Map], wird „entpackt“: [for ((code, value) in rows)].


Beachten Sie ["%.1f".format(Locale.ROOT, PRICE)]: Ohne die „neutrale“ Sprache [Locale.ROOT] würde [format] die Sprache des Smartphones verwenden und auf Französisch „1234,5“ schreiben. Das ist für die Anzeige richtig, nicht aber für Daten, die an einen Server gesendet werden.