4. Kapitel 3 - Einführung in Android und Jetpack Compose
4.1. Quellen
Offizielle Dokumentation: https://developer.android.com – insbesondere die Seiten „Jetpack Compose“ (https://developer.android.com/compose), „Thinking in Compose“, „State and Jetpack Compose“, „Introduction to Activities“ und „ViewModel Overview“. Kotlin-Coroutinen: https://kotlinlang.org/docs/coroutines-overview.html
4.2. Was ist eine Android-App?
Eine Android-App ist eine .apk-Datei (oder .aab für den Play Store), die den kompilierten Code, Ressourcen (Symbole, Texte, Bilder) und ein Manifest ([AndroidManifest.xml]) enthält – ihren „Personalausweis“ für das System: ihre Kennung, die angeforderten Berechtigungen (Netzwerkzugriff usw.) und die Liste ihrer Bildschirme.
Diese Bildschirme heißen „Activities“ ([Activity]). Eine Activity wird nicht vom Programm selbst erzeugt: Das SYSTEM erzeugt sie, wenn der Benutzer auf das App-Symbol tippt, und ruft dann während ihres gesamten Lebenszyklus ihre Methoden auf: [onCreate(...)] bei der Erzeugung, [onPause()] wenn sie in den Hintergrund wechselt, [onDestroy()] bei der Zerstörung ... Daher gibt es in einer Android-App keine Funktion [main()] – dies ist der erste Unterschied zu [void main()] im Flutter-Client. Dieser Lebenszyklus hat eine wichtige Konsequenz, die weiter unten erläutert wird: Eine Bildschirmrotation ZERSTÖRT die Activity und ERZEUGT sie anschließend NEU.
Der Kotlin-Code wird in Java-Bytecode kompiliert, dann in das DEX-Format umgewandelt und von der virtuellen Android-Maschine ausgeführt, [ART] (Android Runtime), die ihn bei der Installation und zur Laufzeit wiederum in Maschinencode kompiliert. Es gibt weder eine JavaScript- noch eine [WebView]-Engine: Es ist eine NATIVE App, genau wie die auf dem Smartphone vorinstallierten Apps. Wie Flutter zeichnet Jetpack Compose seine eigenen Komponenten (Schaltflächen, Eingabefelder usw.), anstatt die klassischen Android-UI-Komponenten (die [View]) zu verwenden – nutzt dafür aber die eigenen UI-Bibliotheken von Android statt einer in die App eingebetteten Rendering-Engine wie Flutter.
Anders als Flutter zielt dieser Client NUR auf Android: Derselbe Code erzeugt keine iOS-, Desktop- oder Web-App. Kapitel 5 erklärt, was dafür nötig wäre (Kotlin Multiplatform und Compose Multiplatform).
4.3. Das Entwicklungsmodell von Compose: Alles ist eine Funktion
Mit Jetpack Compose wird eine Oberfläche durch Kotlin-Funktionen beschrieben, die mit @Composable annotiert sind. Eine @Composable-Funktion gibt nichts zurück: Sie ERZEUGT die Oberfläche, indem sie andere @Composable-Funktionen aufruft – [Text(...)], [Button(...)], [Column(...)] ... Die vollständige Oberfläche ist der Baum dieser verschachtelten Aufrufe.
Dies ist dasselbe deklarative Modell wie bei Flutter („Die Oberfläche ist eine Funktion des Zustands“), mit einem formalen Unterschied: Während Flutter jedes Element durch eine KLASSE (ein [Widget]) beschreibt, deren Methode [build(...)] einen Objektbaum zurückgibt, verwendet Compose ausschließlich Funktionen. Das Compose-Compiler-Plugin wandelt diese Funktionen so um, dass sie gezielt erneut ausgeführt werden können, wenn sich der Zustand ändert, den sie lesen: Dies nennt man „Recomposition“.
Einstellungen zu Aussehen und Layout (Ränder, Größe, Ausrichtung, Hintergrundfarbe, Klicks usw.) sind keine Elemente des Baums wie die Flutter-Widgets [Padding] oder [Center], sondern „Modifier“, die verkettet und als Parameter übergeben werden: [Modifier.padding(16.dp).fillMaxWidth()]. Die Einheit [dp] (dichteunabhängiges Pixel) entspricht den logischen Pixeln von Flutter: 1 dp entspricht einem Pixel auf einem Bildschirm mit einer Auflösung von 160 Punkten pro Zoll, unabhängig von der tatsächlichen Dichte des Bildschirms.
4.4. Zustand und Recomposition: weder StatefulWidget noch setState
Flutter unterscheidet bereits bei der Deklaration der Klasse ein [StatelessWidget] von einem [StatefulWidget] mit der zugehörigen Klasse [State] und verlangt den Aufruf von [setState(() { ... })] , damit eine Zustandsänderung angezeigt wird. Compose macht nichts davon:
- Eine lokale Variable wird in der Funktion selbst deklariert: [var clicks by remember { mutableStateOf(0) }];
- [mutableStateOf(...)] erzeugt einen BEOBACHTBAREN ZUSTAND: Compose registriert automatisch jede @Composable-Funktion, die ihn LIEST, und führt diese Funktionen – und nur diese – erneut aus („komponiert sie neu“), wenn sich der Wert ändert. Nach einer Änderung ist nichts aufzurufen: [clicks++] genügt. So funktioniert [ref(...)]/[reactive(...)] auf der Seite von Vue.js, nicht aber [setState(...)];
- [remember { ... }] speichert einen Wert von einer Ausführung der Funktion zur nächsten. Ohne diese Funktion würde der Zustand bei jedem Aufruf neu erzeugt – und auf null zurückgesetzt;
- [rememberSaveable { ... }] tut dasselbe und bewahrt den Wert ZUSÄTZLICH, wenn die Activity zerstört und anschließend neu erzeugt wird (Bildschirmrotation; siehe unten);
- Das Schlüsselwort [by] (Property-Delegation; siehe den Kotlin-Kurs) ermöglicht es, [clicks] statt [clicks.value] zu schreiben.
Derselbe Mechanismus gilt für einen gemeinsam genutzten Zustand: Eine gewöhnliche Klasse, deren Eigenschaften als [by mutableStateOf(...)] deklariert sind, wird automatisch von allen Funktionen beobachtet, die diese Eigenschaften lesen. So werden die Services des Clients geschrieben ([SettingsService], [AuthService], [TranslationsService]; siehe Kapitel 4): Während die Flutter-Version [ChangeNotifier] erweiterte und nach jeder Änderung manuell [notifyListeners()] aufrief, ist hier nichts zu melden.
4.5. Zustand teilen: CompositionLocal, das Äquivalent zu provider
Damit ein Service für einen ganzen Baum von @Composable-Funktionen verfügbar ist, ohne ihn von Aufruf zu Aufruf als Parameter weiterzureichen, bietet Compose [CompositionLocal]: Man deklariert einen „Schlüssel“ ([val LocalAuth = staticCompositionLocalOf<AuthService> { ... }]), weist ihm an der Spitze des Baums einen Wert zu ([CompositionLocalProvider(LocalAuth provides auth) { ... }]), und jede untergeordnete Funktion kann ihn mit [LocalAuth.current] LESEN. Genau das ist die Rolle des Pakets [provider] in der Flutter-Version ([MultiProvider] / [context.read<...>()]), von [provide]/[inject] auf der Seite von Vue.js oder eines React-[Context]. Compose benötigt kein Äquivalent zu [context.watch<...>()]: Das Abonnieren von Änderungen übernehmen die beobachtbaren Zustände selbst.
4.6. Keine Template-Sprache: Bedingungen und Listen
Wie in Flutter werden bedingte Darstellung und Listen mit Standardkonstrukten der Sprache geschrieben: einem Kotlin-Ausdruck [if] für eine Bedingung, einer Schleife [forEach] für eine Liste. Da eine @Composable-Funktion wie jede andere Funktion ist, [if (auth.isLoggedIn) { ... }] ERZEUGT ihren Inhalt oder eben nicht – es gibt kein Äquivalent zum Aufbau von Widget-Listen ([children: [...]]) oder zur „Collection-if“-Syntax von Dart.
4.7. Coroutinen: async/await im Stil von Kotlin
Eine Android-App hat nur einen Thread, der für das Zeichnen der Oberfläche und die Reaktion auf den Benutzer zuständig ist: den Main-Thread. Er darf NIEMALS warten; Android verbietet sogar jeden Netzwerkzugriff von diesem Thread aus (Ausnahme [NetworkOnMainThreadException]). Serveraufrufe müssen daher „im Hintergrund“ erfolgen. Kotlin stellt hierfür Coroutinen bereit:
- Eine [suspend]-Funktion kann pausieren, ohne den Thread zu blockieren, der sie ausführt – das Äquivalent einer Dart-Funktion mit [async] oder einer TypeScript-Funktion. Der Aufruf einer [suspend]-Funktion bedeutet, auf sie zu warten: Es gibt kein Schlüsselwort [await]; das Warten erfolgt implizit;
- [withContext(Dispatchers.IO) { ... }] führt einen Block auf einem für I/O reservierten Thread aus und kehrt dann mit dem Ergebnis zum ursprünglichen Thread zurück. So lässt sich eine „blockierende“ Netzwerkbibliothek ([OkHttp]) verwenden, ohne jemals die Oberfläche zu blockieren;
- Eine Coroutine wird mit [launch { ... }] IN einem Scope ([CoroutineScope]) gestartet, der an einen Lebenszyklus gebunden ist: [viewModelScope] (die Coroutinen eines ViewModels, die bei dessen Zerstörung abgebrochen werden) oder [rememberCoroutineScope()] (die einer @Composable-Funktion, die abgebrochen werden, wenn sie vom Bildschirm verschwindet). Es besteht nicht mehr die Gefahr wie in Flutter, den Zustand eines bereits zerstörten Bildschirms zu ändern (der Test [if (mounted)]): Die Coroutine wird zusammen mit ihm abgebrochen.
4.8. Der Lebenszyklus: Bildschirmrotation und ViewModel
Wenn der Benutzer sein Smartphone dreht (oder die Systemsprache ändert oder in den Dunkelmodus wechselt), ZERSTÖRT Android standardmäßig die Activity und erzeugt eine neue, die an die neue Konfiguration angepasst ist. Alles, was in der alten Activity gespeichert war – und in den Zuständen ihrer @Composable-Funktionen –, geht verloren. Flutter hat dieses Problem nicht: Das Drehen des Bildschirms ändert nur dessen Größe.
Android bietet zwei Lösungen, die beide vom Client genutzt werden:
- [rememberSaveable { ... }] für kleine UI-Zustände (gerade eingegebener Text, ausgewählter Arzt usw.): Android sichert sie vor der Zerstörung und stellt sie in der neuen Activity wieder her;
- ein [ViewModel] für den Zustand und die Logik eines Bildschirms (vom Server geladene Listen, angezeigter Kalender usw.): Dies ist ein Objekt, das Android über die Neuerzeugung von Activities hinweg BEHÄLT und an die neue weitergibt. Es wird erst zerstört, wenn der Bildschirm endgültig verlassen wird. Der Client in diesem Dokument legt den gesamten Zustand, den die Flutter-Version in der Klasse [_AppRootState] hielt, in einem ViewModel ab ([AppViewModel]).
Objekte, die so lange leben müssen wie die Anwendung (Services), werden nicht in der Activity oder in einem ViewModel erzeugt, sondern in der Klasse [Application] der Anwendung, die beim Start des Prozesses nur ein einziges Mal erzeugt wird.
4.9. Ein einfaches erstes Beispiel
Hier ist eine kleine Compose-Anwendung: etwas Text, eine Schaltfläche, die Klicks zählt, und eine Meldung, die erst nach dem dritten Klick erscheint. Um sie auszuprobieren, ersetzen Sie einfach den Inhalt der Datei [MainActivity.kt] in einem mit der Vorlage [Empty Activity] erstellten Projekt (siehe Kapitel 1) und passen dabei die Zeile [package] an.
Gehen wir diesen Code durch:
- Zeile 19: [class MainActivity : ComponentActivity()] – die Activity, der vom System gestartete Bildschirm. [ComponentActivity] ist die für Compose vorgesehene Basisklasse;
- Zeile 20: [onCreate(...)] – wird von Android aufgerufen, wenn die Activity erzeugt wird. Dies ist der Startpunkt des Codes der App und ersetzt das [main()] von Flutter;
- Zeile 22: [setContent { ... }] – ersetzt den Bildschirminhalt durch die im Block beschriebene Oberfläche: das Äquivalent zu [runApp(...)] in Flutter;
- Zeile 23: [MaterialTheme { ... }] – stellt allem, was innerhalb des Blocks aufgerufen wird, das Material-3-Theme (Farben, Typografie, Formen) bereit – die Rolle von [MaterialApp] in Flutter, abzüglich der Navigation;
- Zeilen 30–31: [@Composable fun Counter(name: String)] – eine `@Composable`-Funktion mit einem Parameter. Ihr Name beginnt per Konvention mit einem Großbuchstaben wie ein Klassenname: Sie stellt ein Element der Oberfläche dar;
- Zeile 32: [var clicks by remember { mutableIntStateOf(0) }] – ein lokaler Zustand: [mutableIntStateOf] ist die für eine Ganzzahl optimierte Variante von [mutableStateOf] ;
- Zeile 33: [Column(modifier = Modifier.padding(32.dp)) { ... }] – ordnet seine Kindelemente untereinander an, mit einem Rand von 32 dp. [Row] würde sie nebeneinander anordnen;
- Zeile 35: [Button(onClick = { clicks++ })] – der Klick-Handler ist ein einfaches Lambda. [clicks++] ändert den Zustand: Compose komponiert [Counter], der diesen Zustand LIEST, sofort neu, und der Text der Schaltfläche wird aktualisiert;
- Zeilen 38–40: ein gewöhnliches Kotlin-[if] – der Text „Well done!“ wird erst ab dem dritten Klick erzeugt und somit angezeigt.
4.10. Zusammenfassung: Zuordnung von Flutter zu Jetpack Compose
- [void main()] + [runApp(...)] → Activity ([ComponentActivity]) + [setContent { ... }]
- [StatelessWidget]/[StatefulWidget] (Klassen) → [@Composable]-Funktionen
- Felder aus [State<T>] + [setState(...)] → [remember { mutableStateOf(...) }] (automatische Recomposition)
- [ChangeNotifier] + [notifyListeners()] → Klasse mit Eigenschaften [by mutableStateOf(...)] (nichts zu melden)
- Paket [provider] ([MultiProvider], [context.read]/[watch]) → [CompositionLocal] ([CompositionLocalProvider], [LocalXxx.current])
- Konstruktorparameter von Widgets (Eingaben), als Parameter übergebene Funktionen (Ausgaben) → Parameter von @Composable-Funktionen, Lambdas
- [build(BuildContext)] → der Rumpf der @Composable-Funktion
- Widgets [Padding], [Center], [SizedBox] ... → Modifier ([Modifier.padding(...)] ...)
- [Future<T>] + [async]/[await] → [suspend]-Funktionen + Coroutinen
- Paket [http] → Bibliothek [OkHttp]
- handgeschriebene Konstruktoren [fromJson(...)] → Klassen mit [@Serializable] ([kotlinx.serialization])
- Paket [shared_preferences] → [SharedPreferences] von Android (die API, nach der das Flutter-Paket benannt ist)
- [showDialog(...)] → eine Funktion [AlertDialog(...)], die so lange angezeigt wird, wie ein Zustand es verlangt
- [LayoutBuilder] / [MediaQuery] → [BoxWithConstraints] / [LocalConfiguration]
- [pubspec.yaml] + [flutter pub get] → [build.gradle.kts] + [libs.versions.toml] + Gradle
- Kein Flutter-Äquivalent: [ViewModel] und [rememberSaveable], bedingt durch die Neuerzeugung der Activity bei der Bildschirmrotation