Skip to content

5. Kapitel 4 - Der Kotlin-Client für die Anwendung RdvMedecins

5.1. Überblick über die Architektur

Image

Dieser Client kommuniziert mit dem Server [rdvmedecins-nestjs-server] des Kurses – der völlig unverändert bleibt – über dieselben Routen: HTTP (POST [/login], GET [/getAllDoctors], GET [/getAllClients], GET [/getDoctorScheduleOfDay/:doctorId/:day], POST [/addAppointment], POST [/deleteAppointment]), mit demselben JSON-Umschlag [{ status, data }] und derselben Token-Authentifizierung [JWT] (Header [Authorization: Bearer <token>]).

5.2. Projektbaum

rdvmedecins-kotlin-client/
├── settings.gradle.kts, build.gradle.kts, gradle/      Gradle configuration
└── app/
    ├── build.gradle.kts                    Android configuration + dependencies
    └── src/main/
        ├── AndroidManifest.xml             permissions, Application class, activity
        ├── assets/i18n/                    translation dictionaries (fr.json, en.json)
        ├── res/                            app icon, name and theme
        └── java/fr/rdvmedecins/client/
            ├── RdvMedecinsApplication.kt   builds the services (once)
            ├── MainActivity.kt             the screen: provides the services, displays App
            ├── App.kt                      the root screen (conductor + guard)
            ├── AppViewModel.kt             the state and logic of the root screen
            ├── core/
            │   ├── Locals.kt               the CompositionLocals (equivalent of provider)
            │   ├── models/                 data classes (mirror of the server's JSON)
            │   ├── services/               SettingsService, AuthService, AppointmentService
            │   ├── http/                   AuthInterceptor (JWT token + logout on 401)
            │   ├── i18n/                   TranslationsService (French/English)
            │   └── ui/                     DropdownList (reusable component)
            └── features/                   one component per feature

Diese Verzeichnisstruktur spiegelt Ordner für Ordner die des Flutter-Clients wider ([lib/core/models], [lib/core/services], [lib/core/http], [lib/core/i18n], [lib/features]), die ihrerseits auf dem Vue.js-Client basiert. Zwei Ergänzungen sind spezifisch für Android: die Application-Klasse ([RdvMedecinsApplication.kt]) und das ViewModel des Bildschirms ([AppViewModel.kt]), deren Zweck in Kapitel 3 erklärt wurde; hinzu kommt ein kleiner Ordner namens [core/ui] für eine wiederverwendbare Dropdown-Liste. Kotlin-Ordnernamen werden kleingeschrieben und ohne Bindestriche geschrieben ([doctordaypicker], [bookingdialog]): Es sind Paketnamen.

5.3. Konfigurationsdateien des Projekts

5.3.1. gradle/libs.versions.toml

Der Versionskatalog: alle Bibliotheken und Gradle-Plugins des Projekts samt ihren Versionen an einer Stelle. Er entspricht dem Abschnitt [dependencies] in der Datei [pubspec.yaml] der Flutter-Version. Die Datei wurde von Android Studio generiert und anschließend ergänzt.

# =========================================================================
# 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 Pendant zu den Versionsnummern
# der pubspec.yaml der Flutter-Version oder der package.json von Node.js.
# =========================================================================

[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"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
junit = "4.13.2"
junitVersion = "1.1.5"
espressoCore = "3.5.1"

[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" }
# ––– für diesen Client ergänzt –––
# viewModel { ... } in einer @Composable-Funktion (siehe App.kt)
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# die grundlegenden Material-Icons (Abmelden, Kalender)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# der HTTP-Client
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# JSON-(De-)Serialisierung
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# für diesen Client ergänzt: erzeugt den (De-)Serialisierungscode der @Serializable-Klassen
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

Kommentieren wir diesen Code:

  • Zeile 10: [agp = "9.4.1"] – die Version des Android Gradle Plugin ([AGP]), des Gradle-Plugins, das eine Android-App erstellt. Ab Version 9 kompiliert es Kotlin-Code selbst: Es muss kein separates Kotlin-Plugin mehr deklariert werden;
  • Zeile 11: [kotlin = "2.2.10"] – die Version der beiden unten deklarierten Kotlin-Kompilierungs-Plugins (Compose und Serialisierung);
  • Zeile 15: [composeBom] – die Version des Compose-„BOM“ (Bill of Materials), das mit einem Mal kompatible Versionen für alle Compose-Bibliotheken festlegt (siehe [app/build.gradle.kts]);
  • Zeilen 38–46: die vier für diesen Client hinzugefügten Bibliotheken: [lifecycle-viewmodel-compose] (die Funktion [viewModel { ... }]), [material-icons-core] (die Symbole für Abmelden und Kalender), [OkHttp] (der HTTP-Client, Äquivalent zum Paket [http] von Flutter) und [kotlinx-serialization-json] (die Umwandlung zwischen JSON <-> Kotlin-Objekten). Die ersten beiden haben keine Version; sie wird vom Compose-BOM-Plugin bestimmt;
  • Zeile 52: das Kompilierungs-Plugin [kotlinx.serialization], das den JSON-Umwandlungscode für die mit [@Serializable] annotierten Klassen erzeugt (siehe [core/models]).

5.3.2. app/build.gradle.kts

Die Konfiguration des Moduls [app] – der Anwendung selbst – einschließlich angewendeter Plugins, Android-Einstellungen und Abhängigkeiten.

// =========================================================================
// app/build.gradle.kts - die Konfiguration des Moduls "app": die Android-Anwendung
// selbst. Von Android Studio generiert (Vorlage "Empty Activity"),
// dann für diesen Client ergänzt (mit "added" markierte Zeilen).
// =========================================================================
plugins {
    // das Android-Plugin: kompiliert den Kotlin-Code (das Android Gradle Plugin 9
    // bringt Kotlin-Unterstützung selbst mit) und erzeugt die .apk
    alias(libs.plugins.android.application)
    // der Compose-Compiler: transformiert die @Composable-Funktionen
    alias(libs.plugins.kotlin.compose)
    // ergänzt: das Plugin kotlinx.serialization (@Serializable-Klassen)
    alias(libs.plugins.kotlin.serialization)
}

android {
    // das Kotlin-"Package" des Quellcodes (Klasse R, BuildConfig...)
    namespace = "fr.rdvmedecins.client"
    // die Android-API-Version, mit der KOMPILIERT wird
    compileSdk {
        version = release(37)
    }

    defaultConfig {
        // die EINDEUTIGE Kennung der Anwendung auf einem Smartphone (und im
        // Play Store)
        applicationId = "fr.rdvmedecins.client"
        // die älteste akzeptierte Android-Version: Android 8.0 (API 26),
        // die erste, die java.time bietet (LocalDate, siehe DoctorDayPicker)
        minSdk = 26
        // die Android-Version, für die die Anwendung getestet wurde
        targetSdk = 37
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            optimization {
                enable = false
            }
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    buildFeatures {
        compose = true
    }
}

dependencies {
    // die Compose-"BOM" (Bill Of Materials): legt in einem Zug zueinander kompatible
    // Versionen für alle Compose-Bibliotheken fest, die
    // daher weiter unten OHNE Versionsnummer deklariert werden
    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 diesen Client ergänzt
    implementation(libs.androidx.lifecycle.viewmodel.compose)
    implementation(libs.androidx.compose.material.icons.core)
    implementation(libs.okhttp)
    implementation(libs.kotlinx.serialization.json)
    // Tests (von Android Studio generiert, in diesem Dokument nicht verwendet)
    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)
    debugImplementation(libs.androidx.compose.ui.test.manifest)
    debugImplementation(libs.androidx.compose.ui.tooling)
}

Kommentieren wir diesen Code:

  • Zeilen 6–13: die drei auf das Modul angewendeten Plugins: das Android-Plugin, der Compose-Compiler (der die [@Composable]-Funktionen umwandelt) und das Plugin kotlinx.serialization;
  • Zeile 18: [namespace] – das Basispaket für den Kotlin-Code;
  • Zeilen 20–21: [compileSdk] – die für die Kompilierung verwendete Version der Android-API (37 = Android 17). [targetSdk] (Zeile 32) ist die Version, für die die App getestet wurde: Android wendet das Verhalten dieser Version auf sie an;
  • Zeile 27: [applicationId] – die eindeutige Kennung der App auf einem Smartphone und im Play Store;
  • Zeile 30: [minSdk = 26] – Android 8.0 oder höher, die erste Version, die die API [java.time] ([LocalDate]) bereitstellt, die von [DoctorDayPicker] verwendet wird;
  • Zeile 51: [compose = true] – aktiviert Compose für dieses Modul;
  • Zeile 59: das Compose-BOM, als „Plattform“ deklariert: Die folgenden Compose-Bibliotheken werden ohne Version deklariert;
  • Zeilen 67–71: die vier für diesen Client hinzugefügten Abhängigkeiten (siehe [libs.versions.toml]). Die Syntax [libs.okhttp] verweist auf den Versionskatalog: Gradle generiert für jeden Eintrag des Katalogs einen Kotlin-Getter, was die automatische Vervollständigung in Android Studio ermöglicht.

5.3.3. app/src/main/AndroidManifest.xml

Das Manifest der App. Die Flutter-Version hatte keines: Der Ordner [android/], der es enthält, wurde von [flutter create] generiert und nicht näher betrachtet. Hier ist es Teil des Codes der App.

<?xml version="1.0" encoding="utf-8"?>
<!-- –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
     AndroidManifest.xml
     ............................................................................
     Der „Personalausweis“ der Anwendung für das Android-System: ihre
     Berechtigungen, ihre Application-Klasse, ihre Activities (Bildschirme).
     ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- Netzwerkzugriff: Ohne diese Berechtigung schlägt jede HTTP-Anfrage an den
         NestJS-Server fehl (für diese Berechtigung wird dem
         Benutzer kein Dialog angezeigt: Sie wird automatisch erteilt) -->
    <uses-permission android:name="android.permission.INTERNET" />

    <!-- android:name: die Application-Klasse, die die Services erstellt
         (siehe RdvMedecinsApplication.kt).
         android:usesCleartextTraffic="true": erlaubt HTTP im Klartext
         (http:// und nicht https://), seit Android 9 standardmäßig blockiert.
         Unverzichtbar mit dem NestJS-Server dieses Kurses, der über
         reines HTTP lauscht - für einen Produktionsserver über https zu entfernen
         (siehe Kapitel 5). -->
    <application
        android:name=".RdvMedecinsApplication"
        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:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.RdvMedecins"
        android:usesCleartextTraffic="true"
        tools:targetApi="31">

        <!-- der einzige Bildschirm der Anwendung. exported="true" + der
             MAIN/LAUNCHER-Filter: Es ist die Activity, die vom
             Icon der Anwendung gestartet wird. windowSoftInputMode="adjustResize": Wenn die
             Tastatur erscheint, wird der Bildschirm verkleinert (und bleibt scrollbar), statt
             von der Tastatur verdeckt zu werden. -->
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:windowSoftInputMode="adjustResize"
            android:theme="@style/Theme.RdvMedecins">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Kommentieren wir diesen Code:

  • Zeile 14: [android.permission.INTERNET] – ohne diese Berechtigung schlägt jede Verbindung zum Server fehl. Es ist eine „normale“ Berechtigung: Sie wird bei der Installation ohne Nachfrage beim Benutzer erteilt;
  • Zeile 24: [android:name=".RdvMedecinsApplication"] – die Application-Klasse der Anwendung (der führende Eintrag [.] wird durch [namespace] ersetzt);
  • Zeile 33: [android:usesCleartextTraffic="true"] – erlaubt HTTP „im Klartext“ ([http://], nicht [https://]), was ab Android 9 standardmäßig blockiert ist. Da der NestJS-Server dieses Kurses auf dem einfachen HTTP-Port lauscht, ist diese Einstellung unverzichtbar (siehe Kapitel 5);
  • Zeilen 41–50: die einzige Activity, [MainActivity]. Der Filter [MAIN]/[LAUNCHER] macht sie zur Activity, die über das App-Symbol gestartet wird; [exported="true"] erlaubt, dass sie von einer anderen App gestartet werden kann – in diesem Fall vom App-Launcher des Smartphones.
  • Zeile 44: [windowSoftInputMode="adjustResize"] – wenn die Tastatur erscheint, wird der Bildschirm an den verbleibenden Platz angepasst (und bleibt scrollbar), statt teilweise von der Tastatur verdeckt zu werden.

Der Rest des Ordners [res/] stammt aus der Vorlage von Android Studio: das App-Symbol ([mipmap-*], [drawable/]), ihr Name ([values/strings.xml]), ihr „Android“-Theme – nur während des Starts verwendet, bevor Compose den ersten Bildschirm mit seinem eigenen Theme anzeigt ([values/themes.xml]) – und die Regeln zur Datensicherung ([xml/]).

5.4. Start der App

Die Datei [lib/main.dart] der Flutter-Version erledigte zwei Dinge: die Services aufbauen und dann den ersten Bildschirm anzeigen. Unter Android sind diese beiden Aufgaben auf die Application-Klasse und die Activity aufgeteilt.

5.4.1. RdvMedecinsApplication.kt

Initialisiert die vier Services des Clients einmalig beim Start der App.

// =========================================================================
// RdvMedecinsApplication.kt
// -------------------------------------------------------------------------
// Erste Hälfte der lib/main.dart der Flutter-Version: Aufbau der Services der
// Anwendung, GENAU EINMAL.
//
// Warum eine Application-Klasse? Unter Android wird der Bildschirm (die Activity, siehe
// MainActivity) bei jeder Drehung des Smartphones, bei jedem Wechsel der
// Systemsprache usw. ZERSTÖRT und anschließend NEU ERSTELLT. In der
// Activity aufgebaute Services würden daher bei jeder Drehung neu aufgebaut. Das
// Application-Objekt hingegen wird beim Start des Prozesses erzeugt
// und lebt so lange wie dieser: Es ist der richtige Ort für Objekte, die
// während der gesamten Lebensdauer der Anwendung bestehen müssen. Es wird in
// AndroidManifest.xml deklariert (Attribut android:name des Tags <application>).
//
// Die REIHENFOLGE beim Aufbau ist wichtig, wie in der Flutter-Version:
// AuthService benötigt SettingsService (die Server-URL); der authentifizierte
// HTTP-Client benötigt AuthService (das Token); AppointmentService benötigt
// den authentifizierten HTTP-Client und SettingsService.
// =========================================================================

package fr.rdvmedecins.client

import android.app.Application
import android.content.Context
import fr.rdvmedecins.client.core.http.AuthInterceptor
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import fr.rdvmedecins.client.core.services.SettingsService
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit

class RdvMedecinsApplication : Application() {

    // lateinit: Diese Properties ohne Null-Wert werden in
    // onCreate() initialisiert und nicht im Konstruktor (siehe den Kotlin-Kurs)
    lateinit var settings: SettingsService
        private set
    lateinit var auth: AuthService
        private set
    lateinit var api: AppointmentService
        private set
    lateinit var translations: TranslationsService
        private set

    // wird von Android beim Start der Anwendung aufgerufen, vor jedem Bildschirm
    override fun onCreate() {
        super.onCreate()

        // die Einstellungen der Anwendung: eine kleine private Schlüssel-Wert-Datei,
        // die das Beenden der Anwendung überdauert - das Pendant zum
        // localStorage eines Browsers
        val prefs = getSharedPreferences("rdvmedecins", Context.MODE_PRIVATE)

        // 1. zuerst SettingsService: die anderen benötigen ihn
        settings = SettingsService(prefs)

        // 2. ein "einfacher" OkHttp-HTTP-Client, den AuthService für
        //    POST /login verwendet. Kurze Timeouts: Auf Mobilgeräten ist eine schnelle Fehlermeldung
        //    besser als endloses Warten, wenn der Server
        //    nicht erreichbar ist (falsche URL, WLAN aus...).
        val plainHttp = OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(15, TimeUnit.SECONDS)
            .build()
        auth = AuthService(settings, prefs, plainHttp)

        // 3. der authentifizierte HTTP-Client: eine KOPIE des vorherigen
        //    (newBuilder() übernimmt dessen Konfiguration und Verbindungen),
        //    plus der Interceptor, der das JWT-Token hinzufügt
        val authHttp = plainHttp.newBuilder()
            .addInterceptor(AuthInterceptor(auth))
            .build()
        api = AppointmentService(authHttp, settings)

        // 4. die Übersetzungen: keine Abhängigkeit von den anderen Services
        translations = TranslationsService(assets, prefs)
    }
}

Kommentieren wir diesen Code:

  • Zeile 34: Die Klasse erweitert [android.app.Application]. Android erzeugt davon eine einzige Instanz, wenn der Prozess der App startet – vor jeder Activity – und behält sie bis zum Ende des Prozesses;
  • Zeilen 38–44: die vier Services, deklariert als [lateinit var ... private set]: nicht null, später initialisiert (in [onCreate]) und nur von dieser Klasse änderbar;
  • Zeile 54: [getSharedPreferences(...)] – die Einstellungen der Anwendung, eine kleine private Schlüssel-Wert-Datei, die das Beenden der Anwendung überdauert: das Äquivalent zu [localStorage] im Browser und zum Flutter-Paket [shared_preferences];
  • Zeilen 63–66: ein „einfacher“ [OkHttp]-Client mit kurzen Timeouts. Ein OkHttp-Client ist darauf ausgelegt, GEMEINSAM genutzt zu werden: Er verwaltet seinen eigenen Pool wiederverwendbarer Verbindungen;
  • Zeile 67: [AuthService] erhält den einfachen Client: Die Route [/login] ist die einzige öffentliche Route des Servers und erfordert kein Token;
  • Zeilen 72–75: Der authentifizierte Client, [newBuilder()], erstellt eine Kopie davon (die die Verbindungen des ersten teilt), ergänzt um den Interceptor [AuthInterceptor], der jeder Anfrage das JWT-Token hinzufügt (siehe [core/http]). [AppointmentService] erhält ihn: Keine seiner Methoden muss sich um das Token kümmern;
  • Zeile 78: [assets] – Zugriff auf die Dateien im Ordner [assets/] der Anwendung, übergeben an [TranslationsService].

Ein bemerkenswerter Unterschied zur Flutter-Version: Vor der Anzeige des ersten Bildschirms ist keine asynchrone Initialisierung erforderlich. Die [SharedPreferences]-Objekte werden synchron gelesen (sie werden beim ersten Zugriff in den Speicher geladen): [AuthService] und [TranslationsService] lesen die gespeicherte Sitzung und die Sprache, sobald sie erzeugt werden, während [lib/main.dart] auf [await auth.init()] und [await translations.init()] warten musste.

5.4.2. MainActivity.kt

Die einzige Aktivität der Anwendung: Sie stellt allen @Composable-Funktionen die Services zur Verfügung und zeigt dann den Wurzelbildschirm an.

// =========================================================================
// MainActivity.kt
// -------------------------------------------------------------------------
// Zweite Hälfte der lib/main.dart der Flutter-Version: Anzeige des
// ersten Bildschirms.
//
// Eine Android-Anwendung besteht aus "Activities" (Activity): Eine
// Activity ist ein Bildschirm, der vom System gestartet wird. Diese hier ist in
// AndroidManifest.xml als Start-Activity (LAUNCHER) deklariert: Sie wird von
// Android gestartet, wenn der Benutzer auf das Symbol der Anwendung tippt.
//
// ComponentActivity ist die für Jetpack Compose gedachte Basis-Activity:
// setContent { ... } ersetzt das alte Android-View-System (XML-Layout-
// Dateien) durch @Composable-Funktionen - das Gegenstück zu
// runApp(...) in Flutter.
// =========================================================================

package fr.rdvmedecins.client

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.runtime.CompositionLocalProvider
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalApi
import fr.rdvmedecins.client.core.LocalSettings
import fr.rdvmedecins.client.core.LocalTranslations

class MainActivity : ComponentActivity() {

    // wird bei jeder Erstellung der Activity aufgerufen: beim Start, aber auch
    // nach jeder Bildschirmdrehung (siehe RdvMedecinsApplication)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // die Anwendung zeichnet unter der System-Statusleiste und
        // der Navigationsleiste; Scaffold (siehe App.kt) sorgt dafür,
        // dass der von diesen Leisten benötigte Platz frei bleibt
        enableEdgeToEdge()

        // die Services, einmalig von
        // RdvMedecinsApplication aufgebaut - und nicht hier, wo sie
        // bei jeder Drehung neu aufgebaut würden
        val app = application as RdvMedecinsApplication

        setContent {
            // CompositionLocalProvider: stellt die vier Services allen
            // @Composable-Funktionen zur Verfügung, die im Block aufgerufen werden - der
            // MultiProvider der Flutter-Version (siehe core/Locals.kt)
            CompositionLocalProvider(
                LocalSettings provides app.settings,
                LocalAuth provides app.auth,
                LocalApi provides app.api,
                LocalTranslations provides app.translations,
            ) {
                RdvMedecinsApp()
            }
        }
    }
}

Kommentieren wir diesen Code:

  • Zeile 34: [onCreate(...)] wird bei JEDER Erstellung der Aktivität aufgerufen – beim Start, aber auch nach jeder Bildschirmdrehung. Deshalb werden die Services von der Klasse Application erstellt und nicht hier;
  • Zeile 39: [enableEdgeToEdge()] – die Anwendung zeichnet auf dem gesamten Bildschirm, auch unter der System-Statusleiste (oben) und der Navigationsleiste (unten). [Scaffold] (siehe [App.kt]) sorgt für die nötigen Abstände, damit der Inhalt nicht von diesen Leisten verdeckt wird;
  • Zeile 44: [application as RdvMedecinsApplication] – die Eigenschaft [application] einer Aktivität liefert das Application-Objekt: Es wird in seinen tatsächlichen Typ umgewandelt, um auf die Services zuzugreifen;
  • Zeile 46: [setContent { ... }] – das Pendant zu [runApp(...)]: Die Oberfläche der Aktivität wird nun durch die @Composable-Funktionen im Block beschrieben;
  • Zeilen 50–56: [CompositionLocalProvider(LocalSettings provides app.settings, ...)] – stellt die vier Services dem gesamten Baum der im Block aufgerufenen @Composable-Funktionen zur Verfügung: das Pendant zum [MultiProvider] der Flutter-Version. [provides] ist eine „Infix“-Funktion: [a provides b] wird ohne Punkt und ohne Klammern geschrieben (siehe den Kotlin-Kurs).

5.4.3. core/Locals.kt

Die vier „Schlüssel“ für die von [MainActivity] bereitgestellten Services.

// =========================================================================
// Locals.kt
// -------------------------------------------------------------------------
// Die "CompositionLocal"s der Anwendung: der Jetpack-Compose-Mechanismus,
// um ein Objekt einem GANZEN Teilbaum von
// @Composable-Funktionen verfügbar zu machen, ohne es von Aufruf zu Aufruf als Parameter weiterzureichen.
// Er entspricht dem Paket provider der Flutter-Version
// (MultiProvider / context.read<...>()), provide/inject auf der Vue.js-Seite oder
// einem React-Context.
//
//   - MainActivity STELLT die Instanzen BEREIT:
//         CompositionLocalProvider(LocalAuth provides auth, ...) { ... }
//   - jede untergeordnete @Composable-Funktion LIEST sie:
//         val auth = LocalAuth.current
//
// staticCompositionLocalOf (statt compositionLocalOf): Diese Services
// werden während der Lebensdauer der Anwendung nie durch andere Instanzen ERSETZT,
// nur ihr INHALT ändert sich - und dieser Inhalt wird von Compose bereits
// dank des mutableStateOf jedes Services beobachtet.
// Der Block { error(...) } liefert den Standardwert: hier eine eindeutige
// Exception, falls ein Bildschirm angezeigt wird, ohne dass der Service bereitgestellt wurde.
// =========================================================================

package fr.rdvmedecins.client.core

import androidx.compose.runtime.staticCompositionLocalOf
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import fr.rdvmedecins.client.core.services.SettingsService

val LocalSettings = staticCompositionLocalOf<SettingsService> { error("SettingsService not provided") }
val LocalAuth = staticCompositionLocalOf<AuthService> { error("AuthService not provided") }
val LocalApi = staticCompositionLocalOf<AppointmentService> { error("AppointmentService not provided") }
val LocalTranslations = staticCompositionLocalOf<TranslationsService> { error("TranslationsService not provided") }

Kommentieren wir diesen Code:

  • Zeile 33: [staticCompositionLocalOf<AuthService> { ... }] – deklariert ein CompositionLocal vom Typ [AuthService]. Der Block legt den Standardwert fest, der verwendet wird, wenn kein Wert bereitgestellt wird: hier eine explizite Ausnahme ([error(...)]), die klarer ist als ein unverständlicher Fehler weiter unten;
  • [static...] statt [compositionLocalOf]: Ein „statisches“ CompositionLocal verfolgt nicht die AUSTAUSCHUNG der bereitgestellten Instanz (was aufwendiger wäre). Das genügt hier: Services werden nie durch andere Instanzen ersetzt; nur ihr Inhalt ändert sich, und dieser Inhalt wird bereits über ihre Eigenschaften [mutableStateOf] beobachtet.

5.4.4. App.kt

Portierung von [lib/app.dart]: der Wurzelbildschirm. Er setzt die Komponenten aus [features/] zusammen, leitet deren Aktionen an das ViewModel weiter und fungiert als „Guard“: Solange der Benutzer nicht angemeldet ist, zeigt er nur den Anmeldebildschirm an. Zustand und Logik sind in [AppViewModel] definiert: Diese Datei ZEIGT nur AN.

// =========================================================================
// App.kt
// -------------------------------------------------------------------------
// Port der lib/app.dart (Flutter-Client): der WURZEL-Bildschirm der Anwendung.
// Wie in allen Varianten dieses Kurses spielt er die Rolle des
// "Dirigenten" - er setzt die Bildschirme aus lib/features/
// (hier features/) zusammen und leitet deren Aktionen weiter - und die Rolle des "Guards": Solange
// der Benutzer nicht angemeldet ist, zeigt er nur den Anmeldebildschirm an.
//
// Zustand und Logik wurden in AppViewModel ausgelagert (den Grund dafür siehe
// dort): Diese Datei ZEIGT nur an.
//
// Drei @Composable-Funktionen:
//   - RdvMedecinsApp: das Theme der Anwendung (MaterialApp auf Flutter-Seite);
//   - AppRoot       : der Bildschirm selbst (Titelleiste + Inhalt);
//   - ServerUrlField und LanguageSelector: zwei kleine Elemente des Bildschirms.
// =========================================================================

package fr.rdvmedecins.client

import androidx.compose.foundation.layout.Column
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.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalApi
import fr.rdvmedecins.client.core.LocalSettings
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.i18n.TranslationsService
import fr.rdvmedecins.client.features.schedule.ScheduleView
import fr.rdvmedecins.client.features.bookingdialog.BookingDialog
import fr.rdvmedecins.client.features.doctordaypicker.DoctorDayPicker
import fr.rdvmedecins.client.features.login.LoginPage

// -------------------------------------------------------------------------
// das Theme: ein "primäres" Blau für Titelleiste und Buttons, wie
// das blaue Banner (navbar bg-primary) der Web-Varianten dieses Kurses
// -------------------------------------------------------------------------
private val appColors = lightColorScheme(
    primary = Color(0xFF1565C0),
    onPrimary = Color.White,
)

@Composable
fun RdvMedecinsApp() {
    MaterialTheme(colorScheme = appColors) {
        AppRoot()
    }
}

// -------------------------------------------------------------------------
// der Hauptbildschirm
// -------------------------------------------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AppRoot() {
    // die Services, bereitgestellt von MainActivity (siehe core/Locals.kt)
    val auth = LocalAuth.current
    val api = LocalApi.current
    val translations = LocalTranslations.current
    // eine Referenz auf die Methode t(...): t("APP.TITLE") liest sich dann
    // wie in den anderen Varianten des Kurses
    val t = translations::t

    // viewModel { ... }: HOLT das ViewModel dieses Bildschirms, falls es bereits
    // existiert (nach einer Drehung), oder ERSTELLT es beim ersten Mal mit dem übergebenen Block.
    // Deshalb darf man nie
    // "val vm = AppViewModel(auth, api)" schreiben: Bei jeder Anzeige würde ein neues, leeres
    // ViewModel aufgebaut.
    val vm = viewModel { AppViewModel(auth, api) }

    // schmaler Bildschirm (Smartphone im Hochformat): Die Titelleiste wird abgespeckt
    val narrow = LocalConfiguration.current.screenWidthDp < 600

    // Scaffold: die Standardstruktur eines Material-Bildschirms (Titelleiste,
    // Inhalt...) - dasselbe Widget und derselbe Name wie in Flutter
    Scaffold(
        topBar = {
            TopAppBar(
                // auf einem schmalen Bildschirm ein kurzer Titel: Neben den FR/EN-Buttons, der Rolle und dem
                // Abmelde-Button ist nicht genug Platz für den
                // vollständigen Titel
                title = {
                    Text(
                        text = if (narrow) "RdvMedecins" else t("APP.TITLE"),
                        maxLines = 1,
                        overflow = TextOverflow.Ellipsis,
                    )
                },
                colors = TopAppBarDefaults.topAppBarColors(
                    containerColor = MaterialTheme.colorScheme.primary,
                    titleContentColor = MaterialTheme.colorScheme.onPrimary,
                    actionIconContentColor = MaterialTheme.colorScheme.onPrimary,
                ),
                // actions: die rechts in der Titelleiste ausgerichteten Elemente
                actions = {
                    // FR/EN-Auswahl: IMMER sichtbar, auch vor der Anmeldung
                    LanguageSelector(translations)
                    // ein einfaches Kotlin-if: Rollen-Badge, Name und
                    // Abmelde-Button existieren erst nach der Anmeldung
                    if (auth.isLoggedIn) {
                        Surface(
                            shape = RoundedCornerShape(8.dp),
                            color = Color.White.copy(alpha = 0.2f),
                            contentColor = MaterialTheme.colorScheme.onPrimary,
                        ) {
                            Text(
                                text = auth.role?.name ?: "",
                                style = MaterialTheme.typography.labelMedium,
                                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
                            )
                        }
                        // auf einem schmalen Bildschirm wird der Name aus Platzmangel ausgeblendet
                        if (!narrow) {
                            Spacer(Modifier.width(8.dp))
                            Text(auth.name ?: "", color = MaterialTheme.colorScheme.onPrimary)
                        }
                        IconButton(onClick = vm::logOut) {
                            Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = t("APP.LOGOUT"))
                        }
                    }
                },
            )
        },
    ) { systemInsets ->
        // systemInsets: der von der Titelleiste und den Systemleisten belegte Platz,
        // der frei bleiben muss (siehe enableEdgeToEdge())
        Column(
            modifier = Modifier
                .padding(systemInsets)
                .fillMaxSize()
                // das Pendant zum SingleChildScrollView der Flutter-Version
                .verticalScroll(rememberScrollState())
                .padding(16.dp),
        ) {
            // die Server-URL, vor wie nach der Anmeldung editierbar
            ServerUrlField(label = t("APP.SERVER_URL_LABEL"))
            Spacer(Modifier.height(16.dp))

            // die Fehlermeldung, falls vorhanden
            vm.error?.let { message ->
                Surface(
                    color = MaterialTheme.colorScheme.errorContainer,
                    contentColor = MaterialTheme.colorScheme.onErrorContainer,
                    shape = RoundedCornerShape(4.dp),
                    modifier = Modifier.fillMaxWidth(),
                ) {
                    Text(message, modifier = Modifier.padding(12.dp))
                }
                Spacer(Modifier.height(16.dp))
            }

            // der "Guard": nicht angemeldet -> nur der Anmeldebildschirm
            if (!auth.isLoggedIn) {
                LoginPage()
            } else {
                // 1. Auswahl des Arztes und des Tages
                DoctorDayPicker(doctors = vm.doctors, onSearch = vm::searchSchedule)
                Spacer(Modifier.height(16.dp))
                // 2. der Terminkalender; canEdit blendet "Book"/"Cancel"
                //    für die Rolle USER aus
                ScheduleView(
                    schedule = vm.schedule,
                    canEdit = auth.isAdmin,
                    onBook = vm::requestBooking,
                    onCancel = vm::cancelAppointment,
                )
            }
        }

        // 3. der Buchungsdialog: wird angezeigt, solange ein
        //    Zeitfenster gebucht wird (siehe AppViewModel)
        vm.slotBeingBooked?.let { slot ->
            BookingDialog(
                slot = slot,
                clients = vm.clients,
                onConfirm = vm::confirmBooking,
                onClose = vm::closeBooking,
            )
        }
    }
}

// -------------------------------------------------------------------------
// das Feld "Server URL". Die Flutter-Version benötigte ein eigenes
// StatefulWidget, um einen TextEditingController zu erstellen und wieder freizugeben.
// In Compose hat ein Textfeld keinen versteckten Zustand: Es ZEIGT den Wert an und
// MELDET jeden Tastenanschlag über onValueChange - wir müssen den Zustand selbst aktualisieren,
// woraufhin das Feld mit dem neuen Wert neu angezeigt wird.
// Das ist das "v-model" von Vue.js, in zwei explizite Hälften geschrieben.
// -------------------------------------------------------------------------
@Composable
private fun ServerUrlField(label: String) {
    val settings = LocalSettings.current
    OutlinedTextField(
        value = settings.apiBaseUrl,
        onValueChange = settings::changeUrl,
        label = { Text(label) },
        singleLine = true,
        // für die Eingabe einer URL geeignete Tastatur (Tasten "/", ".", ":"...)
        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri),
        modifier = Modifier.widthIn(max = 360.dp).fillMaxWidth(),
    )
}

// -------------------------------------------------------------------------
// die beiden Buttons FR / EN der Titelleiste: Die aktuelle Sprache wird
// in fettem Weiß angezeigt, die andere in gedimmtem Weiß
// -------------------------------------------------------------------------
@Composable
private fun LanguageSelector(translations: TranslationsService) {
    listOf("fr", "en").forEach { language ->
        val current = language == translations.currentLanguage
        TextButton(onClick = { translations.changeLanguage(language) }) {
            Text(
                text = language.uppercase(),
                fontWeight = if (current) FontWeight.Bold else FontWeight.Normal,
                color = MaterialTheme.colorScheme.onPrimary.copy(alpha = if (current) 1f else 0.6f),
            )
        }
    }
}

Kommentieren wir diesen Code:

  • Zeilen 70–72: das Farbschema: Blau als Primärfarbe ([primary]), Weiß für den Text darauf ([onPrimary]). Die übrigen Farben sind die Standardfarben von Material 3;
  • Zeilen 76–78: [RdvMedecinsApp] wendet das Thema auf den gesamten Bildschirm an ([MaterialTheme]), ähnlich wie [MaterialApp] in Flutter;
  • Zeile 85: [@OptIn(ExperimentalMaterial3Api::class)] – [TopAppBar] ist in Material 3 noch als „experimentell“ markiert: Die Annotation zeigt an, dass die Komponente in Kenntnis der Risiken verwendet wird (ohne sie lehnt der Compiler den Code ab);
  • Zeilen 89–91: die Services, als CompositionLocal gelesen – das Äquivalent zu [context.read<...>()] / [context.watch<...>()];
  • Zeile 94: [val t = translations::t] – eine REFERENZ auf die Methode [t] des Objekts [translations]: Danach schreiben wir [t("APP.TITLE")], wie in den anderen Varianten des Kurses;
  • Zeile 101: [viewModel { AppViewModel(auth, api) }] - HOLT das ViewModel dieses Bildschirms, falls es bereits existiert (nach einer Drehung), oder ERSTELLT es beim ersten Mal mit dem übergebenen Block. Das ViewModel überlebt somit die Neuerstellung der Aktivität;
  • Zeile 104: die Bildschirmbreite in dp, aus der aktuellen Konfiguration gelesen: Unter 600 dp (Smartphone im Hochformat) wird die Titelleiste vereinfacht – kurzer Titel (Zeile 116) und ausgeblendeter Benutzername (Zeile 145);
  • Zeile 108: [Scaffold(topBar = { ... }) { systemInsets -> ... }] – die Standardstruktur eines Material-Bildschirms, wie in Flutter. Der letzte Parameter, ein Lambda, ist der Inhalt des Bildschirms; er erhält die einzuhaltenden Abstände (Titelleiste und Systemleisten);
  • Zeile 110: [TopAppBar] – die Titelleiste, in der Primärfarbe des Themas eingefärbt;
  • Zeilen 127–132: [actions = { ... }] – die rechts in der Leiste ausgerichteten Elemente: die Sprachauswahl, IMMER sichtbar; dann, mit einem einfachen [if], das Rollen-Badge, der Name und der Abmelde-Button, die erst nach der Anmeldung erscheinen. Da [auth.isLoggedIn] ein beobachtbarer Zustand ist, wird die Leiste bei An- und Abmeldung automatisch neu zusammengesetzt;
  • Zeile 149: [onClick = vm::logOut] – eine als Klick-Handler übergebene Methodenreferenz;
  • Zeilen 159–165: der Inhalt: eine scrollbare [Column] ([verticalScroll], das Äquivalent zu [SingleChildScrollView] in Flutter);
  • Zeile 172: die Fehlermeldung des ViewModels, falls vorhanden: [vm.error?.let { message -> ... }] gibt den Block nur aus, wenn [error] nicht [null] ist;
  • Zeilen 185–197: der „Guard“: Wenn der Benutzer nicht angemeldet ist, der Anmeldebildschirm; wenn er angemeldet ist, die Auswahl von Arzt und Tag, gefolgt vom Kalender. [canEdit = auth.isAdmin] blendet die Buttons zur Terminbuchung für die Rolle USER aus;
  • Zeilen 204–209: das Buchungsdialogfeld, das angezeigt wird, solange [vm.slotBeingBooked] nicht [null] ist (siehe [AppViewModel] und [BookingDialog]);
  • Zeilen 224–232: [ServerUrlField] – das Feld „Server-URL“. In Compose hat ein Eingabefeld keinen verborgenen Zustand: Es ZEIGT [value] AN und MELDET jeden Tastenanschlag über [onValueChange]. Hier wird jeder Tastenanschlag an [settings.changeUrl(...)] gesendet, das den beobachteten Zustand aktualisiert – und das Feld wird mit dem neuen Wert neu gezeichnet. Die Flutter-Version benötigte einen [TextEditingController] und damit ein eigenes [StatefulWidget], um ihn zu erstellen und freizugeben;
  • Zeilen 242–245: [LanguageSelector] – zwei [TextButton]-Instanzen, „FR“ und „EN“, die in einer Schleife über die Sprachliste erzeugt werden; die aktuelle Sprache ist fett dargestellt.

5.4.5. AppViewModel.kt

Zustand und Logik des Wurzelbildschirms: der Teil [_AppRootState] von [lib/app.dart].

// =========================================================================
// AppViewModel.kt
// -------------------------------------------------------------------------
// Der ZUSTAND und die LOGIK des Hauptbildschirms: der Teil "_AppRootState" der
// lib/app.dart der Flutter-Version (Ärzte, Patienten, angezeigter
// Terminkalender, Fehler, letzte Suche...) und die Reaktionen auf die
// Aktionen des Benutzers (Terminkalender suchen, buchen, stornieren).
//
// Warum ein ViewModel und nicht lokale Zustände in der @Composable-Funktion
// AppRoot (siehe App.kt)? Weil die Activity bei jeder Bildschirmdrehung zerstört und
// neu erstellt wird (siehe RdvMedecinsApplication): Ein
// lokaler Zustand ginge verloren - der angezeigte Terminkalender verschwände bei der kleinsten
// Neigung des Smartphones. Ein ViewModel (Bibliothek "lifecycle" von Android Jetpack)
// ÜBERLEBT diese Neuerstellungen: Android behält es
// und übergibt es der neuen Activity. Es wird erst zerstört, wenn der Bildschirm
// endgültig verlassen wird. Flutter kennt dieses Problem nicht: Dort
// zerstört eine Drehung nichts, nur die Bildschirmgröße ändert sich.
//
// Die sich daraus ergebende Aufteilung ist unter Android klassisch: App.kt ZEIGT an, dieses
// ViewModel ENTSCHEIDET und ruft die Services auf.
// =========================================================================

package fr.rdvmedecins.client

import android.util.Log
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.models.AppointmentJson
import fr.rdvmedecins.client.core.services.AuthService
import fr.rdvmedecins.client.core.services.AppointmentService
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.launch

class AppViewModel(
    private val auth: AuthService,
    private val api: AppointmentService,
) : ViewModel() {

    // ––– von App.kt angezeigter Zustand (öffentlich lesbar, privat schreibbar) –––
    var doctors by mutableStateOf<List<Doctor>>(emptyList())
        private set
    var clients by mutableStateOf<List<Client>>(emptyList())
        private set
    var schedule by mutableStateOf<DoctorDaySchedule?>(null)
        private set
    var error by mutableStateOf<String?>(null)
        private set

    // das Zeitfenster, das gerade gebucht wird: nicht null = der Buchungsdialog
    // ist geöffnet (siehe App.kt und BookingDialog.kt)
    var slotBeingBooked by mutableStateOf<SlotJson?>(null)
        private set

    // die letzte Suche (Arzt + Tag), um den Terminkalender nach
    // einer Buchung oder Stornierung zu aktualisieren. Wird nie angezeigt: Einfache
    // Properties genügen, sie müssen keine Compose-Zustände sein.
    private var lastDoctorId: Int? = null
    private var lastDay: String? = null

    init {
        // snapshotFlow { ... } macht das Lesen eines Compose-Zustands zu einem
        // FLOW von Werten: Er liefert sofort den aktuellen Wert von auth.isLoggedIn,
        // dann jeden neuen Wert. Er entspricht exakt
        // dem "watch(() => auth.isLoggedIn, ..., { immediate: true })" von Vue.js
        // - und dem Abonnement per addListener(...) samt anfänglichem Aufruf,
        // das die Flutter-Version von Hand schreiben musste.
        // viewModelScope: Die in diesem Scope gestarteten Coroutinen werden
        // automatisch abgebrochen, wenn das ViewModel zerstört wird (das removeListener(...)
        // aus dispose() auf Flutter-Seite ist nicht mehr nötig).
        viewModelScope.launch {
            snapshotFlow { auth.isLoggedIn }.collect { loggedIn ->
                if (loggedIn) {
                    loadInitialLists()
                } else {
                    reset()
                }
            }
        }
    }

    // -----------------------------------------------------------------------
    // bei der Anmeldung (oder wenn eine gemerkte Sitzung wiederhergestellt wird): Wir
    // laden die Ärzte und die Patienten ein für alle Mal. Zwei
    // getrennte Coroutinen: Die beiden Anfragen werden PARALLEL gesendet.
    // -----------------------------------------------------------------------
    private fun loadInitialLists() {
        runSafely { doctors = api.getAllDoctors() }
        runSafely { clients = api.getAllClients() }
    }

    // -----------------------------------------------------------------------
    // bei der Abmeldung (Button oder vom Server abgelehntes Token): Wir
    // verwerfen den fachlichen Zustand, damit ein neuer Benutzer nicht, auch nicht für einen
    // Augenblick, den Terminkalender des vorherigen Benutzers sieht
    // -----------------------------------------------------------------------
    private fun reset() {
        doctors = emptyList()
        clients = emptyList()
        schedule = null
        error = null
        slotBeingBooked = null
        lastDoctorId = null
        lastDay = null
    }

    // Button "Log out": Es genügt, AuthService abzumelden -
    // snapshotFlow (siehe init) löst dann reset() aus
    fun logOut() {
        auth.logOut()
    }

    // -----------------------------------------------------------------------
    // Button "View schedule" von DoctorDayPicker
    // -----------------------------------------------------------------------
    fun searchSchedule(doctorId: Int, day: String) {
        error = null
        lastDoctorId = doctorId
        lastDay = day
        loadSchedule()
    }

    // -----------------------------------------------------------------------
    // Button "Book" von ScheduleView: Wir ÖFFNEN lediglich den
    // Dialog und merken uns das betreffende Zeitfenster. Mit Compose ist ein Dialog
    // Teil der Anzeige wie alles andere: Er wird
    // angezeigt, solange slotBeingBooked nicht null ist (siehe App.kt) -
    // dasselbe Prinzip wie die Prop "open" des BookingDialog.vue der
    // Vue.js-Variante, das Gegenteil von Flutters showDialog(...).
    // -----------------------------------------------------------------------
    fun requestBooking(slot: SlotJson) {
        slotBeingBooked = slot
    }

    // Button "Cancel" (oder Tippen außerhalb) des Dialogs
    fun closeBooking() {
        slotBeingBooked = null
    }

    // Button "Confirm" des Dialogs
    fun confirmBooking(clientId: Int) {
        val slot = slotBeingBooked ?: return
        val day = lastDay ?: return
        slotBeingBooked = null // schließt den Dialog
        runSafely {
            api.addAppointment(day, clientId, slot.id)
            loadSchedule() // das Zeitfenster erscheint nun als belegt
        }
    }

    // -----------------------------------------------------------------------
    // Button "Cancel" eines belegten Zeitfensters in ScheduleView
    // -----------------------------------------------------------------------
    fun cancelAppointment(appointment: AppointmentJson) {
        runSafely {
            api.deleteAppointment(appointment.id)
            loadSchedule() // das Zeitfenster wird wieder frei
        }
    }

    private fun loadSchedule() {
        val doctorId = lastDoctorId ?: return
        val day = lastDay ?: return
        runSafely { schedule = api.getDoctorScheduleOfDay(doctorId, day) }
    }

    // -----------------------------------------------------------------------
    // führt [action] in einer ViewModel-Coroutine aus und wandelt jede
    // Exception in eine auf dem Bildschirm angezeigte Fehlermeldung um. Das Auslagern
    // dieses try/catch erspart es, ihn in jeder obigen Methode zu wiederholen.
    // Eine CancellationException ist KEIN Fehler: Sie ist das Abbruchsignal
    // einer Coroutine (ViewModel zerstört) und muss
    // weitergereicht werden.
    // -----------------------------------------------------------------------
    private fun runSafely(action: suspend () -> Unit) {
        viewModelScope.launch {
            try {
                action()
            } catch (e: CancellationException) {
                throw e
            } catch (e: Exception) {
                Log.w("RdvMedecins", "a server call failed", e) // siehe Logcat
                error = e.message ?: e.toString()
            }
        }
    }
}

Kommentieren wir diesen Code:

  • Zeile 45: Die Klasse erweitert [ViewModel]; sie erhält die beiden benötigten Services über ihren Konstruktor;
  • Zeilen 48–54: der von [App.kt] angezeigte Zustand: Eigenschaften mit [by mutableStateOf(...)], für alle lesbar ([App.kt] liest sie), aber nur vom ViewModel änderbar ([private set]);
  • Zeile 59: [slotBeingBooked] – der Zeitslot, der gerade gebucht wird. Wenn er nicht [null] ist, wird das Buchungsdialogfeld angezeigt;
  • Zeilen 65–66: die letzte Suche (Arzt und Tag), mit der der Kalender nach einer Buchung oder Stornierung aktualisiert wird. Das sind einfache private Eigenschaften: Sie werden nie angezeigt;
  • Zeilen 78–83: [snapshotFlow { auth.isLoggedIn }] wandelt das Lesen eines Compose-Zustands in einen FLOW um, eine Folge von Werten: zuerst sofort den aktuellen Wert, dann jeden neuen Wert. [collect { ... }] verarbeitet jeden einzelnen: Bei Anmeldung lädt es Ärzte und Patienten; bei Abmeldung leert es den Zustand. Das ist das Pendant zu [watch(..., { immediate: true })] in Vue.js, das die Flutter-Version mit [addListener(...)] und einem von Hand geschriebenen Anfangsaufruf nachbilden musste;
  • Zeilen 94–96: [loadInitialLists()] – zwei getrennte Coroutinen: Beide Anfragen werden PARALLEL gesendet;
  • Zeilen 116–117: [logOut()] meldet lediglich [AuthService] ab; erst [snapshotFlow] löst dann das Leeren des Zustands aus. Dasselbe gilt, wenn [AuthInterceptor] den Benutzer abmeldet (Token vom Server abgelehnt): Das ViewModel muss die Ursache der Abmeldung nicht kennen;
  • Zeilen 138–139: [requestBooking(...)] ÖFFNET KEIN Dialogfeld, sondern speichert lediglich den Zeitslot. Die Anzeige folgt dem Zustand – [App.kt] gibt [BookingDialog] aus, solange [slotBeingBooked] nicht [null] ist. Dieses Dialogfeld überlebt daher auch die Bildschirmdrehung (siehe Kapitel 5);
  • Zeilen 148–154: [confirmBooking(...)] – schließt das Dialogfeld, ruft dann den Server auf und aktualisiert den Kalender: Der Zeitslot erscheint als gebucht;
  • Zeilen 182–190: [runSafely(action)] – startet [action] (eine Funktion vom Typ [suspend]) in einer Coroutine des ViewModels und wandelt jede Ausnahme in eine angezeigte Fehlermeldung um. [CancellationException] wird erneut ausgelöst: Das ist kein Fehler, sondern das Signal für den Abbruch einer Coroutine (das ViewModel wird zerstört), das sich ausbreiten können muss. [Log.w(...)] schreibt den vollständigen Fehler in das Android-Log, das im Tab [Logcat] von Android Studio angezeigt werden kann.

5.5. Die Schicht core/models

5.5.1. core/models/AppointmentModels.kt

Portierung von [lib/core/models/appointment_models.dart]: die mit dem Server ausgetauschten Datenklassen.

// =========================================================================
// AppointmentModels.kt
// -------------------------------------------------------------------------
// Die mit dem NestJS-Server ausgetauschten Datenklassen: das Spiegelbild, in
// Kotlin, des von seinen Routen gelieferten JSON. Port der
// lib/core/models/appointment_models.dart (Flutter-Client dieses Kurses).
//
// Wesentlicher Unterschied zur Flutter-Version: KEIN von Hand geschriebener
// Konstruktor fromJson(...). Die Annotation @Serializable weist das
// Compiler-Plugin kotlinx.serialization (siehe app/build.gradle.kts) an,
// zur Kompilierzeit den Code zu
// ERZEUGEN, der jede Klasse als JSON liest und schreibt. Wie in Dart (und anders als in TypeScript) werden
// die Typen zur Laufzeit geprüft: Ein fehlender Pflichtschlüssel oder ein Schlüssel
// unerwarteten Typs löst sofort eine Exception aus (SerializationException).
//
// Eine Kotlin-"data class" (siehe den Kotlin-Kurs) bringt außerdem ohne eine einzige
// Codezeile: equals/hashCode (Vergleich nach Wert), toString und
// copy(...). Alle Properties sind schreibgeschützt (val): Diese
// Objekte sind UNVERÄNDERLICH, was perfekt zu Jetpack Compose passt,
// das den alten und den neuen Zustand vergleicht, um zu wissen, was neu gezeichnet werden muss.
// =========================================================================

package fr.rdvmedecins.client.core.models

import kotlinx.serialization.Serializable

// ein Arzt, wie von GET /getAllDoctors geliefert (der Server sendet auch
// ein Feld "version", das hier dank ignoreUnknownKeys ignoriert wird, siehe
// Response.kt)
@Serializable
data class Doctor(
    val id: Int,
    val title: String,
    val lastName: String,
    val firstName: String,
)

// ein Patient (Kunde der Arztpraxis), geliefert von GET /getAllClients
@Serializable
data class Client(
    val id: Int,
    val title: String,
    val lastName: String,
    val firstName: String,
)

// ein Sprechstunden-Zeitfenster: startHour/startMinute -> endHour/endMinute
@Serializable
data class SlotJson(
    val id: Int,
    val startHour: Int,
    val startMinute: Int,
    val endHour: Int,
    val endMinute: Int,
)

// ein Termin: ein Tag, ein Patient, ein Zeitfenster. Die Standardwerte "= null"
// machen die Schlüssel im empfangenen JSON optional.
@Serializable
data class AppointmentJson(
    val id: Int,
    val day: String, // Format "yyyy-MM-dd"
    val client: Client? = null,
    val slot: SlotJson? = null,
)

// eine Zeile des Terminkalenders: ein Zeitfenster und, falls belegt, der zugehörige Termin
@Serializable
data class DoctorDaySlot(
    val slot: SlotJson,
    val appointment: AppointmentJson? = null, // null = freies Zeitfenster
)

// der Terminkalender eines Arztes für einen Tag, geliefert von
// GET /getDoctorScheduleOfDay/{doctorId}/{day}
@Serializable
data class DoctorDaySchedule(
    val doctor: Doctor,
    val day: String,
    val slots: List<DoctorDaySlot>,
)

// -------------------------------------------------------------------------
// Authentifizierung
// -------------------------------------------------------------------------

// die beiden Rollen der Anwendung. Die Namen der Konstanten sind
// GENAU die vom Server gesendeten Zeichenfolgen ("ADMIN", "USER"):
// kotlinx.serialization wandelt daher den JSON-String direkt in eine
// Enum-Konstante um, wo die Flutter-Version von Hand
// Role.fromString(...) und asString() schreiben musste.
@Serializable
enum class Role { ADMIN, USER }

// der an POST /login gesendete JSON-Body
@Serializable
data class LoginRequest(
    val login: String,
    val password: String,
)

// der Inhalt von "data" in der Antwort von POST /login
@Serializable
data class LoginResult(
    val accessToken: String, // das JWT-Token, das bei jeder folgenden Anfrage vorzulegen ist
    val login: String,
    val name: String,
    val role: Role,
)

// die an POST /addAppointment und POST /deleteAppointment gesendeten JSON-Bodys
@Serializable
data class AddAppointmentRequest(
    val day: String,
    val clientId: Int,
    val slotId: Int,
)

@Serializable
data class DeleteAppointmentRequest(
    val appointmentId: Int,
)

Kommentieren wir diesen Code:

  • Zeilen 30–31: [@Serializable data class Doctor(...)] – eine „Data Class“ (siehe den Kotlin-Kurs): [equals]/[hashCode] nach Wert, [toString], [copy(...)], ohne eine einzige Zeile Code. Die Annotation [@Serializable] weist das Plugin kotlinx.serialization an, zur Kompilierzeit den Code zu erzeugen, der die Klasse in JSON liest und schreibt – wo die Flutter-Version pro Klasse von Hand einen Konstruktor [fromJson(...)] schrieb;
  • Zeile 63: [val client: Client? = null] – ein nullbarer Typ mit Standardwert: Der Schlüssel [client] kann im empfangenen JSON fehlen oder den Wert [null] haben;
  • Zeile 71: [val appointment: AppointmentJson? = null] - [null] bedeutet, dass der Zeitslot frei ist;
  • Zeile 93: [enum class Role { ADMIN, USER }] – die Namen der Konstanten entsprechen genau den vom Server gesendeten Zeichenketten: kotlinx.serialization wandelt ["ADMIN"] direkt in [Role.ADMIN] um, während die Flutter-Version [Role.fromString(...)] und [asString()] schrieb;
  • Zeilen 97, 113 und 120: die Klassen für die an den Server GESENDETEN JSON-Bodies ([LoginRequest], [AddAppointmentRequest], [DeleteAppointmentRequest]): Dieselbe Annotation, [@Serializable], dient der Kodierung. Die Flutter-Version erstellte diese Bodies mit literalen [Map]-Werten.

5.5.2. core/models/Response.kt

Dekodierung des [{ status, data }]-Wrappers, der allen fachlichen Antworten des Servers gemeinsam ist.

// =========================================================================
// Response.kt
// -------------------------------------------------------------------------
// Alle fachlichen Antworten des NestJS-Servers haben dieselbe Form:
//
//     { "status": 0, "data": ... }
//
// wobei status bei Erfolg 0 ist (siehe ResponseStatus auf Serverseite).
// Die Flutter-Version dekodierte diesen Umschlag mit einer generischen Klasse
// ServerResponse<T>. Hier gehen wir aus einem bestimmten Grund in ZWEI Schritten vor: Bei einem
// Fehler legt der Server eine Liste von Meldungen in "data" ab
// (List<String>), wo bei Erfolg zum Beispiel ein Terminkalender erwartet wird.
// Würde man {status, data} sofort als ServerResponse<DoctorDaySchedule> dekodieren,
// schlüge das bei einer Fehlerantwort fehl, noch bevor der Status gelesen wird.
//   1. wir lesen den Umschlag als generischen JSON-Baum (JsonObject);
//   2. wir prüfen status; nur wenn er 0 ist, dekodieren wir "data" in den
//      erwarteten Typ.
// =========================================================================

package fr.rdvmedecins.client.core.models

import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.int
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive

// die JSON-Konfiguration, die vom gesamten Client gemeinsam genutzt wird:
// - ignoreUnknownKeys: Der Server sendet Felder, die dieser Client
//   nicht verwendet (z. B. die "version" eines Arztes) - wir ignorieren sie, statt
//   eine Exception auszulösen;
// - explicitNulls = false: Beim Kodieren wird eine null-Property nicht
//   geschrieben (ohne Auswirkung auf die Klassen dieses Clients, aber näher am
//   Verhalten von JSON.stringify auf JavaScript-Seite).
val ApiJson = Json {
    ignoreUnknownKeys = true
    explicitNulls = false
}

// Exception, die ausgelöst wird, wenn der Server mit einem fachlichen Status ungleich 0 antwortet
// (Ressource nicht gefunden, ungültiges Datum, Serverfehler)
class ResponseException(val status: Int) :
    Exception("The server responded with error status $status")

// dekodiert den Body einer {status, data}-Antwort und liefert "data" im
// durch [deserializer] beschriebenen Typ T (z. B. Doctor.serializer() oder
// ListSerializer(Doctor.serializer()) für eine Liste von Ärzten)
fun <T> decodeResponse(body: String, deserializer: DeserializationStrategy<T>): T {
    // 1. der Umschlag als generischer JSON-Baum
    val envelope = ApiJson.parseToJsonElement(body).jsonObject
    // 2. der fachliche Status
    val status = envelope.getValue("status").jsonPrimitive.int
    if (status != 0) {
        throw ResponseException(status)
    }
    // 3. "data", erst jetzt in den erwarteten Typ dekodiert
    val data = envelope["data"] ?: JsonNull
    return ApiJson.decodeFromJsonElement(deserializer, data)
}

Kommentieren wir diesen Code:

  • Zeilen 36–38: [ApiJson] – die vom gesamten Client gemeinsam genutzte JSON-Konfiguration. [ignoreUnknownKeys = true]: Der Server sendet Felder, die der Client nicht verwendet (z. B. [version] eines Arztes); ohne diese Einstellung würde kotlinx.serialization beim ersten unbekannten Schlüssel eine Ausnahme auslösen;
  • Zeile 43: [ResponseException] – die Ausnahme, die ausgelöst wird, wenn der Server mit einem fachlichen Status ungleich 0 antwortet;
  • Zeile 49: [decodeResponse(body, deserializer)] - eine generische Funktion: Der Parameter [deserializer] (zum Beispiel [Doctor.serializer()], vom Plugin erzeugt) legt den Typ [T] fest, in den [data] dekodiert wird;
  • Zeilen 51–59: Die Dekodierung erfolgt in ZWEI Schritten. Zunächst wird der Umschlag als generischer JSON-Baum gelesen ([JsonObject]); erst dann, wenn [status] gleich 0 ist, wird [data] in den erwarteten Typ dekodiert. Grund: Im Fehlerfall legt der Server eine Liste von Meldungen in [data] ab, während im Erfolgsfall zum Beispiel ein Kalender zu erwarten ist. Würde man den gesamten Umschlag sofort in den Erfolgstyp dekodieren, schlüge dies bei einer Fehlerantwort fehl, noch bevor der Status gelesen werden könnte.

5.6. Die Schicht core/services

5.6.1. core/services/SettingsService.kt

Portierung von [lib/core/services/settings_service.dart]: die URL des Servers.

// =========================================================================
// SettingsService.kt
// -------------------------------------------------------------------------
// Port der lib/core/services/settings_service.dart: hält die URL des
// NestJS-Servers, auf dem Bildschirm editierbar (Feld "Server URL").
//
// Die Flutter-Version erweiterte ChangeNotifier und musste nach jeder Änderung
// notifyListeners() aufrufen. Hier ist die Property
// mit "by mutableStateOf(...)" deklariert: Sie ist ein BEOBACHTBARER ZUSTAND von
// Jetpack Compose. Jede @Composable-Funktion, die apiBaseUrl bei ihrer
// Anzeige LIEST, wird bei einer Wertänderung automatisch neu angezeigt -
// ohne notifyListeners(), ohne context.watch<...>(): Compose erfasst
// jedes Lesen selbst (dasselbe Prinzip wie reactive(...) / ref(...)
// auf Vue.js-Seite).
//
// Kleine Verbesserung gegenüber der Flutter-Version: Die URL wird
// in den SharedPreferences des Smartphones gespeichert, damit sie nicht bei jedem Start der Anwendung
// neu eingegeben werden muss (auf Mobilgeräten weicht sie
// fast immer vom Standardwert ab, siehe Kapitel 5).
// =========================================================================

package fr.rdvmedecins.client.core.services

import android.content.SharedPreferences
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit

class SettingsService(private val prefs: SharedPreferences) {

    // der Anfangswert wird SYNCHRON aus den Einstellungen zurückgelesen:
    // getString(...) antwortet sofort (die Einstellungen werden
    // beim ersten Zugriff in den Speicher geladen). "private set": Nur diese
    // Klasse kann die URL ändern, über changeUrl(...).
    var apiBaseUrl: String by mutableStateOf(prefs.getString(URL_KEY, null) ?: DEFAULT_URL)
        private set

    fun changeUrl(url: String) {
        if (url == apiBaseUrl) {
            return // vermeidet eine unnötige Neuanzeige und einen unnötigen Schreibvorgang
        }
        apiBaseUrl = url
        // edit { ... }: Erweiterungsfunktion aus androidx.core (core-ktx);
        // sie öffnet einen Editor, führt den Block aus und ruft dann apply() auf,
        // was im Hintergrund auf den Datenträger schreibt, ohne die UI zu blockieren.
        prefs.edit { putString(URL_KEY, url) }
    }

    companion object {
        // 10.0.2.2: Im Android-Emulator bezeichnet diese spezielle Adresse
        // den Host-Rechner, auf dem der NestJS-Server läuft
        // (localhost würde den Emulator selbst bezeichnen, siehe Kapitel 5)
        const val DEFAULT_URL = "http://10.0.2.2:8080"
        private const val URL_KEY = "rdvmedecins.apiBaseUrl"
    }
}

Kommentieren wir diesen Code:

  • Zeilen 36–37: [var apiBaseUrl: String by mutableStateOf(...)] – ein beobachtbarer Zustand, initialisiert mit dem in den Einstellungen gespeicherten Wert oder dem Standardwert. [private set]: Nur diese Klasse kann ihn ändern;
  • Zeile 39: [changeUrl(...)] – die Methode kann nicht [setApiBaseUrl] heißen: Dieser Name wird bereits vom privaten „Setter“ verwendet, den Kotlin für die Eigenschaft [apiBaseUrl] erzeugt (beide hätten für die JVM dieselbe Signatur);
  • Zeile 47: [prefs.edit { putString(...) }] – eine Erweiterungsfunktion der Bibliothek [core-ktx]: Sie öffnet einen Editor, führt den Block aus und ruft dann [apply()] auf, was im Hintergrund auf den Datenträger schreibt. Die URL bleibt so beim nächsten Start erhalten (eine kleine Verbesserung gegenüber der Flutter-Version, nützlich auf einem Smartphone, wo die URL fast immer vom Standardwert abweicht);
  • Zeile 54: [DEFAULT_URL = "http://10.0.2.2:8080"] – die Serveradresse aus Sicht des Android-Emulators (siehe Kapitel 5). Die Flutter-Version, die auch für Web und Desktop gedacht war, verwendete [localhost].

5.6.2. core/services/AuthService.kt

Portierung von [lib/core/services/auth_service.dart]: die Sitzung des angemeldeten Benutzers, Anmeldung und Abmeldung.

// =========================================================================
// AuthService.kt
// -------------------------------------------------------------------------
// Port der lib/core/services/auth_service.dart: die Sitzung des
// angemeldeten Benutzers (JWT-Token, Login, Name, Rolle), Anmeldung
// (POST /login) und Abmeldung.
//
// Wie in SettingsService sind die von der UI angezeigten Properties
// Compose-Zustände (mutableStateOf): Die Anzeige wechselt AUTOMATISCH
// vom Anmeldebildschirm zum Terminkalender, sobald isLoggedIn true wird.
//
// Die Sitzung wird in den SharedPreferences gespeichert: Ein Benutzer, der
// die Anwendung neu startet, erhält sie zurück, ohne sich erneut anzumelden (solange das Token
// nicht abgelaufen ist - zum Fall eines abgelaufenen Tokens siehe AuthInterceptor).
// Unterschied zu Flutter: SharedPreferences (die ursprüngliche Android-API,
// deren Namen das Flutter-Paket shared_preferences übernommen hat) wird
// SYNCHRON gelesen. Die Sitzung wird daher direkt im Konstruktor (init-
// Block) wiederhergestellt, ohne asynchrone Methode init(), auf die vor der Anzeige des
// ersten Bildschirms gewartet werden müsste.
// =========================================================================

package fr.rdvmedecins.client.core.services

import android.content.SharedPreferences
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
import fr.rdvmedecins.client.core.models.ApiJson
import fr.rdvmedecins.client.core.models.LoginRequest
import fr.rdvmedecins.client.core.models.LoginResult
import fr.rdvmedecins.client.core.models.Role
import fr.rdvmedecins.client.core.models.decodeResponse
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException

class AuthService(
    private val settings: SettingsService,
    private val prefs: SharedPreferences,
    // ein HTTP-Client OHNE den Authentifizierungs-Interceptor: POST /login
    // ist die einzige öffentliche Route des Servers, es gibt kein Token,
    // das gesendet werden könnte (siehe RdvMedecinsApplication)
    private val http: OkHttpClient,
) {
    // ––– Sitzungszustand, von der UI beobachtet –––
    var isLoggedIn by mutableStateOf(false)
        private set
    var login by mutableStateOf<String?>(null)
        private set
    var name by mutableStateOf<String?>(null)
        private set
    var role by mutableStateOf<Role?>(null)
        private set

    // das Token wird nie ANGEZEIGT: Es muss kein Compose-Zustand sein.
    // Es wird jedoch von AuthInterceptor auf einem Netzwerk-Thread gelesen:
    // @Volatile garantiert, dass dieser Thread immer den letzten vom
    // Main-Thread geschriebenen Wert sieht.
    @Volatile
    var accessToken: String? = null
        private set

    // berechnete Property: liest role bei jedem Zugriff neu (und abonniert bei einem Lesen während der
    // Anzeige die Anzeige auf Änderungen von role)
    val isAdmin: Boolean
        get() = role == Role.ADMIN

    init {
        restoreSession()
    }

    // -----------------------------------------------------------------------
    // liest eine möglicherweise bei einem früheren Start gespeicherte Sitzung neu
    // -----------------------------------------------------------------------
    private fun restoreSession() {
        val raw = prefs.getString(SESSION_KEY, null) ?: return // keine gespeicherte Sitzung
        try {
            // die Sitzung wurde als LoginResult gespeichert,
            // als JSON serialisiert (siehe logIn): Wir lesen sie unverändert zurück
            applySession(ApiJson.decodeFromString(LoginResult.serializer(), raw))
        } catch (e: Exception) {
            // unlesbarer Inhalt (z. B. das Format einer alten Version der
            // Anwendung): Wir verwerfen ihn, der Benutzer meldet sich erneut an
            prefs.edit { remove(SESSION_KEY) }
        }
    }

    // -----------------------------------------------------------------------
    // POST /login. "suspend": Diese Funktion kann so lange pausieren,
    // wie der Server für die Antwort braucht, OHNE den aufrufenden Thread zu blockieren -
    // das Pendant zu einer async-Funktion, die ein Future<LoginResult>
    // zurückgibt, auf Dart-Seite. Sie löst eine Exception aus, wenn die Anmeldung fehlschlägt.
    // -----------------------------------------------------------------------
    suspend fun logIn(login: String, password: String): LoginResult {
        // withContext(Dispatchers.IO): Der Block läuft auf einem für Ein-/Ausgabe
        // reservierten Thread. Android VERBIETET jeden Netzwerkzugriff
        // vom Main-Thread aus (NetworkOnMainThreadException): Er
        // zeichnet die UI und darf nie warten.
        val result = withContext(Dispatchers.IO) {
            val body = ApiJson.encodeToString(LoginRequest.serializer(), LoginRequest(login, password))
            val request = Request.Builder()
                .url("${settings.apiBaseUrl}/login")
                .post(body.toRequestBody(JSON_TYPE))
                .build()
            // execute(): ein BLOCKIERENDER Aufruf - hier harmlos, wir sind auf einem
            // Ein-/Ausgabe-Thread. use { } schließt die Antwort am Ende des
            // Blocks, was auch passiert (das Pendant zum
            // try-with-resources von Java, siehe den Kotlin-Kurs).
            http.newCall(request).execute().use { response ->
                // falsche Zugangsdaten: Der Server antwortet 401 Unauthorized
                if (!response.isSuccessful) {
                    throw IOException("Login failed (HTTP ${response.code})")
                }
                decodeResponse(response.body!!.string(), LoginResult.serializer())
            }
        }
        // zurück auf dem Thread des Aufrufers (dem Main-Thread):
        // Hier, und nicht auf dem Ein-/Ausgabe-Thread, ändern wir den
        // von der UI beobachteten Zustand
        applySession(result)
        prefs.edit { putString(SESSION_KEY, ApiJson.encodeToString(LoginResult.serializer(), result)) }
        return result
    }

    // -----------------------------------------------------------------------
    // Abmeldung: Wir verwerfen die Sitzung, im Speicher und in den Einstellungen.
    // Muss auf dem Main-Thread aufgerufen werden (siehe AuthInterceptor).
    // -----------------------------------------------------------------------
    fun logOut() {
        accessToken = null
        login = null
        name = null
        role = null
        isLoggedIn = false
        prefs.edit { remove(SESSION_KEY) }
    }

    private fun applySession(session: LoginResult) {
        accessToken = session.accessToken
        login = session.login
        name = session.name
        role = session.role
        isLoggedIn = true
    }

    companion object {
        private const val SESSION_KEY = "rdvmedecins.session"
        private val JSON_TYPE = "application/json; charset=utf-8".toMediaType()
    }
}

Kommentieren wir diesen Code:

  • Zeilen 51–57: der Sitzungszustand, wie er von der Oberfläche beobachtet wird: [isLoggedIn], [login], [name], [role];
  • Zeilen 64–65: [accessToken] wird nie angezeigt: Es besteht keine Notwendigkeit, daraus einen Compose-Zustand zu machen. Er wird jedoch von [AuthInterceptor] in einem Netzwerk-Thread gelesen: [@Volatile] stellt sicher, dass dieser Thread stets den letzten vom Haupt-Thread geschriebenen Wert sieht;
  • Zeilen 70–71: [isAdmin] – eine berechnete Eigenschaft ([get() = ...]), die bei jedem Zugriff neu gelesen wird;
  • Zeilen 73–85: Der Block [init] stellt eine eventuell zwischengespeicherte Sitzung wieder her, sobald der Service initialisiert wird: Die Einstellungen werden synchron gelesen. Die Sitzung wird als [LoginResult] gespeichert, in JSON serialisiert, und anschließend mit [decodeFromString(LoginResult.serializer(), raw)] wieder gelesen;
  • Zeile 99: [suspend fun logIn(...)] – eine suspendierende Funktion: Sie pausiert, während sie auf die Antwort des Servers wartet, ohne den aufrufenden Thread zu blockieren;
  • Zeile 104: [withContext(Dispatchers.IO) { ... }] – die Anfrage wird in einem I/O-Thread ausgeführt; der Wert des letzten Ausdrucks im Block (das dekodierte [LoginResult]) ist das Ergebnis;
  • Zeilen 106–109: die OkHttp-Anfrage: [Request.Builder()], URL, dann [.post(body.toRequestBody(JSON_TYPE))] – der JSON-Body mit seinem MIME-Typ;
  • Zeile 114: [execute()] führt die Anfrage BLOCKIEREND aus – gefahrlos in einem I/O-Thread. [use { response -> ... }] schließt die Antwort am Ende des Blocks, was auch geschieht: das Äquivalent zu `try-with-resources` in Java;
  • Zeilen 116–117: Falsche Zugangsdaten: Der Server liefert die Antwort 401 Unauthorized; es wird eine Ausnahme ausgelöst, die [LoginPage] in eine Fehlermeldung umwandelt;
  • Zeilen 125–126: Zurück im aufrufenden Thread (dem Haupt-Thread) wird die Sitzung übernommen – wodurch sich der beobachtete Zustand ändert: Der Bildschirm wechselt automatisch zum Kalender – und anschließend in den Einstellungen gespeichert;
  • Zeilen 134–140: [logOut()] – verwirft die Sitzung, sowohl im Speicher als auch in den Einstellungen.

5.6.3. core/services/AppointmentService.kt

Portierung von [lib/core/services/appointment_service.dart]: eine Methode pro vom Client genutzter fachlicher Route.

// =========================================================================
// AppointmentService.kt
// -------------------------------------------------------------------------
// Port der lib/core/services/appointment_service.dart: eine Methode pro fachlicher
// Route des von diesem Client verwendeten NestJS-Servers. Jede Methode ist eine
// "suspend"-Funktion (siehe AuthService.logIn), die die Nutzdaten
// direkt zurückgibt ("data" des Umschlags {status, data}) oder
// eine Exception auslöst.
//
// Der im Konstruktor erhaltene HTTP-Client enthält AuthInterceptor (siehe
// RdvMedecinsApplication): Keine der folgenden Methoden muss sich daher
// um das JWT-Token kümmern.
//
// Dieser Service hat KEINEN beobachtbaren Zustand (nichts in ihm verändert sich nach dem Aufbau):
// Er ist eine gewöhnliche Klasse ohne mutableStateOf - das Gegenstück zum
// einfachen Provider.value(value: api) (und nicht ChangeNotifierProvider) der
// Flutter-Version.
// =========================================================================

package fr.rdvmedecins.client.core.services

import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.AddAppointmentRequest
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.ApiJson
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.models.AppointmentJson
import fr.rdvmedecins.client.core.models.DeleteAppointmentRequest
import fr.rdvmedecins.client.core.models.decodeResponse
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.json.JsonElement
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException

class AppointmentService(
    private val http: OkHttpClient,
    private val settings: SettingsService,
) {
    // -----------------------------------------------------------------------
    // die GET-Routen
    // -----------------------------------------------------------------------
    suspend fun getAllDoctors(): List<Doctor> =
        call(getRequest("/getAllDoctors"), ListSerializer(Doctor.serializer()))

    suspend fun getAllClients(): List<Client> =
        call(getRequest("/getAllClients"), ListSerializer(Client.serializer()))

    suspend fun getDoctorScheduleOfDay(doctorId: Int, day: String): DoctorDaySchedule =
        call(getRequest("/getDoctorScheduleOfDay/$doctorId/$day"), DoctorDaySchedule.serializer())

    // -----------------------------------------------------------------------
    // die POST-Routen (vom Server der Rolle ADMIN vorbehalten)
    // -----------------------------------------------------------------------
    suspend fun addAppointment(day: String, clientId: Int, slotId: Int): AppointmentJson {
        val body = ApiJson.encodeToString(
            AddAppointmentRequest.serializer(),
            AddAppointmentRequest(day, clientId, slotId),
        )
        return call(postRequest("/addAppointment", body), AppointmentJson.serializer())
    }

    suspend fun deleteAppointment(appointmentId: Int) {
        val body = ApiJson.encodeToString(DeleteAppointmentRequest.serializer(), DeleteAppointmentRequest(appointmentId))
        // "data" ist bei Erfolg null: Wir dekodieren es als beliebiges JSON-Element
        // und ignorieren es
        call(postRequest("/deleteAppointment", body), JsonElement.serializer())
    }

    // -----------------------------------------------------------------------
    // Aufbau der Anfragen
    // -----------------------------------------------------------------------
    private fun getRequest(path: String): Request =
        Request.Builder().url(settings.apiBaseUrl + path).get().build()

    private fun postRequest(path: String, jsonBody: String): Request =
        Request.Builder()
            .url(settings.apiBaseUrl + path)
            .post(jsonBody.toRequestBody(JSON_TYPE))
            .build()

    // -----------------------------------------------------------------------
    // führt eine Anfrage auf einem Ein-/Ausgabe-Thread aus und dekodiert die
    // Antwort {status, data}. Der generische Parameter <T> und der
    // dazugehörige [deserializer] geben an, in welchen Typ
    // "data" dekodiert wird - die Rolle des Parameters parseData der Flutter-Version.
    // -----------------------------------------------------------------------
    private suspend fun <T> call(request: Request, deserializer: DeserializationStrategy<T>): T =
        withContext(Dispatchers.IO) {
            http.newCall(request).execute().use { response ->
                // 401 (Token abgelehnt), 403 (unzureichende Rolle), 404...: Der
                // Body ist kein Umschlag {status, data}
                if (!response.isSuccessful) {
                    throw IOException("HTTP error ${response.code}")
                }
                decodeResponse(response.body!!.string(), deserializer)
            }
        }

    companion object {
        private val JSON_TYPE = "application/json; charset=utf-8".toMediaType()
    }
}

Kommentieren wir diesen Code:

  • Zeilen 48–55: die drei GET-Routen. Jede Methode ist eine als Ausdruck geschriebene [suspend]-Funktion: Sie erstellt die Anfrage und gibt den erwarteten Typ von [data] an. [ListSerializer(Doctor.serializer())] beschreibt eine [List<Doctor>];
  • Zeilen 60–72: die beiden POST-Routen: Der JSON-Body wird aus den Klassen [AddAppointmentRequest] und [DeleteAppointmentRequest] kodiert. Bei [/deleteAppointment] ist [data] im Erfolgsfall gleich [null] : Es wird als beliebiges JSON-Element dekodiert ([JsonElement.serializer()]) und ignoriert;
  • Zeilen 93–101: [call(...)] – die Standardmethode: in einem I/O-Thread ausgeführt, prüft sie den HTTP-Code (401 Token abgelehnt, 403 unzureichende Rolle: Der Body ist dann also kein [{status, data}]-Wrapper), anschließend dekodiert sie mit [decodeResponse(...)].

Dieser Service hat keinen beobachtbaren Zustand: Nach seiner Erstellung ändert sich nichts. Er ist eine gewöhnliche Klasse – das Äquivalent zum einfachen [Provider.value(value: api)] (nicht [ChangeNotifierProvider]) in der Flutter-Version.

5.7. Die Schicht core/http

5.7.1. core/http/AuthInterceptor.kt

Portierung von [lib/core/http/auth_http_client.dart]: Hinzufügen des JWT-Tokens zu jeder Anfrage und Abmeldung bei einer Antwort 401.

// =========================================================================
// AuthInterceptor.kt
// -------------------------------------------------------------------------
// Port der lib/core/http/auth_http_client.dart. Zwei Aufgaben,
// dieselben wie in allen Varianten dieses Kurses:
//   1. bei jeder Anfrage den Header "Authorization: Bearer <token>" hinzufügen;
//   2. den Benutzer abmelden, wenn der Server mit 401 Unauthorized antwortet
//      (abgelaufenes oder ungültiges Token).
//
// Die Flutter-Version verpackte den HTTP-Client in eine eigene Klasse,
// weil das http-Paket keinen Abfangmechanismus bietet. OkHttp hingegen
// bietet INTERCEPTORS: Objekte, durch die jede
// Anfrage vor dem Senden und jede Antwort vor der Rückgabe an den
// Aufrufer läuft - genau der Begriff des HTTP-Interceptors von Angular
// (auth.interceptor.ts in der Angular-Variante dieses Kurses).
// =========================================================================

package fr.rdvmedecins.client.core.http

import android.os.Handler
import android.os.Looper
import fr.rdvmedecins.client.core.services.AuthService
import okhttp3.Interceptor
import okhttp3.Response

class AuthInterceptor(private val auth: AuthService) : Interceptor {

    // ein an den Main-Thread gebundener Handler: Damit können wir ihm Arbeit
    // von einem anderen Thread übergeben (siehe intercept weiter unten)
    private val mainThread = Handler(Looper.getMainLooper())

    // wird von OkHttp für JEDE Anfrage auf einem Netzwerk-Thread aufgerufen
    override fun intercept(chain: Interceptor.Chain): Response {
        // 1. die ursprüngliche Anfrage, plus das Token, falls vorhanden. Eine
        //    OkHttp-Anfrage ist unveränderlich: newBuilder() erstellt eine
        //    veränderbare Kopie davon.
        val token = auth.accessToken
        val request = if (token == null) {
            chain.request()
        } else {
            chain.request().newBuilder()
                .header("Authorization", "Bearer $token")
                .build()
        }
        // 2. wir lassen die Anfrage ihren Weg zum Server fortsetzen
        val response = chain.proceed(request)
        // 3. Token abgelehnt: Wir melden den Benutzer ab. Diese Methode
        //    läuft auf einem Netzwerk-Thread; logOut() ändert jedoch
        //    den von der UI angezeigten Zustand: Daher übergeben wir diesen Aufruf an den
        //    Main-Thread (post), ohne auf seine Ausführung zu warten - das
        //    Gegenstück zum unawaited(auth.logOut()) der Flutter-Version.
        if (response.code == 401) {
            mainThread.post { auth.logOut() }
        }
        return response
    }
}

Kommentieren wir diesen Code:

  • Zeile 26: Die Klasse implementiert die Schnittstelle [okhttp3.Interceptor]. OkHttp leitet jede Anfrage vor dem Senden und jede Antwort vor der Rückgabe an den Aufrufer durch die Interceptoren des Clients: Das ist das Konzept der HTTP-Interceptoren von Angular. Die Flutter-Version, der ein solcher Mechanismus im Paket [http] fehlt, kapselte den HTTP-Client in einer eigenen Klasse;
  • Zeile 30: ein [Handler] , der dem Haupt-Thread zugeordnet ist ([Looper.getMainLooper()]): Damit lässt sich Arbeit aus einem anderen Thread an ihn delegieren;
  • Zeilen 41–43: Eine OkHttp-Anfrage ist UNVERÄNDERLICH; [newBuilder()] erstellt eine veränderbare Kopie davon, ergänzt um den Header [Authorization];
  • Zeile 46: [chain.proceed(request)] – die Anfrage wird zum Server weitergeleitet; die Methode gibt die Antwort zurück;
  • Zeilen 52–53: Token abgelehnt (401): [intercept] läuft in einem Netzwerk-Thread, aber [logOut()] ändert den angezeigten Zustand. Der Aufruf wird daher an den Haupt-Thread delegiert ([post { ... }]), ohne auf seine Ausführung zu warten – das Pendant zu [unawaited(auth.logOut())] in der Flutter-Version.

5.8. Die Schicht core/i18n

5.8.1. core/i18n/TranslationsService.kt

Portierung von [lib/core/i18n/translations_service.dart]: Umschalten der Oberfläche zwischen Französisch und Englisch zur Laufzeit.

// =========================================================================
// TranslationsService.kt
// -------------------------------------------------------------------------
// Port der lib/core/i18n/translations_service.dart: Umschalten der UI zwischen
// Französisch und Englisch, im laufenden Betrieb, ohne Neustart der
// Anwendung. Die Wörterbücher sind DIESELBEN JSON-Dateien wie die
// der Flutter- und Vue.js-Clients dieses Kurses (fr.json, en.json), hier abgelegt
// in app/src/main/assets/i18n/: Der Ordner assets/ eines Android-Projekts wird
// unverändert in die Anwendung (die .apk-Datei) eingebettet, wie die
// in der pubspec.yaml der Flutter-Version deklarierten Assets.
//
// Hinweis: Der "offizielle" Android-Weg zur Übersetzung einer
// Anwendung beruht auf den Ressourcendateien res/values/strings.xml
// (Englisch) und res/values-fr/strings.xml (Französisch), wobei das System
// die passende Datei anhand der Sprache des SMARTPHONES wählt. Dieses Dokument
// behält die von allen Varianten des Kurses gemeinsam genutzten JSON-Wörterbücher
// und den FR/EN-Umschalter innerhalb der Anwendung selbst bei, wie
// die ursprüngliche Anwendung (2014).
// =========================================================================

package fr.rdvmedecins.client.core.i18n

import android.content.SharedPreferences
import android.content.res.AssetManager
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
import fr.rdvmedecins.client.core.models.ApiJson
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject

class TranslationsService(
    private val assets: AssetManager,
    private val prefs: SharedPreferences,
) {
    // die angezeigte Sprache: ein Compose-Zustand. Da t(...) weiter unten
    // diese Property LIEST, wird jeder mit t(...) angezeigte Text bei einem Sprachwechsel automatisch
    // neu angezeigt - anders als in der Flutter-Version muss kein context.watch<...>()
    // geschrieben werden.
    var currentLanguage by mutableStateOf(prefs.getString(LANGUAGE_KEY, null) ?: DEFAULT_LANGUAGE)
        private set

    // die bereits geladenen Wörterbücher, nach Sprache ("fr" -> {...})
    private val dictionaries = mutableMapOf<String, JsonObject>()

    fun changeLanguage(language: String) {
        if (language == currentLanguage) {
            return
        }
        dictionary(language) // lädt das Wörterbuch, BEVOR die Sprache geändert wird
        currentLanguage = language
        prefs.edit { putString(LANGUAGE_KEY, language) }
    }

    // -----------------------------------------------------------------------
    // t("LOGIN.TITLE"): durchläuft das Wörterbuch der aktuellen Sprache
    // Segment für Segment ("LOGIN", dann "TITLE"). Wird der Schlüssel
    // nicht gefunden, wird der Schlüssel selbst zurückgegeben: Der fehlende Text bleibt so
    // auf dem Bildschirm sichtbar, ohne die Anwendung abstürzen zu lassen.
    // -----------------------------------------------------------------------
    fun t(key: String): String {
        var currentValue: JsonElement = dictionary(currentLanguage)
        for (segment in key.split('.')) {
            currentValue = (currentValue as? JsonObject)?.get(segment) ?: return key
        }
        val primitive = currentValue as? JsonPrimitive
        return if (primitive != null && primitive.isString) primitive.content else key
    }

    // -----------------------------------------------------------------------
    // das Wörterbuch einer Sprache, beim ersten Bedarf geladen und dann im
    // Speicher gehalten. getOrPut: gibt den dem Schlüssel zugeordneten Wert zurück oder führt
    // den Block aus, speichert dessen Ergebnis und gibt es zurück. Das Lesen ist
    // synchron: Die beiden Dateien sind nur einige hundert
    // Bytes groß, ihr Lesen erfolgt augenblicklich.
    // -----------------------------------------------------------------------
    private fun dictionary(language: String): JsonObject =
        dictionaries.getOrPut(language) {
            assets.open("i18n/$language.json").bufferedReader().use { reader ->
                ApiJson.parseToJsonElement(reader.readText()).jsonObject
            }
        }

    companion object {
        private const val LANGUAGE_KEY = "rdvmedecins.language"
        private val DEFAULT_LANGUAGE = if (java.util.Locale.getDefault().language == "fr") "fr" else "en"
    }
}

Kommentieren wir diesen Code:

  • Zeilen 43–44: [currentLanguage] – ein beobachtbarer Zustand. Da [t(...)] diese Eigenschaft LIEST, wird jede @Composable-Funktion, die Text mit [t(...)] anzeigt, bei einem Sprachwechsel automatisch neu zusammengesetzt: Es muss kein [context.watch<...>()] geschrieben werden;
  • Zeilen 49–55: [changeLanguage(...)] – lädt das Wörterbuch, BEVOR die Sprache umgeschaltet wird, und speichert dann die Auswahl in den Einstellungen;
  • Zeilen 64–70: [t("LOGIN.TITLE")] – durchläuft das Wörterbuch Segment für Segment. [as?] ist die „sichere“ Typumwandlung von Kotlin: Sie liefert [null] (statt eine Ausnahme auszulösen), wenn das Objekt nicht den verlangten Typ hat; in Kombination mit [?: return key] führt das dazu, dass der Schlüssel selbst zurückgegeben wird, sobald ein Segment nicht gefunden wird – der fehlende Text bleibt auf dem Bildschirm sichtbar;
  • Zeilen 80–83: [dictionary(language)] – [getOrPut] liefert das bereits geladene Wörterbuch oder führt den Block aus (Lesen von [assets/i18n/<language>.json]), speichert dessen Ergebnis und gibt es zurück. Das Lesen erfolgt synchron: Beide Dateien sind nur wenige hundert Bytes groß.

5.8.2. assets/i18n/fr.json und assets/i18n/en.json

Die Wörterbücher stammen aus den Clients Flutter und Vue.js, mit vier kleinen Anpassungen: der Titel der App, die Beschriftungen der Datumsauswahl ([DOCTOR_DAY_PICKER.PICK_DAY], [OK], [CANCEL]), die Aufforderungsmeldung des Kalenders („tippen“ statt „klicken“) und die Entfernung eines nicht mehr benötigten Schlüssels. Auszug aus [fr.json]:

{
  "APP": {
    "TITLE": "RdvMedecins - Kotlin / Android",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "SUBMITTING": "Connexion...",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
    "DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
    "DEMO_ACCOUNTS_OR": "ou",
    "DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Médecin",
    "CHOOSE_DOCTOR": "-- choisir un médecin --",
    "DAY_LABEL": "Jour",
    "VIEW_SCHEDULE": "Voir l'agenda",
    "PICK_DAY": "Choisir le jour",
    "OK": "OK",
    "CANCEL": "Annuler"
  },

Hinweis: Die „offizielle“ Methode von Android zur Übersetzung einer App beruht auf den Ressourcendateien [res/values/strings.xml] (Englisch) und [res/values-fr/strings.xml] (Französisch), wobei das System anhand der Sprache des SMARTPHONES die passende Datei auswählt. Dieses Dokument behält die allen Varianten des Kurses gemeinsamen JSON-Wörterbücher und den FR/EN-Sprachwechsel innerhalb der App bei, genau wie die ursprüngliche App (2014). Eine spürbare Folge: Vom System bereitgestellte Komponenten wie die Datumsauswahl folgen der Spracheinstellung des Smartphones und nicht der in der App gewählten Sprache.

5.9. Die Schicht core/ui

5.9.1. core/ui/DropdownList.kt

Eine generische Dropdown-Liste, die zweimal verwendet wird: zur Auswahl eines Arztes und zur Auswahl eines Patienten. Flutter hatte dafür ein fertiges Widget, [DropdownButtonFormField]; Material 3 für Compose bietet eine Kombination aus drei Elementen, die hier ein für alle Mal zusammengefasst werden.

// =========================================================================
// DropdownList.kt
// -------------------------------------------------------------------------
// Eine generische Dropdown-Liste (das <select> von HTML), die in diesem Client zweimal
// verwendet wird: Auswahl des Arztes (DoctorDayPicker) und Auswahl des Patienten
// (BookingDialog). Die Flutter-Version hatte dafür ein fertiges Widget,
// DropdownButtonFormField; Material 3 für Compose bietet eine
// Zusammenstellung aus drei Elementen - ExposedDropdownMenuBox, einem schreibgeschützten
// Textfeld und dem Menü ExposedDropdownMenu -, die wir hier
// ein für alle Mal bündeln.
//
// Die Funktion ist GENERISCH (<T>): Sie zeigt eine Liste von Ärzten
// ebenso an wie eine Liste von Patienten. [itemLabel] gibt an, wie ein Element angezeigt wird,
// [idOf], wie es identifiziert wird.
// =========================================================================

package fr.rdvmedecins.client.core.ui

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.ExposedDropdownMenuAnchorType
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

// die ExposedDropdownMenu*-APIs sind in Material 3 noch als "experimental" markiert:
// @OptIn legt fest, dass wir sie bewusst verwenden
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun <T> DropdownList(
    label: String,
    placeholder: String,     // Text, der angezeigt wird, solange nichts ausgewählt ist
    items: List<T>,
    selectedId: Int?,        // id des ausgewählten Elements oder null
    idOf: (T) -> Int,
    itemLabel: (T) -> String,
    onSelect: (Int) -> Unit,
    modifier: Modifier = Modifier,
) {
    // Menü geöffnet oder geschlossen: ein LOKALER Zustand dieser Funktion, der von einer Anzeige zur nächsten
    // durch remember gemerkt wird (siehe Kapitel 3)
    var menuOpen by remember { mutableStateOf(false) }
    val selected = items.firstOrNull { idOf(it) == selectedId }

    ExposedDropdownMenuBox(
        expanded = menuOpen,
        onExpandedChange = { menuOpen = it },
        modifier = modifier,
    ) {
        // das Feld, das die aktuelle Auswahl anzeigt; menuAnchor(...) macht es zum
        // Ankerpunkt des Menüs (ein Klick darauf öffnet das Menü)
        OutlinedTextField(
            value = selected?.let(itemLabel) ?: "",
            onValueChange = {},
            readOnly = true,
            singleLine = true,
            label = { Text(label) },
            placeholder = { Text(placeholder) },
            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = menuOpen) },
            modifier = Modifier
                .menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable)
                .fillMaxWidth(),
        )
        // das Menü selbst: ein DropdownMenuItem pro Element
        ExposedDropdownMenu(expanded = menuOpen, onDismissRequest = { menuOpen = false }) {
            items.forEach { item ->
                DropdownMenuItem(
                    text = { Text(itemLabel(item)) },
                    onClick = {
                        onSelect(idOf(item))
                        menuOpen = false
                    },
                )
            }
        }
    }
}

Zerlegen wir diesen Code:

  • Zeilen 38–46: [fun <T> DropdownList(...)] – eine GENERISCHE @Composable-Funktion: Sie zeigt sowohl Ärzte als auch Patienten an. [idOf] legt fest, wie ein Element identifiziert wird, [itemLabel] wie es angezeigt wird, und [onSelect] meldet den gewählten Bezeichner;
  • Zeile 46: [modifier: Modifier = Modifier] – die Compose-Konvention: Jede wiederverwendbare Komponente akzeptiert einen Modifier, der auf ihr Wurzelelement angewendet wird, damit der Aufrufer Größe oder Abstände anpassen kann;
  • Zeile 50: [var menuOpen by remember { mutableStateOf(false) }] – der lokale Zustand der Komponente: Menü geöffnet oder geschlossen;
  • Zeile 53: [ExposedDropdownMenuBox] – der Container, der das Öffnen und Schließen des Menüs verwaltet;
  • Zeilen 60–69: das schreibgeschützte Feld, das die aktuelle Auswahl anzeigt. [menuAnchor(...)] dient als Ankerpunkt des Menüs: Ein Tippen darauf öffnet das Menü;
  • Zeilen 73–79: das Menü selbst: ein [DropdownMenuItem] pro Element, erzeugt in einer [forEach]-Schleife.

5.10. Die Schicht features

Wie in allen Versionen des Kurses ist jede Funktion des Bildschirms eine Komponente: Sie erhält ihre Daten als Parameter (Eingaben) und meldet Benutzeraktionen über Funktionen (Ausgaben). Nur [LoginPage] ruft direkt einen Service auf ([AuthService]).

5.10.1. features/login/LoginPage.kt

Portierung von [lib/features/login/login_page.dart]: der Anmeldebildschirm.

// =========================================================================
// LoginPage.kt
// -------------------------------------------------------------------------
// Port der lib/features/login/login_page.dart: der Anmeldebildschirm
// (Login, Passwort, Button "Log in", Fehlermeldung).
//
// Die Flutter-Version benötigte ZWEI Klassen (_LoginForm und
// _LoginFormState) und zwei TextEditingControllers, die in
// dispose() freizugeben waren. Hier genügt eine einzige @Composable-Funktion: Ihre lokalen Zustände
// werden direkt in der Funktion deklariert, mit remember / rememberSaveable.
// =========================================================================

package fr.rdvmedecins.client.features.login

import android.util.Log
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
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.widthIn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Surface
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.rememberCoroutineScope
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.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalAuth
import fr.rdvmedecins.client.core.LocalTranslations
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.launch

@Composable
fun LoginPage() {
    val auth = LocalAuth.current
    val t = LocalTranslations.current::t

    // ––– lokaler Zustand des Bildschirms –––
    // rememberSaveable: Der Wert wird von einer Anzeige zur nächsten gemerkt
    // UND überlebt die Neuerstellung der Activity (Bildschirmdrehung) - ein
    // halb eingetippter Login geht nicht verloren, wenn das Smartphone gedreht wird.
    var login by rememberSaveable { mutableStateOf("") }
    var password by rememberSaveable { mutableStateOf("") }
    // der Übersetzungsschlüssel der Fehlermeldung (und nicht die übersetzte Meldung:
    // So folgt sie einem Sprachwechsel), oder null
    var error by rememberSaveable { mutableStateOf<String?>(null) }
    // nur remember: Eine laufende Anmeldung muss eine Drehung nicht überleben
    var inProgress by remember { mutableStateOf(false) }

    // ein an diesen Bildschirm gebundener Coroutine-Scope: Die darin
    // gestarteten Coroutinen werden abgebrochen, wenn der Bildschirm verschwindet
    val scope = rememberCoroutineScope()

    // eine lokale Funktion (siehe den Kotlin-Kurs): die Validierung des
    // Formulars, aufgerufen vom Button UND von der Taste "Done" der Tastatur
    fun submit() {
        if (login.isBlank() || password.isEmpty() || inProgress) {
            return
        }
        error = null
        inProgress = true
        scope.launch {
            try {
                // bei Erfolg setzt AuthService isLoggedIn auf true:
                // App.kt ersetzt dann AUTOMATISCH diesen Bildschirm durch
                // den Terminkalender - hier ist nichts weiter zu tun
                auth.logIn(login.trim(), password)
            } catch (e: CancellationException) {
                throw e
            } catch (e: Exception) {
                // die genaue Ursache (Server nicht erreichbar, falsche Zugangsdaten...)
                // wird in das Android-Log geschrieben (Registerkarte Logcat von Android
                // Studio); der Benutzer sieht eine einfache Meldung
                Log.w("RdvMedecins", "login failed", e)
                error = "LOGIN.ERROR"
            } finally {
                inProgress = false
            }
        }
    }

    // Box + Alignment.TopCenter: Die Karte wird horizontal zentriert
    Box(modifier = Modifier.fillMaxWidth(), contentAlignment = Alignment.TopCenter) {
        Card(modifier = Modifier.widthIn(max = 420.dp).fillMaxWidth()) {
            Column(
                modifier = Modifier.padding(24.dp),
                verticalArrangement = Arrangement.spacedBy(12.dp),
            ) {
                Text(t("LOGIN.TITLE"), style = MaterialTheme.typography.titleLarge)

                error?.let { key ->
                    Surface(
                        color = MaterialTheme.colorScheme.errorContainer,
                        contentColor = MaterialTheme.colorScheme.onErrorContainer,
                        shape = RoundedCornerShape(4.dp),
                        modifier = Modifier.fillMaxWidth(),
                    ) {
                        Text(t(key), modifier = Modifier.padding(8.dp))
                    }
                }

                OutlinedTextField(
                    value = login,
                    onValueChange = { login = it },
                    label = { Text(t("LOGIN.LOGIN_LABEL")) },
                    singleLine = true,
                    // Taste "Next" der Tastatur: wechselt zum nächsten Feld
                    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
                    modifier = Modifier.fillMaxWidth(),
                )

                OutlinedTextField(
                    value = password,
                    onValueChange = { password = it },
                    label = { Text(t("LOGIN.PASSWORD_LABEL")) },
                    singleLine = true,
                    // zeigt Punkte statt der Zeichen an
                    visualTransformation = PasswordVisualTransformation(),
                    keyboardOptions = KeyboardOptions(
                        keyboardType = KeyboardType.Password,
                        imeAction = ImeAction.Done,
                    ),
                    // Taste "Done" der Tastatur: sendet das Formular ab
                    keyboardActions = KeyboardActions(onDone = { submit() }),
                    modifier = Modifier.fillMaxWidth(),
                )

                Spacer(Modifier.height(4.dp))
                Button(
                    onClick = { submit() },
                    enabled = !inProgress,
                    modifier = Modifier.fillMaxWidth(),
                ) {
                    Text(if (inProgress) t("LOGIN.SUBMITTING") else t("LOGIN.SUBMIT"))
                }

                Text(
                    text = "${t("LOGIN.DEMO_ACCOUNTS_PREFIX")} admin / admin ${t("LOGIN.DEMO_ACCOUNTS_ADMIN")} " +
                        "${t("LOGIN.DEMO_ACCOUNTS_OR")} user / user ${t("LOGIN.DEMO_ACCOUNTS_USER")}.",
                    style = MaterialTheme.typography.bodySmall,
                )
            }
        }
    }
}

Kommentieren wir diesen Code:

  • Zeilen 60–66: die lokalen Zustände des Bildschirms. [rememberSaveable] für Benutzernamen, Passwort und Fehlermeldung: Diese Zustände bleiben bei einer Bildschirmdrehung erhalten. [remember] wird nur für [inProgress] verwendet: Eine laufende Anmeldung muss sie nicht überleben;
  • Zeile 70: [rememberCoroutineScope()] – ein diesem Bildschirm zugeordneter Coroutine-Scope: Darin gestartete Coroutinen werden abgebrochen, wenn der Bildschirm verschwindet;
  • Zeile 74: [fun submit()] – eine LOKALE Funktion (in einer anderen Funktion deklariert; siehe den Kotlin-Kurs), die vom Button und von der Taste „Fertig“ der Tastatur aufgerufen wird;
  • Zeilen 80–93: [scope.launch { ... }] startet die Anmeldung in einer Coroutine. Bei Erfolg ist nichts weiter zu tun: [AuthService] setzt [isLoggedIn] auf [true], und [App.kt] ersetzt diesen Bildschirm AUTOMATISCH durch den Terminkalender. Schlägt die Operation fehl, wird der SCHLÜSSEL der Fehlermeldung gespeichert (nicht die übersetzte Meldung: So bleibt sie bei einem Sprachwechsel konsistent);
  • Zeile 92: [Log.w(...)] – die genaue Ursache des Fehlschlags (nicht erreichbarer Server, falsche Zugangsdaten usw.) wird im Android-Log festgehalten, genauer im Tab [Logcat] von Android Studio. Dank dieses Logs wurde das in Kapitel 5 beschriebene Problem mit der Adresse [10.0.2.2] diagnostiziert;
  • Zeilen 120–122: [OutlinedTextField(value = login, onValueChange = { login = it }, ...)] – das Feld zeigt den Zustand an und aktualisiert ihn bei jedem Tastenanschlag: [v-model] aus Vue.js, in zwei Teile aufgeteilt;
  • Zeile 126: [ImeAction.Next] – die Taste „Weiter“ der virtuellen Tastatur springt zum nächsten Feld;
  • Zeilen 136–142: das Passwort: [PasswordVisualTransformation()] zeigt Punkte anstelle der Zeichen an; [KeyboardType.Password] deaktiviert die Tastaturvorschläge; [onDone] sendet das Formular ab;
  • Zeilen 147–152: der Button, der während der Anmeldung deaktiviert ist ([enabled = !inProgress]) und die Beschriftung „Anmeldung läuft ...“ trägt.

5.10.2. features/doctordaypicker/DoctorDayPicker.kt

Portierung von [lib/features/doctor_day_picker/doctor_day_picker.dart]: Auswahl des Arztes und des Tages.

// =========================================================================
// DoctorDayPicker.kt
// -------------------------------------------------------------------------
// Port der lib/features/doctor_day_picker/doctor_day_picker.dart: die
// Auswahl eines Arztes (Dropdown-Liste) und eines Tages (Kalender), dann der
// Button "View schedule".
//
// Diese Komponente kennt weder den Server noch AppointmentService: Sie erhält die Liste
// der Ärzte als PARAMETER (Eingabe) und meldet die Wahl des Benutzers
// über die Funktion onSearch (Ausgabe) - derselbe Vertrag wie in allen
// Varianten des Kurses (props/emit in Vue.js, Konstruktor-Parameter
// in Flutter).
// =========================================================================

package fr.rdvmedecins.client.features.doctordaypicker

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.OutlinedTextField
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.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.Doctor
import fr.rdvmedecins.client.core.ui.DropdownList
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun DoctorDayPicker(
    doctors: List<Doctor>,
    onSearch: (doctorId: Int, day: String) -> Unit,
) {
    val t = LocalTranslations.current::t

    // ––– lokaler Zustand, über Bildschirmdrehungen hinweg erhalten –––
    var doctorId by rememberSaveable { mutableStateOf<Int?>(null) }
    // der gewählte Tag im Format "yyyy-MM-dd": LocalDate.toString() erzeugt
    // genau dieses Format (ISO 8601), das der Server erwartet - das Paket intl
    // der Flutter-Version wird nicht mehr benötigt
    var day by rememberSaveable { mutableStateOf(LocalDate.now().toString()) }
    var calendarOpen by remember { mutableStateOf(false) }

    // die drei Elemente der Komponente, einmal vorbereitet und dann je nach verfügbarer Breite
    // unterschiedlich angeordnet (siehe unten). Es sind
    // @Composable-LAMBDAS: Sie werden nur ANGEZEIGT, wenn sie aufgerufen werden.
    val doctorField = @Composable { modifier: Modifier ->
        DropdownList(
            label = t("DOCTOR_DAY_PICKER.DOCTOR_LABEL"),
            placeholder = t("DOCTOR_DAY_PICKER.CHOOSE_DOCTOR"),
            items = doctors,
            selectedId = doctorId,
            idOf = { it.id },
            itemLabel = { "${it.title} ${it.firstName} ${it.lastName}" },
            onSelect = { doctorId = it },
            modifier = modifier,
        )
    }
    val dayField = @Composable { modifier: Modifier ->
        OutlinedTextField(
            value = day,
            onValueChange = {},
            readOnly = true,
            singleLine = true,
            label = { Text(t("DOCTOR_DAY_PICKER.DAY_LABEL")) },
            // das Kalender-Icon öffnet den Datumsauswahl-Dialog
            trailingIcon = {
                IconButton(onClick = { calendarOpen = true }) {
                    Icon(Icons.Filled.DateRange, contentDescription = t("DOCTOR_DAY_PICKER.PICK_DAY"))
                }
            },
            modifier = modifier,
        )
    }
    val scheduleButton = @Composable { modifier: Modifier ->
        Button(
            // Button deaktiviert, solange kein Arzt ausgewählt ist
            enabled = doctorId != null,
            onClick = { doctorId?.let { onSearch(it, day) } },
            modifier = modifier,
        ) {
            Text(t("DOCTOR_DAY_PICKER.VIEW_SCHEDULE"))
        }
    }

    Card(modifier = Modifier.fillMaxWidth()) {
        // BoxWithConstraints: gibt Zugriff auf die TATSÄCHLICH
        // verfügbare Breite (maxWidth) - der LayoutBuilder der Flutter-Version.
        // Schmaler Bildschirm (Smartphone im Hochformat): die drei Elemente untereinander;
        // breiter Bildschirm: in einer einzigen Zeile.
        BoxWithConstraints(modifier = Modifier.padding(16.dp)) {
            if (maxWidth < 600.dp) {
                Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
                    doctorField(Modifier.fillMaxWidth())
                    dayField(Modifier.fillMaxWidth())
                    scheduleButton(Modifier.fillMaxWidth())
                }
            } else {
                Row(
                    horizontalArrangement = Arrangement.spacedBy(12.dp),
                    verticalAlignment = Alignment.CenterVertically,
                ) {
                    // weight(...): verteilt die Breite auf die drei
                    // Elemente (5/12, 4/12, 3/12) - das flex: 5, 4, 3 des
                    // Expanded der Flutter-Version
                    doctorField(Modifier.weight(5f))
                    dayField(Modifier.weight(4f))
                    scheduleButton(Modifier.weight(3f))
                }
            }
        }
    }

    // der Kalender: ein Dialog, der angezeigt wird, solange
    // calendarOpen true ist (dasselbe Prinzip wie BookingDialog)
    if (calendarOpen) {
        // DatePicker arbeitet in Millisekunden seit dem 1. Januar 1970,
        // um Mitternacht UTC: Wir konvertieren in beide Richtungen mit java.time
        val state = rememberDatePickerState(
            initialSelectedDateMillis = LocalDate.parse(day)
                .atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
        )
        DatePickerDialog(
            onDismissRequest = { calendarOpen = false },
            confirmButton = {
                TextButton(onClick = {
                    state.selectedDateMillis?.let { millis ->
                        day = Instant.ofEpochMilli(millis).atZone(ZoneOffset.UTC).toLocalDate().toString()
                    }
                    calendarOpen = false
                }) { Text(t("DOCTOR_DAY_PICKER.OK")) }
            },
            dismissButton = {
                TextButton(onClick = { calendarOpen = false }) {
                    Text(t("DOCTOR_DAY_PICKER.CANCEL"))
                }
            },
        ) {
            DatePicker(state = state)
        }
    }
}

Kommentieren wir diesen Code:

  • Zeilen 54–56: die Ein- und Ausgaben der Komponente: die Liste der Ärzte und die Funktion [onSearch(doctorId, day)]. Die Namen, die den Parametern des Funktionstyps gegeben werden ([doctorId: Int, day: String]), dienen nur der Dokumentation;
  • Zeile 65: der gewählte Tag, im Format [yyyy-MM-dd] gespeichert: [LocalDate.now().toString()] erzeugt genau dieses Format (ISO 8601), das der Server erwartet. Das Paket [intl] aus der Flutter-Version wird nicht mehr benötigt;
  • Zeilen 71–99: die drei Elemente der Komponente, als @Composable-LAMBDAS vorbereitet ([@Composable { modifier: Modifier -> ... }]): Sie werden erst beim Aufruf angezeigt, mit dem gewünschten Modifier. So lassen sie sich auf zwei verschiedene Arten anordnen, ohne ihren Code zweimal schreiben zu müssen;
  • Zeilen 91–93: das Feld für den Tag, das schreibgeschützt ist; das Kalendersymbol rechts öffnet die Datumsauswahl;
  • Zeilen 115–132: [BoxWithConstraints] liefert Zugriff auf die verfügbare Breite ([maxWidth]) – der [LayoutBuilder] der Flutter-Version. Unter 600 dp: die drei Elemente untereinander gestapelt ([Column]); andernfalls in einer einzigen Zeile ([Row]) mit den Gewichten 5/4/3 ([Modifier.weight(...)], in den Flutter-Versionen [Expanded(flex: ...)]);
  • Zeilen 140–163: die Datumsauswahl: ein [DatePickerDialog] , der angezeigt wird, solange [calendarOpen] gleich [true] ist. Der [DatePicker] von Material 3 arbeitet mit Millisekunden seit Mitternacht des 1. Januar 1970 (UTC): Die Umrechnung funktioniert in beide Richtungen mit [java.time] ([atStartOfDay(ZoneOffset.UTC)] und [Instant.ofEpochMilli(...)]).

5.10.3. features/schedule/ScheduleView.kt

Portierung von [lib/features/schedule/schedule_view.dart]: der Tageskalender eines Arztes.

// =========================================================================
// ScheduleView.kt
// -------------------------------------------------------------------------
// Port der lib/features/schedule/schedule_view.dart: die Anzeige des
// Terminkalenders eines Arztes für einen Tag - eine Zeile pro Zeitfenster, frei oder
// belegt, mit einem Button "Book" (freies Zeitfenster) oder "Cancel" (belegtes
// Zeitfenster) für die Rolle ADMIN.
//
// Wie DoctorDayPicker ist diese Komponente "zustandslos": Alles, was sie
// anzeigt, wird ihr als Parameter übergeben, und sie meldet die Klicks über
// onBook / onCancel. Es ist AppViewModel, das den Server aufruft.
// =========================================================================

package fr.rdvmedecins.client.features.schedule

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.DoctorDaySchedule
import fr.rdvmedecins.client.core.models.DoctorDaySlot
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.models.AppointmentJson

// Breite der Zeitspalte ("10:40 - 11:00")
private val TIME_COLUMN_WIDTH = 116.dp

// "8:00", "8:20"...: die Minuten immer zweistellig
private fun formatTime(h: Int, m: Int): String = "$h:${m.toString().padStart(2, '0')}"

@Composable
fun ScheduleView(
    schedule: DoctorDaySchedule?,
    canEdit: Boolean,
    onBook: (SlotJson) -> Unit,
    onCancel: (AppointmentJson) -> Unit,
) {
    val t = LocalTranslations.current::t

    // noch kein Terminkalender: eine einfache Aufforderung
    if (schedule == null) {
        Text(
            text = t("SCHEDULE.EMPTY_STATE"),
            color = MaterialTheme.colorScheme.outline,
            modifier = Modifier.padding(vertical = 24.dp),
        )
        return // eine @Composable-Funktion kann hier abbrechen: Es wird nichts weiter angezeigt
    }

    Card(modifier = Modifier.fillMaxWidth()) {
        Column(modifier = Modifier.padding(16.dp)) {
            val doctor = schedule.doctor
            Text(
                text = "${t("SCHEDULE.TITLE_PREFIX")} ${schedule.day} - ${doctor.title} ${doctor.firstName} ${doctor.lastName}",
                style = MaterialTheme.typography.titleMedium,
            )
            // Spaltenüberschriften: dieselbe Breite der ersten Spalte wie
            // in jeder Zeile (TIME_COLUMN_WIDTH), damit die Spalten
            // ausgerichtet sind
            Row(modifier = Modifier.fillMaxWidth().padding(top = 12.dp, bottom = 4.dp)) {
                Text(t("SCHEDULE.COLUMN_SLOT"), fontWeight = FontWeight.Bold, modifier = Modifier.width(TIME_COLUMN_WIDTH))
                Spacer(Modifier.width(8.dp)) // der Abstand zwischen den Spalten der Zeilen
                Text(t("SCHEDULE.COLUMN_STATUS"), fontWeight = FontWeight.Bold)
            }
            HorizontalDivider()
            // eine Zeile pro Zeitfenster. Eine einfache forEach-Schleife in einer
            // Column: hier keine LazyColumn (die "Lazy"-Liste von Compose,
            // die nur die sichtbaren Zeilen aufbaut), weil dieser
            // Terminkalender bereits in einer scrollbaren Column liegt (siehe App.kt)
            // und ein Dutzend Zeilen diese Optimierung nicht rechtfertigt.
            schedule.slots.forEach { daySlot ->
                SlotRow(daySlot, canEdit, onBook, onCancel)
                HorizontalDivider()
            }
        }
    }
}

// -------------------------------------------------------------------------
// eine Zeile des Terminkalenders: Zeit | Status (frei oder Patient) | Button
// -------------------------------------------------------------------------
@Composable
private fun SlotRow(
    daySlot: DoctorDaySlot,
    canEdit: Boolean,
    onBook: (SlotJson) -> Unit,
    onCancel: (AppointmentJson) -> Unit,
) {
    val t = LocalTranslations.current::t
    val slot = daySlot.slot
    val appointment = daySlot.appointment

    Row(
        modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        // die Zeit: eine feste Breite, dieselbe wie die der Kopfzeile
        Text(
            text = "${formatTime(slot.startHour, slot.startMinute)} - ${formatTime(slot.endHour, slot.endMinute)}",
            modifier = Modifier.width(TIME_COLUMN_WIDTH),
        )
        // der Status: ein grünes Badge "Free" oder der Name des Patienten
        Surface(
            shape = RoundedCornerShape(8.dp),
            color = if (appointment == null) Color(0xFFC8E6C9) else MaterialTheme.colorScheme.secondaryContainer,
            // weight(1f): Der Status nimmt die gesamte vom Zeit- und Button-Bereich
            // freigelassene Breite ein
            modifier = Modifier.weight(1f),
        ) {
            val client = appointment?.client
            Text(
                text = if (appointment == null) t("SCHEDULE.FREE") else "${client?.title ?: ""} ${client?.firstName ?: ""} ${client?.lastName ?: ""}",
                style = MaterialTheme.typography.bodyMedium,
                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
            )
        }
        // der Button existiert nur für die Rolle ADMIN; er bucht ein freies
        // Zeitfenster oder storniert den Termin eines belegten Zeitfensters
        if (canEdit) {
            // KEIN weight(...) hier: Der Button nimmt die Breite seines Textes ein.
            // Eine erste Version erzwang für ihn ein Viertel der Zeile
            // (weight(0.25f)): Auf einem Smartphone im Hochformat wurde die Beschriftung
            // "Réserver" (französische UI) dann zu "Rése" abgeschnitten (siehe Kapitel 5).
            OutlinedButton(
                onClick = { if (appointment == null) onBook(slot) else onCancel(appointment) },
                // verringertes inneres Padding (standardmäßig 24 dp auf jeder Seite)
                contentPadding = PaddingValues(horizontal = 12.dp),
                // eine gemeinsame Mindestbreite: Die Buttons "Book" und
                // "Cancel" haben so dieselbe Breite, und die Spalten bleiben
                // von Zeile zu Zeile ausgerichtet
                modifier = Modifier.widthIn(min = 96.dp),
            ) {
                Text(if (appointment == null) t("SCHEDULE.BOOK") else t("SCHEDULE.CANCEL_APPOINTMENT"), maxLines = 1)
            }
        }
    }
}

Kommentieren wir diesen Code:

  • Zeilen 60–66: noch kein Kalender – eine Aufforderungsmeldung, gefolgt von [return]. Eine @Composable-Funktion darf hier enden: Es wird nichts weiter ausgegeben;
  • Zeilen 79–82: die Spaltenköpfe: Die erste Spalte hat dieselbe feste Breite ([TIME_COLUMN_WIDTH]) wie die Uhrzeit in jeder Zeile, damit die Spalten ausgerichtet sind. Compose hat kein Äquivalent zu [DataTable] von Flutter: Die Tabelle wird mit [Row] aufgebaut;
  • Zeilen 90–91: eine Zeile pro Slot, mit einer einfachen [forEach] -Schleife in einer [Column]. Keine [LazyColumn] (die „Lazy“-Liste von Compose, die nur die sichtbaren Zeilen aufbaut): Der Kalender befindet sich bereits in einer scrollbaren Spalte (siehe [App.kt]) – eine [LazyColumn] in einer scrollbaren Spalte führt tatsächlich zu einem Laufzeitfehler – und ein Dutzend Zeilen rechtfertigen diese Optimierung nicht;
  • Zeilen 122–128: der Status: ein grünes Badge „Frei“ oder der Name des Patienten. [Modifier.weight(1f)]: Der Status nimmt die gesamte Breite ein, Uhrzeit und Button frei lassen;
  • Zeilen 139–151: der Button, nur für die Rolle ADMIN ([if (canEdit)]): „Buchen“ bei einem freien Slot, „Stornieren“ bei einem gebuchten Slot. Er hat keine feste Breite: Er nimmt die Breite seines Textes ein, mit einer gemeinsamen Mindestbreite. Eine frühere Version begrenzte ihn auf ein Viertel der Zeile: Auf einem Smartphone im Hochformat wurde die Beschriftung dann abgeschnitten (siehe Kapitel 5).

5.10.4. features/bookingdialog/BookingDialog.kt

Portierung von [lib/features/booking_dialog/booking_dialog.dart]: das Buchungsdialogfeld.

// =========================================================================
// BookingDialog.kt
// -------------------------------------------------------------------------
// Port der lib/features/booking_dialog/booking_dialog.dart: der Buchungsdialog
// eines Zeitfensters (Auswahl des Patienten, dann
// "Confirm" oder "Cancel").
//
// Struktureller Unterschied zur Flutter-Version: Flutter ÖFFNETE den
// Dialog mit showDialog(...) und WARTETE auf dessen Ergebnis (ein Future<int?>).
// In Compose ist ein Dialog ein Anzeigeelement wie jedes
// andere: AlertDialog wird angezeigt, solange die aufrufende Funktion ihn
// aufruft (siehe App.kt: solange vm.slotBeingBooked nicht
// null ist). Er "gibt" nichts "zurück": Er meldet die Wahl über zwei
// Funktionen, onConfirm und onClose - genau die beiden Ereignisse
// "confirm" / "close" des BookingDialog.vue der Vue.js-Variante.
// =========================================================================

package fr.rdvmedecins.client.features.bookingdialog

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
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.unit.dp
import fr.rdvmedecins.client.core.LocalTranslations
import fr.rdvmedecins.client.core.models.Client
import fr.rdvmedecins.client.core.models.SlotJson
import fr.rdvmedecins.client.core.ui.DropdownList

@Composable
fun BookingDialog(
    slot: SlotJson,
    clients: List<Client>,
    onConfirm: (clientId: Int) -> Unit,
    onClose: () -> Unit,
) {
    val t = LocalTranslations.current::t
    // der ausgewählte Patient (seine id) oder null, solange keiner ausgewählt ist
    var clientId by rememberSaveable { mutableStateOf<Int?>(null) }

    AlertDialog(
        // Tippen außerhalb des Dialogs oder die "Zurück"-Taste des Smartphones
        onDismissRequest = onClose,
        title = { Text(t("BOOKING_DIALOG.TITLE")) },
        text = {
            Column(verticalArrangement = Arrangement.spacedBy(16.dp)) {
                Text(
                    "${t("BOOKING_DIALOG.SLOT_FROM")} ${slot.startHour}:${slot.startMinute.toString().padStart(2, '0')} " +
                        "${t("BOOKING_DIALOG.SLOT_TO")} ${slot.endHour}:${slot.endMinute.toString().padStart(2, '0')}",
                )
                DropdownList(
                    label = t("BOOKING_DIALOG.PATIENT_LABEL"),
                    placeholder = t("BOOKING_DIALOG.CHOOSE_PATIENT"),
                    items = clients,
                    selectedId = clientId,
                    idOf = { it.id },
                    itemLabel = { "${it.title} ${it.firstName} ${it.lastName}" },
                    onSelect = { clientId = it },
                    modifier = Modifier.fillMaxWidth(),
                )
            }
        },
        // "Confirm": deaktiviert, solange kein Patient ausgewählt ist
        confirmButton = {
            Button(
                enabled = clientId != null,
                onClick = { clientId?.let(onConfirm) },
            ) { Text(t("BOOKING_DIALOG.CONFIRM")) }
        },
        dismissButton = {
            TextButton(onClick = onClose) { Text(t("BOOKING_DIALOG.CANCEL")) }
        },
    )
}

Kommentieren wir diesen Code:

  • Zeilen 8–15: Der Kopfkommentar fasst den strukturellen Unterschied zur Flutter-Version zusammen. Flutter ÖFFNETE das Dialogfeld mit [showDialog(...)] und WARTETE auf sein Ergebnis (ein [Future<int?>]). In Compose ist ein Dialogfeld ein Oberflächenelement wie jedes andere: Es bleibt angezeigt, solange die Funktion, die es aufruft, es weiter aufruft. Es „gibt“ nichts „zurück“: Es meldet die Auswahl über zwei Funktionen, [onConfirm] und [onClose] – genau die beiden Ereignisse [confirm] / [close] der Komponente [BookingDialog.vue] in der Vue.js-Variante;
  • Zeile 48: der gewählte Patient: [rememberSaveable]; der Patient bleibt auch nach einer Drehung des Bildschirms bei geöffnetem Dialogfeld ausgewählt;
  • Zeilen 50–52: [AlertDialog(...)] – das Dialogfeld von Material 3 mit Titel, Inhalt ([text]) und zwei Buttons. [onDismissRequest] wird aufgerufen, wenn der Benutzer außerhalb des Dialogfelds tippt oder die „Zurück“-Taste des Smartphones drückt;
  • Zeilen 73–76: der Button „Bestätigen“, der deaktiviert ist, bis ein Patient ausgewählt wurde. [clientId?.let(onConfirm)]: Wenn [clientId] nicht [null] ist, wird [onConfirm] aufgerufen – mit dessen Wert.

5.11. Schritt-für-Schritt-Anleitung zur Verwendung der Anwendung

Die folgenden Screenshots wurden im Emulator Pixel 8 (Android 17) aus Kapitel 1 aufgenommen, wobei die Anwendung über [adb reverse] mit dem Server verbunden war (siehe Kapitel 5), daher die URL [http://localhost:8080].

5.11.1. 1. Anmeldebildschirm

Beim ersten Start ist keine Sitzung gespeichert: [AuthService.isLoggedIn] ist gleich [false], und [App.kt] zeigt [LoginPage] an. Ein Versuch mit einer ungültigen Kombination aus Benutzername und Passwort – oder mit einem nicht erreichbaren Server – zeigt die Fehlermeldung an (Schlüssel [LOGIN.ERROR]):

Image

Image

5.11.2. 2. Anmeldung als Administrator (Rolle ADMIN, Vollzugriff)

Nach der Anmeldung mit [admin]/[admin] weicht der Anmeldebildschirm der Auswahl von Arzt und Tag; die Titelleiste zeigt das Rollen-Badge und den Abmelde-Button. Im Hintergrund hat [AppViewModel] die Ärzte und Patienten geladen:

Image

Image

  • Links der Bildschirm unmittelbar nach der Anmeldung: Der Button „Kalender anzeigen“ ist deaktiviert, bis ein Arzt ausgewählt ist;
  • rechts die geöffnete Dropdown-Liste der Ärzte.

Das Kalendersymbol öffnet die Datumsauswahl; „Kalender anzeigen“ zeigt den Terminkalender des Arztes für den gewählten Tag an:

Image

Image

„Buchen“ öffnet das Dialogfeld zur Patientenauswahl; „Bestätigen“ sendet die Buchung an den Server, und der Kalender wird neu geladen: Der Zeitslot erscheint als gebucht, mit einem Button „Stornieren“:

Image

Image

Image

„Stornieren“ löscht bei einem Klick auf einen gebuchten Slot den Termin, und der Slot ist wieder verfügbar. Der Button „FR“ schaltet den gesamten Bildschirm auf Französisch um, einschließlich der Beschriftungen des Kalenders; der Abmelde-Button führt zurück zum Anmeldebildschirm:

Image

Image

5.11.3. 3. Anmeldung als Benutzer (Rolle USER, nur Lesezugriff)

Eine Anmeldung mit [user]/[user] zeigt das Badge „USER“ an. Der Kalender bleibt einsehbar, aber es erscheinen keine Buttons „Buchen“/„Stornieren“ ([canEdit] entspricht [false]) – der Server würde diese beiden Aktionen dieser Rolle ohnehin verweigern (403 Forbidden, siehe Kapitel 2).

Image

5.12. Was außerhalb des Umfangs bleibt oder zurückgestellt wurde

  • Wie die anderen Clients dieses Kurses hat auch dieser keinen spezifischen Demo-/Debug-Modus.
  • Es werden clientseitig keine künstlichen Netzwerkverzögerungen zu Lehrzwecken eingeführt.
  • Keine Navigation zwischen Bildschirmen: Die App passt auf einen einzigen Bildschirm (Dialogfelder ausgenommen). Eine funktionsreichere Android-App würde die Bibliothek [Navigation Compose] verwenden.
  • Keine automatisierten Tests: Die von Android Studio generierten Ordner [src/test] und [src/androidTest] wurden aus dem Projekt entfernt.