5. Capítulo 4 - El cliente Kotlin de la aplicación RdvMedecins
5.1. Descripción general de la arquitectura

Este cliente se comunica con el servidor [rdvmedecins-nestjs-server] del curso, que permanece completamente sin cambios, mediante las mismas rutas HTTP (POST [/login], GET [/getAllDoctors], GET [/getAllClients], GET [/getDoctorScheduleOfDay/:doctorId/:day], POST [/addAppointment], POST [/deleteAppointment]), con el mismo envoltorio JSON [{ status, data }] y la misma autenticación por token [JWT] (encabezado [Authorization: Bearer <token>]).
5.2. Árbol del proyecto
| 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
|
Esta estructura de directorios refleja, carpeta por carpeta, la del cliente Flutter ([lib/core/models], [lib/core/services], [lib/core/http], [lib/core/i18n], [lib/features]), que a su vez se basa en el cliente Vue.js. Hay dos agregados propios de Android: la clase Application ([RdvMedecinsApplication.kt]) y el ViewModel de la pantalla ([AppViewModel.kt]), cuyo propósito se explicó en el capítulo 3; y una pequeña carpeta llamada [core/ui] para una lista desplegable reutilizable. Los nombres de carpeta en Kotlin van en minúsculas y sin guiones ([doctordaypicker], [bookingdialog]): son nombres de paquetes.
5.3. Archivos de configuración del proyecto
5.3.1. gradle/libs.versions.toml
El catálogo de versiones: todas las bibliotecas y los complementos de Gradle del proyecto, junto con sus versiones, en un solo lugar. Es el equivalente de la sección [dependencies] del archivo [pubspec.yaml] de la versión Flutter. Android Studio generó el archivo y luego se complementó.
| # =========================================================================
# libs.versions.toml - el "catálogo de versiones" del proyecto: TODAS las
# versiones de los plugins y de las bibliotecas, en un solo lugar. Los
# archivos build.gradle.kts las referencian por nombre (libs.okhttp,
# libs.plugins.kotlin.compose...): el equivalente de los números de versión
# del pubspec.yaml de la versión Flutter, o del package.json de 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]
# generado por Android Studio (plantilla "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" }
# agregado para este cliente
# viewModel { ... } en una función @Composable (ver App.kt)
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# los íconos básicos de Material (logout, calendar)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# el cliente HTTP
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# (de)serialización JSON
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" }
# agregado para este cliente: genera el código de (de)serialización de las clases @Serializable
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
Comentemos este código:
- línea 10: [agp = "9.4.1"]: la versión del Android Gradle Plugin ([AGP]), el complemento de Gradle que construye una aplicación Android. A partir de la versión 9, compila por sí mismo el código Kotlin: ya no hay un complemento de Kotlin separado que declarar;
- línea 11: [kotlin = "2.2.10"]: la versión de los dos complementos de compilación de Kotlin declarados más abajo (Compose y serialización);
- línea 15: [composeBom]: la versión del “BOM” de Compose (Bill of Materials), que fija versiones compatibles para todas las bibliotecas de Compose a la vez (véase [app/build.gradle.kts]);
- líneas 38–46: las cuatro bibliotecas agregadas para este cliente: [lifecycle-viewmodel-compose] (la función [viewModel { ... }]), [material-icons-core] (los íconos de cierre de sesión y de calendario), [OkHttp] (el cliente HTTP, equivalente al paquete [http] de Flutter) y [kotlinx-serialization-json] (la conversión entre JSON <-> objetos Kotlin). Las dos primeras no tienen versión; la determina el BOM de Compose;
- línea 52: el complemento de compilación [kotlinx.serialization], que genera el código de conversión JSON para las clases anotadas con [@Serializable] (véase [core/models]).
5.3.2. app/build.gradle.kts
La configuración del módulo [app], es decir, la aplicación propiamente dicha, que incluye los complementos aplicados, los ajustes de Android y las dependencias.
| // =========================================================================
// app/build.gradle.kts - la configuración del módulo "app": la aplicación
// Android en sí. Generado por Android Studio (plantilla "Empty Activity"),
// y luego completado para este cliente (líneas marcadas "added").
// =========================================================================
plugins {
// el plugin de Android: compila el código Kotlin (Android Gradle Plugin 9
// ya incluye soporte para Kotlin) y produce el .apk
alias(libs.plugins.android.application)
// el compilador de Compose: transforma las funciones @Composable
alias(libs.plugins.kotlin.compose)
// agregado: el plugin kotlinx.serialization (clases @Serializable)
alias(libs.plugins.kotlin.serialization)
}
android {
// el "package" base de Kotlin del código fuente (clase R, BuildConfig...)
namespace = "fr.rdvmedecins.client"
// la versión de la API de Android usada para COMPILAR
compileSdk {
version = release(37)
}
defaultConfig {
// el identificador ÚNICO de la aplicación en un teléfono (y en la
// Play Store)
applicationId = "fr.rdvmedecins.client"
// la versión de Android más antigua aceptada: Android 8.0 (API 26),
// la primera en ofrecer java.time (LocalDate, ver DoctorDayPicker)
minSdk = 26
// la versión de Android con la que se probó la aplicación
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 {
// el "BOM" (Bill Of Materials) de Compose: fija de una sola vez versiones
// mutuamente compatibles para todas las bibliotecas de Compose, que
// por lo tanto se declaran a continuación SIN número de versión
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)
// agregado para este cliente
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.compose.material.icons.core)
implementation(libs.okhttp)
implementation(libs.kotlinx.serialization.json)
// pruebas (generadas por Android Studio, no se usan en este documento)
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)
}
|
Comentemos este código:
- líneas 6–13: los tres complementos aplicados al módulo: el de Android, el compilador de Compose (que transforma las funciones [@Composable]) y el complemento kotlinx.serialization;
- línea 18: [namespace]: el paquete base del código Kotlin;
- líneas 20–21: [compileSdk]: la versión de la API de Android utilizada para la compilación (37 = Android 17). [targetSdk] (línea 32) es la versión para la cual se probó la aplicación: Android le aplica los comportamientos de esa versión;
- línea 27: [applicationId] : el identificador único de la aplicación en un teléfono y en Play Store;
- línea 30: [minSdk = 26]: Android 8.0 o superior, la primera versión que ofrece la API [java.time] ([LocalDate]), utilizada por [DoctorDayPicker];
- línea 51: [compose = true]: habilita Compose para este módulo;
- línea 59: el BOM de Compose, declarado como “platform”: las bibliotecas de Compose que siguen se declaran sin versión;
- líneas 67–71: las cuatro dependencias agregadas para este cliente (véase [libs.versions.toml]). La sintaxis [libs.okhttp] hace referencia al catálogo de versiones: Gradle genera un getter de Kotlin para cada entrada del catálogo, lo que habilita el autocompletado en Android Studio.
5.3.3. app/src/main/AndroidManifest.xml
El manifiesto de la aplicación. La versión Flutter no tenía uno: la carpeta [android/], que lo contiene, fue generada por [flutter create] y no se examinó. Aquí forma parte del código de la aplicación.
| <?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
AndroidManifest.xml
............................................................................
La "cédula de identidad" de la aplicación para el sistema Android: sus
permisos, su clase Application, sus actividades (pantallas).
===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- acceso a la red: sin este permiso, toda solicitud HTTP al
servidor NestJS falla (no se muestra ningún diálogo al
usuario para este permiso: se concede automáticamente) -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- android:name: la clase Application que construye los servicios
(ver RdvMedecinsApplication.kt).
android:usesCleartextTraffic="true": permite HTTP "en claro"
(http:// y no https://), bloqueado por defecto desde Android 9.
Indispensable con el servidor NestJS de este curso, que escucha en
HTTP simple - debe quitarse para un servidor de producción con https
(ver capítulo 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">
<!-- la única pantalla de la aplicación. exported="true" + el filtro
MAIN/LAUNCHER: es la actividad que se lanza con el
ícono de la aplicación. windowSoftInputMode="adjustResize": cuando
aparece el teclado, la pantalla se reduce (y sigue siendo desplazable) en lugar de
quedar oculta por el teclado. -->
<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>
|
Comentemos este código:
- línea 14: [android.permission.INTERNET]: sin este permiso, toda conexión con el servidor fallará. Es un permiso “normal”: se concede en la instalación sin preguntar al usuario;
- línea 24: [android:name=".RdvMedecinsApplication"]: la clase Application de la aplicación (el punto inicial [.] se reemplaza por [namespace]);
- línea 33: [android:usesCleartextTraffic="true"]: permite HTTP “en texto plano” ([http://], no [https://]), que está bloqueado de forma predeterminada desde Android 9. Como el servidor NestJS de este curso escucha en HTTP simple, este ajuste es indispensable (véase el capítulo 5);
- líneas 41–50: la única activity, [MainActivity]. El filtro [MAIN]/[LAUNCHER] la convierte en la activity que inicia el ícono de la aplicación; [exported="true"] permite que otra aplicación la inicie; en este caso, el lanzador de aplicaciones del teléfono;
- línea 44: [windowSoftInputMode="adjustResize"]: cuando aparece el teclado, la pantalla se ajusta al espacio restante (y sigue siendo desplazable) en lugar de quedar parcialmente tapada por el teclado.
El resto de la carpeta [res/] proviene de la plantilla de Android Studio: el ícono de la aplicación ([mipmap-*], [drawable/]), su nombre ([values/strings.xml]), su tema “Android”, que se usa solo durante el inicio, antes de que Compose muestre la primera pantalla con su propio tema ([values/themes.xml]), y las reglas de ahorro de datos ([xml/]).
5.4. Inicio de la aplicación
El archivo [lib/main.dart] de la versión Flutter hacía dos cosas: construir los servicios y luego mostrar la primera pantalla. En Android, estas dos funciones se reparten entre la clase Application y la activity.
5.4.1. RdvMedecinsApplication.kt
Inicializa los cuatro servicios del cliente una sola vez, al iniciarse la aplicación.
| // =========================================================================
// RdvMedecinsApplication.kt
// -------------------------------------------------------------------------
// Primera mitad del lib/main.dart de la versión Flutter: construir,
// UNA SOLA VEZ, los servicios de la aplicación.
//
// ¿Por qué una clase Application? En Android, la pantalla (la Activity, ver
// MainActivity) se DESTRUYE y luego se RECREA en cada rotación del teléfono, en
// cada cambio del idioma del sistema, etc. Los servicios construidos en la
// Activity se reconstruirían, por lo tanto, en cada rotación. El
// objeto Application, en cambio, se crea cuando se inicia el proceso
// y vive tanto como este: es el lugar adecuado para los objetos que deben
// durar toda la vida de la aplicación. Se declara en
// AndroidManifest.xml (atributo android:name de la etiqueta <application>).
//
// El ORDEN de construcción importa, como en la versión Flutter:
// AuthService necesita SettingsService (la URL del servidor); el cliente
// HTTP autenticado necesita AuthService (el token); AppointmentService necesita
// el cliente HTTP autenticado y 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: estas propiedades no nulas se inicializarán en
// onCreate(), y no en el constructor (ver el curso de Kotlin)
lateinit var settings: SettingsService
private set
lateinit var auth: AuthService
private set
lateinit var api: AppointmentService
private set
lateinit var translations: TranslationsService
private set
// llamado por Android cuando se inicia la aplicación, antes de cualquier pantalla
override fun onCreate() {
super.onCreate()
// las preferencias de la aplicación: un pequeño archivo privado de clave/valor,
// que sobrevive a la detención de la aplicación - el equivalente del
// localStorage de un navegador
val prefs = getSharedPreferences("rdvmedecins", Context.MODE_PRIVATE)
// 1. Primero SettingsService: los demás lo necesitan
settings = SettingsService(prefs)
// 2. un cliente HTTP OkHttp "simple", usado por AuthService para
// POST /login. Timeouts cortos: en móvil, un mensaje de error rápido
// es mejor que una espera interminable si el servidor
// no es accesible (URL incorrecta, Wi-Fi apagado...).
val plainHttp = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(15, TimeUnit.SECONDS)
.build()
auth = AuthService(settings, prefs, plainHttp)
// 3. el cliente HTTP autenticado: una COPIA del anterior
// (newBuilder() reutiliza su configuración y sus conexiones),
// más el interceptor que agrega el token JWT
val authHttp = plainHttp.newBuilder()
.addInterceptor(AuthInterceptor(auth))
.build()
api = AppointmentService(authHttp, settings)
// 4. las traducciones: sin dependencia de los demás servicios
translations = TranslationsService(assets, prefs)
}
}
|
Comentemos este código:
- línea 34: la clase extiende [android.app.Application]. Android crea una única instancia de ella cuando se inicia el proceso de la aplicación, antes que cualquier activity, y la conserva hasta que el proceso termina;
- líneas 38–44: los cuatro servicios, declarados como [lateinit var ... private set]: no nulos, inicializados más tarde (en [onCreate]) y modificables solo por esta clase;
- línea 54: [getSharedPreferences(...)]: las preferencias de la aplicación, un pequeño archivo privado de pares clave/valor que sobrevive al cierre de la aplicación; es el equivalente del [localStorage] de un navegador y del paquete [shared_preferences] de Flutter;
- líneas 63–66: un cliente [OkHttp] “simple”, con tiempos de espera cortos. Un cliente OkHttp está pensado para COMPARTIRSE: gestiona su propio grupo de conexiones reutilizables;
- línea 67: [AuthService] recibe el cliente simple: la ruta [/login] es la única ruta pública del servidor; no requiere un token;
- líneas 72–75: el cliente autenticado, [newBuilder()], crea una copia de este (que comparte las conexiones del primero) complementada con el interceptor [AuthInterceptor], que agrega el token JWT a cada solicitud (véase [core/http]). [AppointmentService] lo recibe: ninguno de sus métodos necesita ocuparse del token;
- línea 78: [assets]: acceso a los archivos de la carpeta [assets/] de la aplicación, que se pasa a [TranslationsService].
Una diferencia notable con la versión Flutter: no se requiere ninguna inicialización asíncrona antes de mostrar la primera pantalla. Los objetos [SharedPreferences] se leen de forma sincrónica (se cargan en memoria en el primer acceso): [AuthService] y [TranslationsService] leen la sesión y el idioma almacenados en cuanto se crean, mientras que [lib/main.dart] debía esperar [await auth.init()] y [await translations.init()].
5.4.2. MainActivity.kt
La única actividad de la aplicación: pone los servicios a disposición de todas las funciones @Composable y luego muestra la pantalla raíz.
| // =========================================================================
// MainActivity.kt
// -------------------------------------------------------------------------
// Segunda mitad del lib/main.dart de la versión Flutter: mostrar la
// primera pantalla.
//
// Una aplicación Android se compone de "activities" (Activity): una
// activity es una pantalla, lanzada por el sistema. Esta se declara en
// AndroidManifest.xml como la activity de inicio (LAUNCHER): es la que
// Android lanza cuando el usuario toca el ícono de la aplicación.
//
// ComponentActivity es la activity base diseñada para Jetpack Compose:
// setContent { ... } reemplaza el antiguo sistema de vistas de Android (archivos
// de diseño XML) por funciones @Composable - el equivalente de
// runApp(...) de 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() {
// llamado cada vez que se crea la activity: al iniciar, pero también
// después de cada rotación de pantalla (ver RdvMedecinsApplication)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// la aplicación dibuja debajo de la barra de estado y de la
// barra de navegación del sistema; Scaffold (ver App.kt) se encarga de
// dejar el espacio que necesitan esas barras
enableEdgeToEdge()
// los servicios, construidos una sola vez por
// RdvMedecinsApplication - y no aquí, donde se reconstruirían
// en cada rotación
val app = application as RdvMedecinsApplication
setContent {
// CompositionLocalProvider: pone los cuatro servicios a disposición
// de toda función @Composable llamada dentro del bloque - el
// MultiProvider de la versión Flutter (ver core/Locals.kt)
CompositionLocalProvider(
LocalSettings provides app.settings,
LocalAuth provides app.auth,
LocalApi provides app.api,
LocalTranslations provides app.translations,
) {
RdvMedecinsApp()
}
}
}
}
|
Comentemos este código:
- línea 34: [onCreate(...)] se llama CADA vez que se crea la actividad: al iniciar, pero también después de cada rotación de pantalla. Por eso los servicios los crea la clase Application, y no aquí;
- línea 39: [enableEdgeToEdge()]—la aplicación dibuja en toda la pantalla, incluso debajo de la barra de estado del sistema (arriba) y de la barra de navegación (abajo). [Scaffold] (véase [App.kt]) proporciona los márgenes necesarios para que el contenido no quede oculto por estas barras;
- línea 44: [application as RdvMedecinsApplication]—la propiedad [application] de una actividad devuelve el objeto Application: se convierte a su tipo real para acceder a los servicios;
- línea 46: [setContent { ... }]—el equivalente de [runApp(...)]: la interfaz de la actividad ahora se describe mediante las funciones @Composable del bloque;
- líneas 50–56: [CompositionLocalProvider(LocalSettings provides app.settings, ...)]—proporciona los cuatro servicios a todo el árbol de funciones @Composable llamadas dentro del bloque: el equivalente del [MultiProvider] de la versión Flutter. [provides] es una función “infija”: [a provides b] se escribe sin punto ni paréntesis (véase el curso de Kotlin).
5.4.3. core/Locals.kt
Las cuatro “claves” de los servicios proporcionados por [MainActivity].
| // =========================================================================
// Locals.kt
// -------------------------------------------------------------------------
// Los "CompositionLocal" de la aplicación: el mecanismo de Jetpack Compose
// para poner un objeto a disposición de TODO un subárbol de
// funciones @Composable, sin pasarlo como parámetro de llamada en llamada.
// Es el equivalente del paquete provider de la versión Flutter
// (MultiProvider / context.read<...>()), de provide/inject en Vue.js o
// de un Context de React.
//
// - MainActivity PROPORCIONA las instancias:
// CompositionLocalProvider(LocalAuth provides auth, ...) { ... }
// - cualquier función @Composable descendiente las LEE:
// val auth = LocalAuth.current
//
// staticCompositionLocalOf (en lugar de compositionLocalOf): estos servicios
// nunca se REEMPLAZAN por otras instancias durante la vida de
// la aplicación, solo cambia su CONTENIDO - y ese contenido ya está
// observado por Compose gracias al mutableStateOf de cada servicio.
// El bloque { error(...) } da el valor por defecto: aquí, una excepción
// explícita si se muestra una pantalla sin que se haya proporcionado el servicio.
// =========================================================================
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") }
|
Comentemos este código:
- línea 33: [staticCompositionLocalOf<AuthService> { ... }]—declara un CompositionLocal de tipo [AuthService]. El bloque especifica el valor predeterminado, que se usa si no se proporciona ningún valor: aquí, una excepción explícita ([error(...)]), más clara que un error críptico más adelante;
- [static...] en lugar de [compositionLocalOf]: un CompositionLocal “estático” no hace seguimiento de los REEMPLAZOS de la instancia proporcionada (lo que sería más costoso). Esto funciona aquí: los servicios nunca se reemplazan por otras instancias; solo cambia su contenido, y ese contenido ya se observa a través de sus propiedades [mutableStateOf].
5.4.4. App.kt
Port de [lib/app.dart]: la pantalla raíz. Ensambla los componentes de [features/], transmite sus acciones al ViewModel y actúa como “guardia”: mientras el usuario no haya iniciado sesión, solo muestra la pantalla de inicio de sesión. Su estado y su lógica se definen en [AppViewModel]: este archivo simplemente MUESTRA.
| // =========================================================================
// App.kt
// -------------------------------------------------------------------------
// Adaptación de lib/app.dart (cliente Flutter): la pantalla RAÍZ de la aplicación.
// Como en todas las variantes de este curso, cumple el papel de
// "director de orquesta" - ensambla las pantallas de lib/features/
// (aquí features/) y retransmite sus acciones - y el papel de "guardia": mientras
// el usuario no haya iniciado sesión, solo muestra la pantalla de inicio de sesión.
//
// Su estado y su lógica se trasladaron a AppViewModel (ver ese
// archivo para saber por qué): este archivo solo MUESTRA.
//
// Tres funciones @Composable:
// - RdvMedecinsApp: el tema de la aplicación (MaterialApp en el lado de Flutter);
// - AppRoot : la pantalla propiamente dicha (barra de título + contenido);
// - ServerUrlField y LanguageSelector: dos pequeños elementos de la pantalla.
// =========================================================================
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
// -------------------------------------------------------------------------
// el tema: un azul "primary" para la barra de título y los botones, como
// la franja azul (navbar bg-primary) de las variantes web de este curso
// -------------------------------------------------------------------------
private val appColors = lightColorScheme(
primary = Color(0xFF1565C0),
onPrimary = Color.White,
)
@Composable
fun RdvMedecinsApp() {
MaterialTheme(colorScheme = appColors) {
AppRoot()
}
}
// -------------------------------------------------------------------------
// la pantalla principal
// -------------------------------------------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AppRoot() {
// los servicios, proporcionados por MainActivity (ver core/Locals.kt)
val auth = LocalAuth.current
val api = LocalApi.current
val translations = LocalTranslations.current
// una referencia al método t(...): t("APP.TITLE") se lee entonces
// como en las otras variantes del curso
val t = translations::t
// viewModel { ... }: RECUPERA el ViewModel de esta pantalla si ya
// existe (después de una rotación), o lo CREA con el bloque dado la primera
// vez. Por eso nunca debe escribirse
// "val vm = AppViewModel(auth, api)": se construiría un ViewModel nuevo y
// vacío en cada visualización.
val vm = viewModel { AppViewModel(auth, api) }
// pantalla estrecha (teléfono en vertical): la barra de título se aligera
val narrow = LocalConfiguration.current.screenWidthDp < 600
// Scaffold: la estructura estándar de una pantalla Material (barra de título,
// contenido...) - el mismo widget, y el mismo nombre, que en Flutter
Scaffold(
topBar = {
TopAppBar(
// en una pantalla estrecha, un título corto: no hay espacio suficiente para el
// título completo junto a los botones FR/EN, el rol y el
// botón de cierre de sesión
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: los elementos alineados a la derecha de la barra de título
actions = {
// selector FR/EN: SIEMPRE visible, incluso antes de iniciar sesión
LanguageSelector(translations)
// un simple if de Kotlin: la insignia del rol, el nombre y el
// botón de cierre de sesión solo existen una vez iniciada la sesión
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),
)
}
// en una pantalla estrecha, el nombre se oculta por falta de espacio
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: el espacio ocupado por la barra de título y las barras del
// sistema, que debe dejarse libre (ver enableEdgeToEdge())
Column(
modifier = Modifier
.padding(systemInsets)
.fillMaxSize()
// el equivalente del SingleChildScrollView de la versión Flutter
.verticalScroll(rememberScrollState())
.padding(16.dp),
) {
// la URL del servidor, editable antes y después de iniciar sesión
ServerUrlField(label = t("APP.SERVER_URL_LABEL"))
Spacer(Modifier.height(16.dp))
// el mensaje de error, si lo hay
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))
}
// el "guardia": sin sesión iniciada -> solo la pantalla de inicio de sesión
if (!auth.isLoggedIn) {
LoginPage()
} else {
// 1. elección del médico y del día
DoctorDayPicker(doctors = vm.doctors, onSearch = vm::searchSchedule)
Spacer(Modifier.height(16.dp))
// 2. la agenda; canEdit oculta "Book"/"Cancel"
// para el rol USER
ScheduleView(
schedule = vm.schedule,
canEdit = auth.isAdmin,
onBook = vm::requestBooking,
onCancel = vm::cancelAppointment,
)
}
}
// 3. el diálogo de reserva: se muestra mientras
// se esté reservando una franja (ver AppViewModel)
vm.slotBeingBooked?.let { slot ->
BookingDialog(
slot = slot,
clients = vm.clients,
onConfirm = vm::confirmBooking,
onClose = vm::closeBooking,
)
}
}
}
// -------------------------------------------------------------------------
// el campo "Server URL". La versión Flutter necesitaba un
// StatefulWidget dedicado para crear y luego liberar un TextEditingController.
// En Compose, un campo de texto no tiene estado oculto: MUESTRA value y
// REPORTA cada pulsación de tecla mediante onValueChange - nos corresponde actualizar el estado,
// lo que hace que el campo se vuelva a mostrar con el nuevo valor.
// Es el "v-model" de Vue.js escrito en dos mitades explícitas.
// -------------------------------------------------------------------------
@Composable
private fun ServerUrlField(label: String) {
val settings = LocalSettings.current
OutlinedTextField(
value = settings.apiBaseUrl,
onValueChange = settings::changeUrl,
label = { Text(label) },
singleLine = true,
// teclado adecuado para escribir una URL (teclas "/", ".", ":"...)
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri),
modifier = Modifier.widthIn(max = 360.dp).fillMaxWidth(),
)
}
// -------------------------------------------------------------------------
// los dos botones FR / EN de la barra de título: el idioma actual se
// muestra en blanco y negrita, el otro en blanco atenuado
// -------------------------------------------------------------------------
@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),
)
}
}
}
|
Comentemos este código:
- líneas 70–72: el esquema de colores: azul como color primario ([primary]), blanco para el texto sobre él ([onPrimary]). Los demás colores son los predeterminados de Material 3;
- líneas 76–78: [RdvMedecinsApp] aplica el tema a toda la pantalla ([MaterialTheme]), de forma similar a [MaterialApp] de Flutter;
- línea 85: [@OptIn(ExperimentalMaterial3Api::class)]—[TopAppBar] sigue marcado como “experimental” por Material 3: la anotación indica que se usa con pleno conocimiento de los riesgos (sin ella, el compilador rechaza el código);
- líneas 89–91: los servicios, leídos como CompositionLocal—el equivalente de [context.read<...>()] / [context.watch<...>()];
- línea 94: [val t = translations::t]—una REFERENCIA al método [t] del objeto [translations]: luego se escribe [t("APP.TITLE")], como en las otras variantes del curso;
- Línea 101: [viewModel { AppViewModel(auth, api) }] - RECUPERA el ViewModel de esta pantalla si ya existe (después de una rotación), o lo CREA con el bloque proporcionado la primera vez. Así, el ViewModel sobrevive cuando se recrea la actividad;
- línea 104: el ancho de pantalla, en dp, leído de la configuración actual: por debajo de 600 dp (teléfono en modo vertical), la barra de título se simplifica: título corto (línea 116) y nombre de usuario oculto (línea 145);
- línea 108: [Scaffold(topBar = { ... }) { systemInsets -> ... }]—la estructura estándar de una pantalla Material, como en Flutter. El último parámetro, una lambda, es el contenido de la pantalla; recibe los márgenes que se deben respetar (barra de título y barras del sistema);
- línea 110: [TopAppBar] – la barra de título, coloreada con el color primario del tema;
- líneas 127–132: [actions = { ... }]—los elementos alineados a la derecha de la barra: el selector de idioma, SIEMPRE visible; luego, con un simple [if], la insignia del rol, el nombre y el botón de cierre de sesión, que solo aparecen una vez iniciada la sesión. Como [auth.isLoggedIn] es un estado observable, la barra se recompone automáticamente al iniciar y al cerrar sesión;
- línea 149: [onClick = vm::logOut]—una referencia a un método pasada como controlador de clic;
- líneas 159–165: el contenido: una [Column] con desplazamiento ([verticalScroll], el equivalente de [SingleChildScrollView] de Flutter);
- línea 172: el mensaje de error del ViewModel, si lo hay: [vm.error?.let { message -> ... }] solo emite el bloque si [error] no es [null];
- líneas 185–197: la “guardia”: si no se ha iniciado sesión, la pantalla de inicio de sesión; si se ha iniciado, la selección de médico y día, seguida del calendario. [canEdit = auth.isAdmin] oculta los botones de reserva de citas para el rol USER;
- líneas 204–209: el cuadro de diálogo de reserva, que se muestra mientras [vm.slotBeingBooked] no sea [null] (véanse [AppViewModel] y [BookingDialog]);
- líneas 224–232: [ServerUrlField]—el campo “URL del servidor”. En Compose, un campo de entrada no tiene un estado oculto: MUESTRA [value] e INFORMA cada pulsación de tecla mediante [onValueChange]. Aquí, cada pulsación se envía a [settings.changeUrl(...)], que actualiza el estado observado, y el campo se vuelve a dibujar con el nuevo valor. La versión Flutter requería un [TextEditingController] y, por lo tanto, un [StatefulWidget] dedicado para crearlo y liberarlo;
- líneas 242–245: [LanguageSelector]—dos [TextButton] , “FR” y “EN”, generados mediante un bucle sobre la lista de idiomas; el idioma actual aparece en negrita.
5.4.5. AppViewModel.kt
El estado y la lógica de la pantalla raíz: la parte [_AppRootState] de [lib/app.dart].
| // =========================================================================
// AppViewModel.kt
// -------------------------------------------------------------------------
// El ESTADO y la LÓGICA de la pantalla principal: la parte "_AppRootState" del
// lib/app.dart de la versión Flutter (médicos, pacientes, agenda
// mostrada, error, última búsqueda...) y las reacciones a las
// acciones del usuario (buscar una agenda, reservar, cancelar).
//
// ¿Por qué un ViewModel, en lugar de estados locales en la función @Composable
// AppRoot (ver App.kt)? Porque la Activity se destruye y se
// recrea en cada rotación de pantalla (ver RdvMedecinsApplication): un
// estado local se perdería - la agenda mostrada desaparecería con la más mínima
// inclinación del teléfono. Un ViewModel (biblioteca "lifecycle" de Android Jetpack)
// SOBREVIVE a esas recreaciones: Android lo conserva y
// se lo entrega a la nueva Activity. Solo se destruye cuando se abandona
// la pantalla definitivamente. Flutter no tiene este problema: allí la rotación
// no destruye nada, solo cambia el tamaño de la pantalla.
//
// La separación resultante es clásica en Android: App.kt MUESTRA, este
// ViewModel DECIDE y llama a los servicios.
// =========================================================================
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() {
// — estado mostrado por App.kt (lectura pública, escritura privada) —
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
// la franja que se está reservando: no nula = el diálogo de reserva
// está abierto (ver App.kt y BookingDialog.kt)
var slotBeingBooked by mutableStateOf<SlotJson?>(null)
private set
// la última búsqueda (médico + día), para actualizar la agenda después de
// una reserva o una cancelación. Nunca se muestra: bastan
// propiedades simples, no hace falta convertirlas en estados de Compose.
private var lastDoctorId: Int? = null
private var lastDay: String? = null
init {
// snapshotFlow { ... } convierte la lectura de un estado de Compose en un
// FLOW de valores: emite de inmediato el valor actual de auth.isLoggedIn,
// luego cada nuevo valor. Es el equivalente exacto del
// "watch(() => auth.isLoggedIn, ..., { immediate: true })" de Vue.js
// - y de la suscripción addListener(...) + llamada inicial
// que la versión Flutter debía escribir a mano.
// viewModelScope: las corrutinas lanzadas en este ámbito se cancelan
// automáticamente cuando se destruye el ViewModel (ya no hace falta
// el removeListener(...) del dispose() del lado de Flutter).
viewModelScope.launch {
snapshotFlow { auth.isLoggedIn }.collect { loggedIn ->
if (loggedIn) {
loadInitialLists()
} else {
reset()
}
}
}
}
// -----------------------------------------------------------------------
// al iniciar sesión (o cuando se restaura una sesión recordada):
// cargamos los médicos y los pacientes una sola vez. Dos
// corrutinas separadas: las dos solicitudes se envían EN PARALELO.
// -----------------------------------------------------------------------
private fun loadInitialLists() {
runSafely { doctors = api.getAllDoctors() }
runSafely { clients = api.getAllClients() }
}
// -----------------------------------------------------------------------
// al cerrar sesión (botón, o token rechazado por el servidor):
// purgamos el estado de negocio, para que un nuevo usuario no vea, ni siquiera por
// un instante, la agenda del usuario anterior
// -----------------------------------------------------------------------
private fun reset() {
doctors = emptyList()
clients = emptyList()
schedule = null
error = null
slotBeingBooked = null
lastDoctorId = null
lastDay = null
}
// botón "Log out": basta con cerrar la sesión en AuthService -
// snapshotFlow (ver init) activa entonces reset()
fun logOut() {
auth.logOut()
}
// -----------------------------------------------------------------------
// botón "View schedule" de DoctorDayPicker
// -----------------------------------------------------------------------
fun searchSchedule(doctorId: Int, day: String) {
error = null
lastDoctorId = doctorId
lastDay = day
loadSchedule()
}
// -----------------------------------------------------------------------
// botón "Book" de ScheduleView: nos limitamos a ABRIR el
// diálogo, recordando la franja correspondiente. Con Compose, un diálogo
// forma parte de la visualización como todo lo demás: se
// muestra mientras slotBeingBooked no sea nulo (ver App.kt) -
// el mismo principio que la prop "open" del BookingDialog.vue de la
// variante Vue.js, lo contrario del showDialog(...) de Flutter.
// -----------------------------------------------------------------------
fun requestBooking(slot: SlotJson) {
slotBeingBooked = slot
}
// botón "Cancel" del diálogo (o toque fuera de él)
fun closeBooking() {
slotBeingBooked = null
}
// botón "Confirm" del diálogo
fun confirmBooking(clientId: Int) {
val slot = slotBeingBooked ?: return
val day = lastDay ?: return
slotBeingBooked = null // cierra el diálogo
runSafely {
api.addAppointment(day, clientId, slot.id)
loadSchedule() // la franja ahora aparece ocupada
}
}
// -----------------------------------------------------------------------
// botón "Cancel" de una franja ocupada, en ScheduleView
// -----------------------------------------------------------------------
fun cancelAppointment(appointment: AppointmentJson) {
runSafely {
api.deleteAppointment(appointment.id)
loadSchedule() // la franja vuelve a quedar libre
}
}
private fun loadSchedule() {
val doctorId = lastDoctorId ?: return
val day = lastDay ?: return
runSafely { schedule = api.getDoctorScheduleOfDay(doctorId, day) }
}
// -----------------------------------------------------------------------
// ejecuta [action] en una corrutina del ViewModel y convierte cualquier
// excepción en un mensaje de error mostrado en pantalla. Factorizar este
// try/catch evita repetirlo en cada método anterior.
// Una CancellationException NO es un error: es la señal de cancelación
// de una corrutina (ViewModel destruido), que debe dejarse
// propagar.
// -----------------------------------------------------------------------
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) // ver Logcat
error = e.message ?: e.toString()
}
}
}
}
|
Comentemos este código:
- línea 45: la clase extiende [ViewModel]; recibe por su constructor los dos servicios que necesita;
- líneas 48–54: el estado que muestra [App.kt]: propiedades de [by mutableStateOf(...)], legibles por todos ([App.kt] las lee) pero modificables solo por el ViewModel ([private set]);
- línea 59: [slotBeingBooked]—el horario que se está reservando en este momento. Si no es [null], se muestra el cuadro de diálogo de reserva;
- líneas 65–66: la búsqueda más reciente (médico y día), usada para actualizar el calendario después de una reserva o una cancelación. Son simples propiedades privadas: nunca se muestran;
- líneas 78–83: [snapshotFlow { auth.isLoggedIn }] convierte la lectura de un estado de Compose en un FLOW, una secuencia de valores: el valor actual de inmediato y luego cada nuevo valor. [collect { ... }] procesa cada uno: cuando hay sesión iniciada, carga los médicos y los pacientes; cuando se cierra, borra el estado. Es el equivalente del [watch(..., { immediate: true })] de Vue.js, que la versión Flutter tenía que replicar con [addListener(...)] y una llamada inicial escrita a mano;
- líneas 94–96: [loadInitialLists()]—dos corrutinas separadas: ambas solicitudes se envían EN PARALELO;
- Líneas 116–117: [logOut()] simplemente desconecta a [AuthService]; es [snapshotFlow] el que luego activa la purga del estado. Lo mismo ocurre cuando [AuthInterceptor] desconecta al usuario (token rechazado por el servidor): el ViewModel no necesita conocer la causa de la desconexión;
- Líneas 138–139: [requestBooking(...)] NO ABRE un cuadro de diálogo; simplemente almacena el horario. La visualización sigue al estado: es [App.kt] quien emite [BookingDialog] mientras [slotBeingBooked] no sea [null]. Por lo tanto, este cuadro de diálogo también sobrevive a la rotación de pantalla (véase el Capítulo 5);
- líneas 148–154: [confirmBooking(...)]—cierra el cuadro de diálogo, luego llama al servidor y actualiza el calendario: el horario aparece como reservado;
- líneas 182–190: [runSafely(action)]—lanza [action] (una función [suspend]) en una corrutina del ViewModel y convierte cualquier excepción en un mensaje de error que se muestra. [CancellationException] se vuelve a lanzar: no es un error, sino una señal de cancelación de la corrutina (el ViewModel se destruye), que debe poder propagarse. [Log.w(...)] escribe el error completo en el registro de Android, que se puede consultar en la pestaña [Logcat] de Android Studio.
5.5. La capa core/models
5.5.1. core/models/AppointmentModels.kt
Port de [lib/core/models/appointment_models.dart]: las clases de datos intercambiadas con el servidor.
| // =========================================================================
// AppointmentModels.kt
// -------------------------------------------------------------------------
// Las data classes intercambiadas con el servidor NestJS: el reflejo, en
// Kotlin, del JSON devuelto por sus rutas. Adaptación de
// lib/core/models/appointment_models.dart (cliente Flutter de este curso).
//
// Gran diferencia con la versión Flutter: NINGÚN constructor
// fromJson(...) escrito a mano. La anotación @Serializable le pide al
// plugin del compilador kotlinx.serialization (ver app/build.gradle.kts)
// que GENERE, en tiempo de compilación, el código que lee y escribe cada clase como
// JSON. Como en Dart (y a diferencia de TypeScript), los tipos se
// verifican en tiempo de ejecución: una clave obligatoria ausente, o una de
// un tipo inesperado, lanza de inmediato una excepción (SerializationException).
//
// Una "data class" de Kotlin (ver el curso de Kotlin) aporta además, sin una sola
// línea de código: equals/hashCode (comparación por valor), toString y
// copy(...). Todas las propiedades son de solo lectura (val): estos
// objetos son INMUTABLES, lo que le viene perfecto a Jetpack Compose,
// que compara el estado anterior y el nuevo para saber qué redibujar.
// =========================================================================
package fr.rdvmedecins.client.core.models
import kotlinx.serialization.Serializable
// un médico, tal como lo devuelve GET /getAllDoctors (el servidor también envía
// un campo "version", ignorado aquí gracias a ignoreUnknownKeys, ver
// Response.kt)
@Serializable
data class Doctor(
val id: Int,
val title: String,
val lastName: String,
val firstName: String,
)
// un paciente (cliente del consultorio médico), devuelto por GET /getAllClients
@Serializable
data class Client(
val id: Int,
val title: String,
val lastName: String,
val firstName: String,
)
// una franja horaria de consulta: startHour/startMinute -> endHour/endMinute
@Serializable
data class SlotJson(
val id: Int,
val startHour: Int,
val startMinute: Int,
val endHour: Int,
val endMinute: Int,
)
// una cita: un día, un paciente, una franja. Los valores por defecto
// "= null" hacen opcionales las claves en el JSON recibido.
@Serializable
data class AppointmentJson(
val id: Int,
val day: String, // formato "yyyy-MM-dd"
val client: Client? = null,
val slot: SlotJson? = null,
)
// una fila de la agenda: una franja y, si está ocupada, su cita
@Serializable
data class DoctorDaySlot(
val slot: SlotJson,
val appointment: AppointmentJson? = null, // null = franja libre
)
// la agenda de un médico para un día, devuelta por
// GET /getDoctorScheduleOfDay/{doctorId}/{day}
@Serializable
data class DoctorDaySchedule(
val doctor: Doctor,
val day: String,
val slots: List<DoctorDaySlot>,
)
// -------------------------------------------------------------------------
// Autenticación
// -------------------------------------------------------------------------
// los dos roles de la aplicación. Los nombres de las constantes son
// EXACTAMENTE las cadenas enviadas por el servidor ("ADMIN", "USER"):
// kotlinx.serialization convierte entonces directamente la cadena JSON en una
// constante enum, mientras que la versión Flutter tenía que escribir a mano
// Role.fromString(...) y asString().
@Serializable
enum class Role { ADMIN, USER }
// el cuerpo JSON enviado a POST /login
@Serializable
data class LoginRequest(
val login: String,
val password: String,
)
// el contenido de "data" en la respuesta de POST /login
@Serializable
data class LoginResult(
val accessToken: String, // el token JWT que debe presentarse con cada solicitud siguiente
val login: String,
val name: String,
val role: Role,
)
// los cuerpos JSON enviados a POST /addAppointment y POST /deleteAppointment
@Serializable
data class AddAppointmentRequest(
val day: String,
val clientId: Int,
val slotId: Int,
)
@Serializable
data class DeleteAppointmentRequest(
val appointmentId: Int,
)
|
Comentemos este código:
- líneas 30–31: [@Serializable data class Doctor(...)]—una “data class” (véase el curso de Kotlin): [equals]/[hashCode] por valor, [toString], [copy(...)], sin una sola línea de código. La anotación [@Serializable] indica al plugin kotlinx.serialization que genere, en tiempo de compilación, el código que lee y escribe la clase en JSON, mientras que la versión Flutter escribía a mano un constructor [fromJson(...)] por clase;
- línea 63: [val client: Client? = null]—un tipo anulable con un valor predeterminado: la clave [client] puede estar ausente del JSON recibido, o puede ser [null];
- línea 71: [val appointment: AppointmentJson? = null] - [null] significa que el horario está disponible;
- línea 93: [enum class Role { ADMIN, USER }]—los nombres de las constantes son exactamente las cadenas que envía el servidor: kotlinx.serialization convierte directamente ["ADMIN"] en [Role.ADMIN], mientras que la versión Flutter escribía [Role.fromString(...)] y [asString()];
- Líneas 97, 113 y 120: las clases para los cuerpos JSON ENVIADOS al servidor ([LoginRequest], [AddAppointmentRequest], [DeleteAppointmentRequest]): la misma anotación, [@Serializable], se usa para la codificación. La versión Flutter construía estos cuerpos con valores literales de [Map].
5.5.2. core/models/Response.kt
Decodificación del contenedor [{ status, data }] común a todas las respuestas de negocio del servidor.
| // =========================================================================
// Response.kt
// -------------------------------------------------------------------------
// Todas las respuestas de negocio del servidor NestJS tienen la misma forma:
//
// { "status": 0, "data": ... }
//
// donde status es 0 en caso de éxito (ver ResponseStatus del lado del servidor).
// La versión Flutter decodificaba este envoltorio con una clase genérica
// ServerResponse<T>. Aquí procedemos en DOS pasos, por una razón específica: en caso
// de error, el servidor pone una lista de mensajes en "data"
// (List<String>) mientras que, en caso de éxito, esperamos por ejemplo una agenda.
// Decodificar {status, data} directamente como ServerResponse<DoctorDaySchedule>
// fallaría por lo tanto con una respuesta de error, antes incluso de leer el status.
// 1. leemos el envoltorio como un árbol JSON genérico (JsonObject);
// 2. verificamos status; solo si es 0 decodificamos "data" al
// tipo esperado.
// =========================================================================
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
// la configuración JSON compartida por todo el cliente:
// - ignoreUnknownKeys: el servidor envía campos que este cliente
// no usa (p. ej. la "version" de un médico) - los ignoramos en lugar de
// lanzar una excepción;
// - explicitNulls = false: al codificar, una propiedad nula no se
// escribe (sin efecto en las clases de este cliente, pero más cercano al
// comportamiento de JSON.stringify del lado de JavaScript).
val ApiJson = Json {
ignoreUnknownKeys = true
explicitNulls = false
}
// excepción lanzada cuando el servidor responde con un status de negocio
// distinto de 0 (recurso no encontrado, fecha inválida, error del servidor)
class ResponseException(val status: Int) :
Exception("The server responded with error status $status")
// decodifica el cuerpo de una respuesta {status, data} y devuelve "data" en el
// tipo T descrito por [deserializer] (p. ej. Doctor.serializer(), o
// ListSerializer(Doctor.serializer()) para una lista de médicos)
fun <T> decodeResponse(body: String, deserializer: DeserializationStrategy<T>): T {
// 1. el envoltorio, como árbol JSON genérico
val envelope = ApiJson.parseToJsonElement(body).jsonObject
// 2. el status de negocio
val status = envelope.getValue("status").jsonPrimitive.int
if (status != 0) {
throw ResponseException(status)
}
// 3. "data", decodificado solo ahora, al tipo esperado
val data = envelope["data"] ?: JsonNull
return ApiJson.decodeFromJsonElement(deserializer, data)
}
|
Comentemos este código:
- líneas 36–38: [ApiJson]—la configuración JSON compartida por todo el cliente. [ignoreUnknownKeys = true]: el servidor envía campos que el cliente no usa (p. ej., [version] de un médico); sin este ajuste, kotlinx.serialization lanzaría una excepción al encontrar la primera clave desconocida;
- línea 43: [ResponseException]—la excepción que se lanza cuando el servidor responde con un estado de negocio distinto de 0;
- Línea 49: [decodeResponse(body, deserializer)] - una función genérica: el parámetro [deserializer] (por ejemplo, [Doctor.serializer()], generado por el plugin) especifica el tipo [T] en el que se decodifica [data];
- Líneas 51–59: la decodificación se realiza en DOS pasos. Primero, el contenedor se lee como un árbol JSON genérico ([JsonObject]); luego, solo si [status] es 0, se decodifica [data] en el tipo esperado. Motivo: en caso de error, el servidor coloca una lista de mensajes en [data], mientras que en caso de éxito se esperaría, por ejemplo, un calendario. Decodificar de inmediato todo el contenedor en el tipo de éxito fallaría ante una respuesta de error, antes de poder leer el estado.
5.6. La capa core/services
5.6.1. core/services/SettingsService.kt
Port de [lib/core/services/settings_service.dart]: la URL del servidor.
| // =========================================================================
// SettingsService.kt
// -------------------------------------------------------------------------
// Adaptación de lib/core/services/settings_service.dart: guarda la URL del
// servidor NestJS, editable desde la pantalla (campo "Server URL").
//
// La versión Flutter extendía ChangeNotifier y debía llamar a
// notifyListeners() después de cada cambio. Aquí, la propiedad se
// declara con "by mutableStateOf(...)": es un ESTADO OBSERVABLE de
// Jetpack Compose. Toda función @Composable que LEA apiBaseUrl durante
// su visualización se vuelve a mostrar automáticamente cuando el valor cambia -
// sin notifyListeners(), sin context.watch<...>(): Compose registra
// cada lectura por sí mismo (el mismo principio que reactive(...) / ref(...)
// en Vue.js).
//
// Pequeña mejora respecto a la versión Flutter: la URL se
// guarda en las SharedPreferences del teléfono, para no tener que
// volver a escribirla en cada inicio de la aplicación (en móvil, casi siempre
// difiere del valor por defecto, ver capítulo 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) {
// el valor inicial se vuelve a leer de las preferencias,
// de forma SÍNCRONA: getString(...) responde de inmediato (las preferencias se
// cargan en memoria en el primer acceso). "private set": solo esta
// clase puede modificar la URL, mediante changeUrl(...).
var apiBaseUrl: String by mutableStateOf(prefs.getString(URL_KEY, null) ?: DEFAULT_URL)
private set
fun changeUrl(url: String) {
if (url == apiBaseUrl) {
return // evita una nueva visualización y una escritura innecesarias
}
apiBaseUrl = url
// edit { ... }: función de extensión de androidx.core (core-ktx);
// abre un editor, ejecuta el bloque y luego llama a apply(), que
// escribe en disco en segundo plano, sin bloquear la UI.
prefs.edit { putString(URL_KEY, url) }
}
companion object {
// 10.0.2.2: en el emulador de Android, esta dirección especial
// designa la máquina anfitriona, aquella donde se ejecuta el servidor NestJS
// (localhost designaría al propio emulador, ver capítulo 5)
const val DEFAULT_URL = "http://10.0.2.2:8080"
private const val URL_KEY = "rdvmedecins.apiBaseUrl"
}
}
|
Comentemos este código:
- líneas 36–37: [var apiBaseUrl: String by mutableStateOf(...)]—un estado observable, inicializado con el valor almacenado en las preferencias o con el valor predeterminado. [private set]: solo esta clase puede modificarlo;
- línea 39: [changeUrl(...)]—el método no puede llamarse [setApiBaseUrl]: ese nombre ya lo usa el “setter” privado que Kotlin genera para la propiedad [apiBaseUrl] (ambos tendrían la misma firma para la JVM);
- línea 47: [prefs.edit { putString(...) }]—una función de extensión de la biblioteca [core-ktx]: abre un editor, ejecuta el bloque y luego llama a [apply()], que escribe en disco en segundo plano. Así, la URL se conserva en el siguiente inicio (una pequeña mejora respecto de la versión Flutter, útil en un teléfono, donde la URL casi siempre difiere del valor predeterminado);
- línea 54: [DEFAULT_URL = "http://10.0.2.2:8080"]—la dirección del servidor vista desde el emulador de Android (véase el Capítulo 5). La versión Flutter, que también estaba destinada a la web y al escritorio, usaba [localhost].
5.6.2. core/services/AuthService.kt
Port de [lib/core/services/auth_service.dart]: la sesión del usuario conectado, el inicio y el cierre de sesión.
| // =========================================================================
// AuthService.kt
// -------------------------------------------------------------------------
// Adaptación de lib/core/services/auth_service.dart: la sesión del
// usuario conectado (token JWT, login, nombre, rol), el inicio de sesión
// (POST /login) y el cierre de sesión.
//
// Como en SettingsService, las propiedades mostradas por la UI son
// estados de Compose (mutableStateOf): la pantalla pasa AUTOMÁTICAMENTE de
// la pantalla de inicio de sesión a la agenda en cuanto isLoggedIn se vuelve true.
//
// La sesión se guarda en las SharedPreferences: un usuario que
// reinicia la aplicación la recupera sin volver a iniciar sesión (mientras el token
// no haya expirado - ver AuthInterceptor para el caso del token expirado).
// Diferencia con Flutter: SharedPreferences (la API original de Android,
// de la que el paquete shared_preferences de Flutter tomó prestado el nombre) se lee
// de forma SÍNCRONA. Por lo tanto, la sesión se restaura directamente en el constructor (bloque
// init), sin un método init() asíncrono que haya que esperar antes de mostrar la
// primera pantalla.
// =========================================================================
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,
// un cliente HTTP SIN el interceptor de autenticación: POST /login
// es la única ruta pública del servidor, no hay ningún token que
// enviar (ver RdvMedecinsApplication)
private val http: OkHttpClient,
) {
// estado de la sesión, observado por la UI
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
// el token nunca se MUESTRA: no hace falta convertirlo en un estado de Compose.
// Sin embargo, AuthInterceptor lo lee en un hilo de red:
// @Volatile garantiza que ese hilo siempre vea el último valor
// escrito por el hilo principal.
@Volatile
var accessToken: String? = null
private set
// propiedad calculada: vuelve a leer role en cada acceso (y, cuando se lee durante una
// visualización, suscribe la visualización a los cambios de role)
val isAdmin: Boolean
get() = role == Role.ADMIN
init {
restoreSession()
}
// -----------------------------------------------------------------------
// vuelve a leer una sesión posiblemente guardada durante un inicio anterior
// -----------------------------------------------------------------------
private fun restoreSession() {
val raw = prefs.getString(SESSION_KEY, null) ?: return // ninguna sesión guardada
try {
// la sesión se guardó como un LoginResult
// serializado en JSON (ver logIn): lo volvemos a leer tal cual
applySession(ApiJson.decodeFromString(LoginResult.serializer(), raw))
} catch (e: Exception) {
// contenido ilegible (p. ej. el formato de una versión antigua de
// la aplicación): lo olvidamos, el usuario volverá a iniciar sesión
prefs.edit { remove(SESSION_KEY) }
}
}
// -----------------------------------------------------------------------
// POST /login. "suspend": esta función puede pausarse durante el
// tiempo que el servidor tarda en responder, SIN bloquear el hilo que la llama -
// el equivalente de una función async que devuelve un Future<LoginResult>
// del lado de Dart. Lanza una excepción si el inicio de sesión falla.
// -----------------------------------------------------------------------
suspend fun logIn(login: String, password: String): LoginResult {
// withContext(Dispatchers.IO): el bloque se ejecuta en un hilo
// reservado para entrada/salida. Android PROHÍBE cualquier acceso a la red
// desde el hilo principal (NetworkOnMainThreadException): es
// el que dibuja la UI, nunca debe esperar.
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(): una llamada BLOQUEANTE - inofensiva aquí, estamos en un hilo de
// entrada/salida. use { } cierra la respuesta al final del
// bloque, pase lo que pase (el equivalente del
// try-with-resources de Java, ver el curso de Kotlin).
http.newCall(request).execute().use { response ->
// credenciales incorrectas: el servidor responde 401 Unauthorized
if (!response.isSuccessful) {
throw IOException("Login failed (HTTP ${response.code})")
}
decodeResponse(response.body!!.string(), LoginResult.serializer())
}
}
// de vuelta en el hilo del llamador (el hilo principal):
// es aquí, y no en el hilo de entrada/salida, donde modificamos el
// estado observado por la UI
applySession(result)
prefs.edit { putString(SESSION_KEY, ApiJson.encodeToString(LoginResult.serializer(), result)) }
return result
}
// -----------------------------------------------------------------------
// cierre de sesión: olvidamos la sesión, en memoria y en las preferencias.
// Debe llamarse en el hilo principal (ver 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()
}
}
|
Comentemos este código:
- líneas 51–57: el estado de la sesión, tal como lo observa la interfaz: [isLoggedIn], [login], [name], [role];
- líneas 64–65: [accessToken] nunca se muestra: no hace falta convertirlo en un estado de Compose. Sin embargo, [AuthInterceptor] lo lee en un hilo de red: [@Volatile] garantiza que este hilo siempre vea el último valor escrito por el hilo principal;
- líneas 70–71: [isAdmin]—una propiedad calculada ([get() = ...]), que se vuelve a leer en cada acceso;
- líneas 73–85: el bloque [init] restaura la sesión almacenada, si existe, en cuanto se inicializa el servicio: las preferencias se leen de forma sincrónica. La sesión se almacena como un [LoginResult] serializado en JSON, que luego se vuelve a leer mediante [decodeFromString(LoginResult.serializer(), raw)];
- línea 99: [suspend fun logIn(...)]—una función suspendida: se pausa mientras espera la respuesta del servidor, sin bloquear el hilo que la llama;
- línea 104: [withContext(Dispatchers.IO) { ... }]—la solicitud se ejecuta en un hilo de E/S; el valor de la última expresión del bloque (el [LoginResult] decodificado) es el resultado;
- líneas 106–109: la solicitud de OkHttp: [Request.Builder()], la URL y luego [.post(body.toRequestBody(JSON_TYPE))]—el cuerpo JSON, con su tipo MIME;
- Línea 114: [execute()] ejecuta la solicitud de forma BLOQUEANTE, sin riesgo en un hilo de E/S. [use { response -> ... }] cierra la respuesta al final del bloque, pase lo que pase: el equivalente de `try-with-resources` de Java;
- Líneas 116–117: credenciales incorrectas: el servidor devuelve una respuesta 401 Unauthorized; se lanza una excepción, que [LoginPage] convierte en un mensaje de error;
- líneas 125–126: de vuelta en el hilo que realizó la llamada (el hilo principal), se aplica la sesión, lo que cambia el estado observado (la pantalla pasa automáticamente al calendario), y luego se guarda en las preferencias;
- líneas 134–140: [logOut()]—descarta la sesión, tanto en memoria como en las preferencias.
5.6.3. core/services/AppointmentService.kt
Port de [lib/core/services/appointment_service.dart]: un método por cada ruta de negocio que usa el cliente.
| // =========================================================================
// AppointmentService.kt
// -------------------------------------------------------------------------
// Adaptación de lib/core/services/appointment_service.dart: un método por ruta
// de negocio del servidor NestJS usada por este cliente. Cada método es una
// función "suspend" (ver AuthService.logIn) que devuelve
// directamente los datos útiles ("data" del envoltorio {status, data}), o
// lanza una excepción.
//
// El cliente HTTP recibido en el constructor contiene AuthInterceptor (ver
// RdvMedecinsApplication): por lo tanto, ninguno de los métodos siguientes tiene que
// preocuparse por el token JWT.
//
// Este servicio NO tiene estado observable (nada en él varía una vez construido):
// es una clase ordinaria, sin mutableStateOf - el equivalente del
// simple Provider.value(value: api) (y no ChangeNotifierProvider) de la
// versión Flutter.
// =========================================================================
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,
) {
// -----------------------------------------------------------------------
// las rutas GET
// -----------------------------------------------------------------------
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())
// -----------------------------------------------------------------------
// las rutas POST (reservadas por el servidor para el rol ADMIN)
// -----------------------------------------------------------------------
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" es null en caso de éxito: lo decodificamos como un elemento
// JSON cualquiera, y lo ignoramos
call(postRequest("/deleteAppointment", body), JsonElement.serializer())
}
// -----------------------------------------------------------------------
// construcción de las solicitudes
// -----------------------------------------------------------------------
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()
// -----------------------------------------------------------------------
// ejecuta una solicitud en un hilo de entrada/salida y decodifica la
// respuesta {status, data}. El parámetro genérico <T> y el
// [deserializer] que lo acompaña indican a qué tipo decodificar
// "data" - el papel del parámetro parseData de la versión Flutter.
// -----------------------------------------------------------------------
private suspend fun <T> call(request: Request, deserializer: DeserializationStrategy<T>): T =
withContext(Dispatchers.IO) {
http.newCall(request).execute().use { response ->
// 401 (token rechazado), 403 (rol insuficiente), 404...: el
// cuerpo no es un envoltorio {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()
}
}
|
Comentemos este código:
- líneas 48–55: las tres rutas GET. Cada método es una función [suspend] escrita como una expresión: construye la solicitud y especifica el tipo esperado de [data]. [ListSerializer(Doctor.serializer())] describe un [List<Doctor>];
- líneas 60–72: las dos rutas POST: el cuerpo JSON se codifica a partir de las clases [AddAppointmentRequest] y [DeleteAppointmentRequest]. Para [/deleteAppointment], [data] equivale a [null] si la operación tiene éxito: se decodifica como cualquier elemento JSON ([JsonElement.serializer()]) y se ignora;
- líneas 93–101: [call(...)]—el método estándar: se ejecuta en un hilo de E/S, verifica el código HTTP (401 token rechazado, 403 rol insuficiente: por lo tanto, el cuerpo no es un contenedor [{status, data}]) y luego decodifica con [decodeResponse(...)].
Este servicio no tiene estado observable: nada cambia una vez construido. Es una clase ordinaria, el equivalente del simple [Provider.value(value: api)] (y no de [ChangeNotifierProvider]) en la versión Flutter.
5.7. La capa core/http
5.7.1. core/http/AuthInterceptor.kt
Port de [lib/core/http/auth_http_client.dart]: agregar el token JWT a cada solicitud y cerrar la sesión ante una respuesta 401.
| // =========================================================================
// AuthInterceptor.kt
// -------------------------------------------------------------------------
// Adaptación de lib/core/http/auth_http_client.dart. Dos responsabilidades,
// las mismas que en todas las variantes de este curso:
// 1. agregar el encabezado "Authorization: Bearer <token>" a cada solicitud;
// 2. cerrar la sesión del usuario si el servidor responde 401 Unauthorized
// (token expirado o inválido).
//
// La versión Flutter envolvía el cliente HTTP en una clase propia,
// por falta de un mecanismo de interceptación en el paquete http. OkHttp, en cambio,
// ofrece INTERCEPTORES: objetos por los que pasa cada
// solicitud antes de enviarse, y cada respuesta antes de volver al
// llamador - exactamente la noción de interceptor HTTP de Angular
// (auth.interceptor.ts en la variante Angular de este curso).
// =========================================================================
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 {
// un Handler vinculado al hilo principal: nos permite entregarle
// trabajo desde otro hilo (ver intercept más abajo)
private val mainThread = Handler(Looper.getMainLooper())
// llamado por OkHttp para CADA solicitud, en un hilo de red
override fun intercept(chain: Interceptor.Chain): Response {
// 1. la solicitud original, más el token si lo hay. Una
// solicitud de OkHttp es inmutable: newBuilder() hace una copia
// modificable de ella.
val token = auth.accessToken
val request = if (token == null) {
chain.request()
} else {
chain.request().newBuilder()
.header("Authorization", "Bearer $token")
.build()
}
// 2. dejamos que la solicitud continúe su camino hacia el servidor
val response = chain.proceed(request)
// 3. token rechazado: cerramos la sesión del usuario. Este método
// se ejecuta en un hilo de red; sin embargo, logOut() modifica el
// estado mostrado por la UI: por eso entregamos esta llamada al
// hilo principal (post), sin esperar a que se ejecute - el
// equivalente del unawaited(auth.logOut()) de la versión Flutter.
if (response.code == 401) {
mainThread.post { auth.logOut() }
}
return response
}
}
|
Comentemos este código:
- Línea 26: la clase implementa la interfaz [okhttp3.Interceptor]. OkHttp hace pasar cada solicitud por los interceptores del cliente antes de enviarla, y cada respuesta antes de devolverla a quien llama: es el concepto de los interceptores HTTP de Angular. La versión Flutter, al carecer de un mecanismo así en el paquete [http], envolvía el cliente HTTP en su propia clase;
- línea 30: un [Handler] asociado con el hilo principal ([Looper.getMainLooper()]): permite delegarle trabajo desde otro hilo;
- líneas 41–43: una solicitud de OkHttp es INMUTABLE; [newBuilder()] crea una copia modificable de ella, complementada con el encabezado [Authorization];
- línea 46: [chain.proceed(request)]—la solicitud continúa hacia el servidor; el método devuelve la respuesta;
- líneas 52–53: token rechazado (401): [intercept] se ejecuta en un hilo de red, pero [logOut()] modifica el estado mostrado. Por lo tanto, la llamada se delega al hilo principal ([post { ... }]), sin esperar a que se ejecute: el equivalente de [unawaited(auth.logOut())] en la versión Flutter.
5.8. La capa core/i18n
5.8.1. core/i18n/TranslationsService.kt
Port de [lib/core/i18n/translations_service.dart]: cambiar la interfaz entre francés e inglés sobre la marcha.
| // =========================================================================
// TranslationsService.kt
// -------------------------------------------------------------------------
// Adaptación de lib/core/i18n/translations_service.dart: cambiar la UI entre
// francés e inglés, sobre la marcha, sin reiniciar
// la aplicación. Los diccionarios son los MISMOS archivos JSON que los
// de los clientes Flutter y Vue.js de este curso (fr.json, en.json), colocados aquí
// en app/src/main/assets/i18n/: la carpeta assets/ de un proyecto Android
// se incrusta tal cual en la aplicación (el archivo .apk), como los
// assets declarados en el pubspec.yaml de la versión Flutter.
//
// Nota: la forma "oficial" de Android de traducir una
// aplicación se basa en archivos de recursos res/values/strings.xml
// (inglés) y res/values-fr/strings.xml (francés), y el sistema
// elige el archivo correcto según el idioma del TELÉFONO. Este documento
// conserva los diccionarios JSON compartidos por todas las variantes del curso,
// y el cambio FR/EN dentro de la propia aplicación, como lo hacía la
// aplicación original (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,
) {
// el idioma mostrado: un estado de Compose. Como t(...) más abajo LEE
// esta propiedad, todo texto mostrado con t(...) se vuelve a mostrar
// automáticamente cuando cambia el idioma - sin context.watch<...>() que
// escribir, a diferencia de la versión Flutter.
var currentLanguage by mutableStateOf(prefs.getString(LANGUAGE_KEY, null) ?: DEFAULT_LANGUAGE)
private set
// los diccionarios ya cargados, por idioma ("fr" -> {...})
private val dictionaries = mutableMapOf<String, JsonObject>()
fun changeLanguage(language: String) {
if (language == currentLanguage) {
return
}
dictionary(language) // carga el diccionario ANTES de cambiar el idioma
currentLanguage = language
prefs.edit { putString(LANGUAGE_KEY, language) }
}
// -----------------------------------------------------------------------
// t("LOGIN.TITLE"): recorre el diccionario del idioma actual
// segmento por segmento ("LOGIN", luego "TITLE"). Si no se encuentra la clave,
// se devuelve la propia clave: el texto faltante permanece así
// visible en pantalla, sin hacer que la aplicación falle.
// -----------------------------------------------------------------------
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
}
// -----------------------------------------------------------------------
// el diccionario de un idioma, cargado la primera vez que se necesita y luego conservado en
// memoria. getOrPut: devuelve el valor asociado a la clave, o ejecuta
// el bloque, almacena su resultado y lo devuelve. La lectura es
// síncrona: los dos archivos pesan apenas unos cientos de
// bytes, leerlos es instantáneo.
// -----------------------------------------------------------------------
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"
}
}
|
Comentemos este código:
- Líneas 43–44: [currentLanguage]—un estado observable. Como [t(...)] LEE esta propiedad, cualquier función @Composable que muestre texto con [t(...)] se recompone automáticamente cuando cambia el idioma: no hace falta escribir ningún [context.watch<...>()];
- líneas 49–55: [changeLanguage(...)]—carga el diccionario ANTES de cambiar de idioma, y luego guarda la selección en las preferencias;
- Líneas 64–70: [t("LOGIN.TITLE")]—recorre el diccionario segmento por segmento. [as?] es la conversión de tipo “segura” de Kotlin: devuelve [null] (en lugar de lanzar una excepción) si el objeto no es del tipo solicitado; combinada con [?: return key], hace que se devuelva la propia clave en cuanto no se encuentra un segmento: el texto faltante permanece visible en la pantalla;
- líneas 80–83: [dictionary(language)] – [getOrPut] devuelve el diccionario ya cargado, o ejecuta el bloque (que lee [assets/i18n/<language>.json]), almacena su resultado y lo devuelve. La lectura es sincrónica: ambos archivos pesan apenas unos cientos de bytes.
5.8.2. assets/i18n/fr.json y assets/i18n/en.json
Los diccionarios son los de los clientes Flutter y Vue.js, con cuatro ajustes menores: el título de la aplicación, las etiquetas del selector de fecha ([DOCTOR_DAY_PICKER.PICK_DAY], [OK], [CANCEL]), el mensaje de invitación del calendario (“tocar” en lugar de “hacer clic”) y la eliminación de una clave que ya no es necesaria. Extracto de [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"
},
|
Nota: el método “oficial” de Android para traducir una aplicación se basa en archivos de recursos [res/values/strings.xml] (inglés) y [res/values-fr/strings.xml] (francés), y el sistema selecciona el archivo correcto según el idioma del TELÉFONO. Este documento conserva los diccionarios JSON comunes a todas las variantes del curso y el cambio de idioma FR/EN dentro de la propia aplicación, tal como en la aplicación original (2014). Una consecuencia perceptible: los componentes proporcionados por el sistema, como el selector de fecha, siguen el idioma configurado en el teléfono y no el idioma elegido dentro de la aplicación.
5.9. La capa core/ui
5.9.1. core/ui/DropdownList.kt
Una lista desplegable genérica, usada dos veces: para seleccionar un médico y para seleccionar un paciente. Flutter tenía un widget listo para usar, [DropdownButtonFormField]; Material 3 para Compose ofrece una combinación de tres elementos, agrupados aquí de una vez por todas.
| // =========================================================================
// DropdownList.kt
// -------------------------------------------------------------------------
// Una lista desplegable genérica (el <select> de HTML), usada dos veces
// en este cliente: elección del médico (DoctorDayPicker) y elección del paciente
// (BookingDialog). La versión Flutter tenía un widget listo para usar
// para esto, DropdownButtonFormField; Material 3 para Compose ofrece un
// ensamblaje de tres elementos - ExposedDropdownMenuBox, un campo de
// texto de solo lectura y el menú ExposedDropdownMenu - que aquí agrupamos
// una sola vez.
//
// La función es GENÉRICA (<T>): muestra una lista de médicos
// igual que una lista de pacientes. [itemLabel] indica cómo mostrar un elemento,
// [idOf] cómo identificarlo.
// =========================================================================
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
// las API ExposedDropdownMenu* todavía están marcadas como "experimentales" por
// Material 3: @OptIn indica que las usamos a sabiendas
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun <T> DropdownList(
label: String,
placeholder: String, // texto mostrado mientras no se haya elegido nada
items: List<T>,
selectedId: Int?, // id del elemento elegido, o null
idOf: (T) -> Int,
itemLabel: (T) -> String,
onSelect: (Int) -> Unit,
modifier: Modifier = Modifier,
) {
// menú abierto o cerrado: un estado LOCAL a esta función, recordado de una
// visualización a la siguiente por remember (ver capítulo 3)
var menuOpen by remember { mutableStateOf(false) }
val selected = items.firstOrNull { idOf(it) == selectedId }
ExposedDropdownMenuBox(
expanded = menuOpen,
onExpandedChange = { menuOpen = it },
modifier = modifier,
) {
// el campo que muestra la elección actual; menuAnchor(...) lo convierte en
// el punto de anclaje del menú (un clic en él abre el 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(),
)
// el menú propiamente dicho: un DropdownMenuItem por elemento
ExposedDropdownMenu(expanded = menuOpen, onDismissRequest = { menuOpen = false }) {
items.forEach { item ->
DropdownMenuItem(
text = { Text(itemLabel(item)) },
onClick = {
onSelect(idOf(item))
menuOpen = false
},
)
}
}
}
}
|
Analicemos este código:
- líneas 38–46: [fun <T> DropdownList(...)]—una función @Composable GENÉRICA: muestra tanto médicos como pacientes. [idOf] especifica cómo identificar un elemento, [itemLabel] cómo mostrarlo y [onSelect] indica el identificador elegido;
- línea 46: [modifier: Modifier = Modifier]—la convención de Compose: todo componente reutilizable acepta un modifier, que se aplica a su elemento raíz, para que quien lo llama pueda ajustar su tamaño o sus márgenes;
- línea 50: [var menuOpen by remember { mutableStateOf(false) }]—el estado local del componente: menú abierto o cerrado;
- línea 53: [ExposedDropdownMenuBox]—el contenedor, que administra la apertura y el cierre del menú;
- líneas 60–69: el campo de solo lectura que muestra la selección actual. [menuAnchor(...)] sirve como punto de anclaje del menú: al tocarlo, se abre el menú;
- líneas 73–79: el menú en sí: un [DropdownMenuItem] por elemento, generado mediante un bucle [forEach].
5.10. La capa features
Como en todas las versiones del curso, cada funcionalidad de la pantalla es un componente: recibe sus datos como parámetros (entradas) y comunica las acciones del usuario mediante funciones (salidas). Solo [LoginPage] llama directamente a un servicio ([AuthService]).
5.10.1. features/login/LoginPage.kt
Port de [lib/features/login/login_page.dart]: la pantalla de inicio de sesión.
| // =========================================================================
// LoginPage.kt
// -------------------------------------------------------------------------
// Adaptación de lib/features/login/login_page.dart: la pantalla de inicio de sesión
// (login, contraseña, botón "Log in", mensaje de error).
//
// La versión Flutter necesitaba DOS clases (_LoginForm y
// _LoginFormState) y dos TextEditingController que liberar en
// dispose(). Aquí basta una sola función @Composable: sus estados locales se
// declaran directamente en la función, con 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
// estado local de la pantalla
// rememberSaveable: el valor se recuerda de una visualización a la siguiente
// Y sobrevive a la recreación de la Activity (rotación de pantalla) - un
// login a medio escribir no se pierde si se gira el teléfono.
var login by rememberSaveable { mutableStateOf("") }
var password by rememberSaveable { mutableStateOf("") }
// la clave de traducción del mensaje de error (y no el mensaje traducido:
// así sigue un cambio de idioma), o null
var error by rememberSaveable { mutableStateOf<String?>(null) }
// solo remember: un inicio de sesión en curso no necesita sobrevivir a una rotación
var inProgress by remember { mutableStateOf(false) }
// un ámbito de corrutinas vinculado a esta pantalla: las corrutinas
// lanzadas en él se cancelan si la pantalla desaparece
val scope = rememberCoroutineScope()
// una función local (ver el curso de Kotlin): la validación del
// formulario, llamada por el botón Y por la tecla "Done" del teclado
fun submit() {
if (login.isBlank() || password.isEmpty() || inProgress) {
return
}
error = null
inProgress = true
scope.launch {
try {
// en caso de éxito, AuthService pone isLoggedIn en true:
// App.kt reemplaza entonces AUTOMÁTICAMENTE esta pantalla por
// la agenda - aquí no hay nada más que hacer
auth.logIn(login.trim(), password)
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
// la causa exacta (servidor inaccesible, credenciales incorrectas...)
// se escribe en el registro de Android (pestaña Logcat de Android
// Studio); el usuario ve un mensaje simple
Log.w("RdvMedecins", "login failed", e)
error = "LOGIN.ERROR"
} finally {
inProgress = false
}
}
}
// Box + Alignment.TopCenter: la tarjeta se centra horizontalmente
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,
// tecla "Next" del teclado: pasa al campo siguiente
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
modifier = Modifier.fillMaxWidth(),
)
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text(t("LOGIN.PASSWORD_LABEL")) },
singleLine = true,
// muestra puntos en lugar de los caracteres
visualTransformation = PasswordVisualTransformation(),
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Password,
imeAction = ImeAction.Done,
),
// tecla "Done" del teclado: envía el formulario
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,
)
}
}
}
}
|
Comentemos este código:
- líneas 60–66: los estados locales de la pantalla. [rememberSaveable] para el nombre de usuario, la contraseña y el mensaje de error: estos estados persisten a través de una rotación de pantalla. [remember] se usa solo para [inProgress]: una conexión en curso no necesita sobrevivir a ella;
- línea 70: [rememberCoroutineScope()]—un ámbito de corrutinas asociado con esta pantalla: las corrutinas lanzadas dentro de él se cancelan si la pantalla desaparece;
- línea 74: [fun submit()]—una función LOCAL (declarada dentro de otra función; véase el curso de Kotlin), llamada por el botón y por la tecla “Listo” del teclado;
- Líneas 80–93: [scope.launch { ... }] inicia la conexión en una corrutina. Si tiene éxito, no queda nada más por hacer: [AuthService] cambia [isLoggedIn] a [true], y [App.kt] reemplaza AUTOMÁTICAMENTE esta pantalla por la agenda. Si la operación falla, se almacena la CLAVE del mensaje de error (no el mensaje traducido: así se garantiza la coherencia cuando cambia el idioma);
- línea 92: [Log.w(...)]—la causa exacta del fallo (servidor inaccesible, credenciales incorrectas, etc.) se registra en el registro de Android, concretamente en la pestaña [Logcat] de Android Studio. Gracias a este registro se diagnosticó el problema con la dirección [10.0.2.2], descrito en el Capítulo 5;
- líneas 120–122: [OutlinedTextField(value = login, onValueChange = { login = it }, ...)]—el campo muestra el estado y lo actualiza con cada pulsación de tecla: el [v-model] de Vue.js escrito en dos partes;
- línea 126: [ImeAction.Next]—la tecla “Siguiente” del teclado virtual pasa al campo siguiente;
- líneas 136–142: la contraseña: [PasswordVisualTransformation()] muestra puntos en lugar de caracteres; [KeyboardType.Password] desactiva las sugerencias del teclado; [onDone] envía el formulario;
- líneas 147–152: el botón, que se deshabilita ([enabled = !inProgress]) durante el proceso de inicio de sesión, con la etiqueta “Signing in...”.
5.10.2. features/doctordaypicker/DoctorDayPicker.kt
Port de [lib/features/doctor_day_picker/doctor_day_picker.dart]: la selección del médico y del día.
| // =========================================================================
// DoctorDayPicker.kt
// -------------------------------------------------------------------------
// Adaptación de lib/features/doctor_day_picker/doctor_day_picker.dart: la
// elección de un médico (lista desplegable) y de un día (calendario), y luego el
// botón "View schedule".
//
// Este componente no conoce ni el servidor ni AppointmentService: recibe la lista
// de médicos como PARÁMETRO (entrada) e informa la elección del usuario
// mediante la función onSearch (salida) - el mismo contrato que en todas
// las variantes del curso (props/emit en Vue.js, parámetros del constructor
// en 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
// estado local, conservado entre rotaciones de pantalla
var doctorId by rememberSaveable { mutableStateOf<Int?>(null) }
// el día elegido, en formato "yyyy-MM-dd": LocalDate.toString() produce
// exactamente este formato (ISO 8601), el que espera el servidor - ya no hace
// falta el paquete intl de la versión Flutter
var day by rememberSaveable { mutableStateOf(LocalDate.now().toString()) }
var calendarOpen by remember { mutableStateOf(false) }
// los tres elementos del componente, preparados una sola vez y luego dispuestos
// de forma distinta según el ancho disponible (ver más abajo). Son
// LAMBDAS @Composable: solo se MUESTRAN cuando se las llama.
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")) },
// el ícono de calendario abre el selector de fecha
trailingIcon = {
IconButton(onClick = { calendarOpen = true }) {
Icon(Icons.Filled.DateRange, contentDescription = t("DOCTOR_DAY_PICKER.PICK_DAY"))
}
},
modifier = modifier,
)
}
val scheduleButton = @Composable { modifier: Modifier ->
Button(
// botón deshabilitado mientras no se haya elegido un médico
enabled = doctorId != null,
onClick = { doctorId?.let { onSearch(it, day) } },
modifier = modifier,
) {
Text(t("DOCTOR_DAY_PICKER.VIEW_SCHEDULE"))
}
}
Card(modifier = Modifier.fillMaxWidth()) {
// BoxWithConstraints: da acceso al ancho REALMENTE
// disponible (maxWidth) - el LayoutBuilder de la versión Flutter.
// Pantalla estrecha (teléfono en vertical): los tres elementos uno
// debajo del otro; pantalla ancha: en una sola fila.
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(...): reparte el ancho entre los tres
// elementos (5/12, 4/12, 3/12) - el flex: 5, 4, 3 del
// Expanded de la versión Flutter
doctorField(Modifier.weight(5f))
dayField(Modifier.weight(4f))
scheduleButton(Modifier.weight(3f))
}
}
}
}
// el calendario: un diálogo mostrado mientras
// calendarOpen sea true (el mismo principio que BookingDialog)
if (calendarOpen) {
// DatePicker trabaja en milisegundos desde el 1 de enero de 1970,
// a medianoche UTC: convertimos en ambos sentidos con 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)
}
}
}
|
Comentemos este código:
- líneas 54–56: las entradas y salidas del componente: la lista de médicos y la función [onSearch(doctorId, day)]. Los nombres dados a los parámetros de tipo función ([doctorId: Int, day: String]) son solo documentación;
- línea 65: el día seleccionado, almacenado en el formato [yyyy-MM-dd]: [LocalDate.now().toString()] produce exactamente este formato (ISO 8601), que es el que espera el servidor. El paquete [intl] de la versión Flutter ya no es necesario;
- líneas 71–99: los tres elementos del componente, preparados como LAMBDAS @Composable ([@Composable { modifier: Modifier -> ... }]): solo se muestran cuando se las llama, con el modifier deseado. Esto permite disponerlos de dos maneras distintas sin tener que escribir su código dos veces;
- líneas 91–93: el campo del día, que es de solo lectura; el ícono de calendario a la derecha abre el selector de fecha;
- líneas 115–132: [BoxWithConstraints] da acceso al ancho disponible ([maxWidth]): el equivalente del [LayoutBuilder] de la versión Flutter. Menos de 600 dp: los tres elementos se apilan uno debajo del otro ([Column]); de lo contrario, en una sola línea ([Row]), con pesos 5/4/3 ([Modifier.weight(...)], el equivalente de [Expanded(flex: ...)] en Flutter);
- Líneas 140–163: el selector de fecha: un [DatePickerDialog] que se muestra mientras [calendarOpen] sea igual a [true]. El [DatePicker] de Material 3 trabaja en milisegundos desde la medianoche del 1 de enero de 1970 (UTC): la conversión funciona en ambos sentidos con [java.time] ([atStartOfDay(ZoneOffset.UTC)] y [Instant.ofEpochMilli(...)]).
5.10.3. features/schedule/ScheduleView.kt
Port de [lib/features/schedule/schedule_view.dart]: la agenda diaria de un médico.
| // =========================================================================
// ScheduleView.kt
// -------------------------------------------------------------------------
// Adaptación de lib/features/schedule/schedule_view.dart: la visualización de
// la agenda de un médico para un día - una fila por franja, libre o
// ocupada, con un botón "Book" (franja libre) o "Cancel" (franja
// ocupada) para el rol ADMIN.
//
// Al igual que DoctorDayPicker, este componente es "stateless": todo lo que
// muestra se le entrega como parámetro, e informa los clics mediante
// onBook / onCancel. Es AppViewModel quien llama al servidor.
// =========================================================================
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
// ancho de la columna de horario ("10:40 - 11:00")
private val TIME_COLUMN_WIDTH = 116.dp
// "8:00", "8:20"...: los minutos siempre con dos dígitos
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
// todavía no hay agenda: un simple mensaje de invitación
if (schedule == null) {
Text(
text = t("SCHEDULE.EMPTY_STATE"),
color = MaterialTheme.colorScheme.outline,
modifier = Modifier.padding(vertical = 24.dp),
)
return // una función @Composable puede detenerse aquí: no se muestra nada más
}
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,
)
// encabezados de columna: el mismo ancho de primera columna que
// en cada fila (TIME_COLUMN_WIDTH), para que las columnas
// queden alineadas
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)) // el espaciado entre las columnas de las filas
Text(t("SCHEDULE.COLUMN_STATUS"), fontWeight = FontWeight.Bold)
}
HorizontalDivider()
// una fila por franja. Un simple bucle forEach, en una
// Column: aquí no se usa LazyColumn (la lista "perezosa" de Compose,
// que solo construye las filas visibles), porque esta
// agenda ya está colocada en una Column desplazable (ver App.kt),
// y una docena de filas no justifican esta optimización.
schedule.slots.forEach { daySlot ->
SlotRow(daySlot, canEdit, onBook, onCancel)
HorizontalDivider()
}
}
}
}
// -------------------------------------------------------------------------
// una fila de la agenda: horario | estado (libre o paciente) | botón
// -------------------------------------------------------------------------
@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),
) {
// el horario: un ancho fijo, el mismo que el del encabezado
Text(
text = "${formatTime(slot.startHour, slot.startMinute)} - ${formatTime(slot.endHour, slot.endMinute)}",
modifier = Modifier.width(TIME_COLUMN_WIDTH),
)
// el estado: una insignia verde "Free", o el nombre del paciente
Surface(
shape = RoundedCornerShape(8.dp),
color = if (appointment == null) Color(0xFFC8E6C9) else MaterialTheme.colorScheme.secondaryContainer,
// weight(1f): el estado ocupa todo el ancho que dejan libre
// el horario y el botón
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),
)
}
// el botón solo existe para el rol ADMIN; reserva una franja
// libre, o cancela la cita de una franja ocupada
if (canEdit) {
// SIN weight(...) aquí: el botón toma el ancho de su texto.
// Una primera versión le imponía una cuarta parte de la fila
// (weight(0.25f)): en un teléfono en vertical, la etiqueta
// "Réserver" (UI en francés) se truncaba entonces como "Rése" (ver capítulo 5).
OutlinedButton(
onClick = { if (appointment == null) onBook(slot) else onCancel(appointment) },
// relleno interno reducido (24 dp por defecto a cada lado)
contentPadding = PaddingValues(horizontal = 12.dp),
// un ancho mínimo común: los botones "Book" y
// "Cancel" tienen así el mismo ancho, y las columnas permanecen
// alineadas de una fila a la siguiente
modifier = Modifier.widthIn(min = 96.dp),
) {
Text(if (appointment == null) t("SCHEDULE.BOOK") else t("SCHEDULE.CANCEL_APPOINTMENT"), maxLines = 1)
}
}
}
}
|
Comentemos este código:
- líneas 60–66: aún no hay agenda: un mensaje de invitación, seguido de [return]. Una función @Composable puede terminar aquí: no se emite nada más;
- líneas 79–82: los encabezados de las columnas: la primera columna tiene el mismo ancho fijo ([TIME_COLUMN_WIDTH]) que la hora de cada fila, de modo que las columnas queden alineadas. Compose no tiene un equivalente de [DataTable] de Flutter: la tabla se construye con [Row];
- Líneas 90–91: una línea por horario, con un simple bucle [forEach] dentro de una [Column]. Sin [LazyColumn] (la lista “diferida” de Compose, que construye solo las líneas visibles): la agenda ya está colocada en una columna con desplazamiento (véase [App.kt]); un [LazyColumn] dentro de una columna con desplazamiento provoca, de hecho, un error en tiempo de ejecución, y una docena de líneas no justifica esta optimización;
- líneas 122–128: el estado: una insignia verde “Free” o el nombre del paciente. [Modifier.weight(1f)]: el estado ocupa todo el ancho que dejan libre la hora y el botón;
- líneas 139–151: el botón, solo para el rol ADMIN ([if (canEdit)]): “Book” en un horario disponible, “Cancel” en un horario reservado. No tiene un ancho fijo: ocupa el ancho de su texto, con un ancho mínimo común. Una versión anterior lo limitaba a un cuarto de la línea: en un teléfono en modo vertical, la etiqueta quedaba entonces truncada (véase el Capítulo 5).
5.10.4. features/bookingdialog/BookingDialog.kt
Port de [lib/features/booking_dialog/booking_dialog.dart]: el cuadro de diálogo de reserva.
| // =========================================================================
// BookingDialog.kt
// -------------------------------------------------------------------------
// Adaptación de lib/features/booking_dialog/booking_dialog.dart: el diálogo de
// reserva de una franja (elección del paciente, luego
// "Confirm" o "Cancel").
//
// Diferencia estructural con la versión Flutter: Flutter ABRÍA el
// diálogo con showDialog(...) y ESPERABA su resultado (un Future<int?>).
// En Compose, un diálogo es un elemento de visualización como cualquier
// otro: AlertDialog se muestra mientras la función que lo invoca
// lo llame (ver App.kt: mientras vm.slotBeingBooked no sea
// null). No "devuelve" nada: informa la elección mediante dos
// funciones, onConfirm y onClose - exactamente los dos eventos
// "confirm" / "close" del BookingDialog.vue de la variante Vue.js.
// =========================================================================
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
// el paciente elegido (su id), o null mientras no se haya elegido ninguno
var clientId by rememberSaveable { mutableStateOf<Int?>(null) }
AlertDialog(
// toque fuera del diálogo, o tecla "atrás" del teléfono
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": deshabilitado mientras no se haya elegido un paciente
confirmButton = {
Button(
enabled = clientId != null,
onClick = { clientId?.let(onConfirm) },
) { Text(t("BOOKING_DIALOG.CONFIRM")) }
},
dismissButton = {
TextButton(onClick = onClose) { Text(t("BOOKING_DIALOG.CANCEL")) }
},
)
}
|
Comentemos este código:
- líneas 8–15: el comentario de encabezado resume la diferencia estructural con la versión Flutter. Flutter ABRÍA el cuadro de diálogo con [showDialog(...)] y ESPERABA su resultado (un [Future<int?>]). En Compose, un cuadro de diálogo es un elemento de vista como cualquier otro: permanece visible mientras la función que lo llama siga llamándolo. No “devuelve” nada: comunica la selección mediante dos funciones, [onConfirm] y [onClose]—exactamente los dos eventos [confirm] / [close] del componente [BookingDialog.vue] en la variante Vue.js;
- línea 48: el paciente seleccionado: [rememberSaveable]; el paciente sigue seleccionado incluso después de que la pantalla rote con el cuadro de diálogo abierto;
- líneas 50–52: [AlertDialog(...)]—el cuadro de diálogo de Material 3, con un título, un contenido ([text]) y dos botones. [onDismissRequest] se llama cuando el usuario toca fuera del cuadro de diálogo o presiona el botón “Atrás” del teléfono;
- líneas 73–76: el botón “Confirm”, que permanece deshabilitado hasta que se selecciona un paciente. [clientId?.let(onConfirm)]: si [clientId] no es [null], se llama a [onConfirm] con su valor.
5.11. Guía paso a paso para usar la aplicación
Las siguientes capturas de pantalla se tomaron en el emulador Pixel 8 (Android 17) del Capítulo 1, con la aplicación conectada al servidor mediante [adb reverse] (véase el Capítulo 5), de ahí la URL [http://localhost:8080].
5.11.1. 1. Pantalla de inicio de sesión
En el primer inicio no hay ninguna sesión almacenada: [AuthService.isLoggedIn] es igual a [false], y [App.kt] muestra [LoginPage]. Un intento con una combinación de usuario y contraseña no válida, o con un servidor inaccesible, muestra el mensaje de error (clave [LOGIN.ERROR]):


5.11.2. 2. Inicio de sesión como administrador (rol ADMIN, acceso completo)
Una vez iniciada la sesión con [admin]/[admin], la pantalla de inicio de sesión da paso a la selección del médico y del día; la barra de título muestra la insignia del rol y el botón de cierre de sesión. En segundo plano, [AppViewModel] ha cargado los médicos y los pacientes:


- A la izquierda, la pantalla inmediatamente después de iniciar sesión: el botón “View schedule” está deshabilitado hasta que se selecciona un médico;
- a la derecha, la lista desplegable de médicos, abierta.
El ícono de calendario abre el selector de fecha; “View schedule” muestra la agenda del médico para el día seleccionado:


“Book” abre el cuadro de diálogo de selección de paciente; “Confirm” envía la reserva al servidor y la agenda se vuelve a cargar: el horario aparece como reservado, con un botón “Cancel”:



“Cancel”, al tocarlo en un horario reservado, elimina la cita y el horario vuelve a quedar disponible. El botón “FR” cambia toda la pantalla al francés, incluidas las etiquetas de la agenda; el botón de cierre de sesión devuelve a la pantalla de inicio de sesión:


5.11.3. 3. Inicio de sesión como usuario (rol USER, solo lectura)
Una conexión con [user]/[user] muestra la insignia “USER”. La agenda sigue siendo visible, pero no aparecen botones “Book”/“Cancel” ([canEdit] equivale a [false]); de todos modos, el servidor denegaría estas dos acciones a este rol (403 Forbidden, véase el Capítulo 2).

5.12. Lo que queda fuera del alcance o se pospone
- Como los demás clientes de este curso, no hay un modo de demostración/depuración específico.
- No se introducen retrasos artificiales de red en el cliente con fines didácticos.
- No hay navegación entre pantallas: la aplicación cabe en una sola pantalla (sin contar los cuadros de diálogo). Una aplicación Android más completa usaría la biblioteca [Navigation Compose].
- No hay pruebas automatizadas: las carpetas [src/test] y [src/androidTest] generadas por Android Studio se eliminaron del proyecto.