9. Comunicación con el servidor
El servidor RdvMedecins está en ejecución (consulte el capítulo anterior, con [CAPTCHA_TEST=test] en su archivo [.env] para las pruebas). Los ejemplos 22 a 25 lo consultan desde el teléfono.
9.0.1. ¿Dónde está el servidor?
Una aplicación web servida por el propio servidor no tiene que plantearse esta pregunta: sus solicitudes van al mismo origen que la página. Una aplicación MÓVIL sí: se le debe indicar la dirección completa del servidor. Sin embargo, el teléfono no es la computadora que ejecuta el servidor:
| // =========================================================================
// common/Config.kt - ¿DÓNDE está el servidor JSON? (ejemplos 22 a 25)
// -------------------------------------------------------------------------
// Una aplicación web servida por el propio servidor no tiene que hacerse
// esta pregunta: sus solicitudes van al MISMO origen que la
// página. Una aplicación MÓVIL sí: hay que darle la dirección completa
// del servidor. Pero el teléfono no es la computadora que ejecuta el
// servidor:
// - "localhost", para el teléfono (o el emulador), es ÉL MISMO. El
// comando adb reverse tcp:8080 tcp:8080 lo soluciona: enlaza el
// puerto 8080 del teléfono con el puerto 8080 de la computadora, a través del cable USB
// (o, para el emulador, directamente). Es la solución elegida por
// defecto: http://localhost:8080;
// - el emulador de Android también ve la computadora en la dirección especial
// 10.0.2.2;
// - un teléfono real, conectado a la misma red Wi-Fi que la computadora, puede
// usar la dirección de la computadora en esa red (192.168.1.20...).
// La dirección se fija en tiempo de COMPILACIÓN (BuildConfig, cf. app/build.gradle.kts):
// gradlew installDebug -Pserver=http://10.0.2.2:8080
// =========================================================================
package fr.stahe.examples.common
import fr.stahe.examples.BuildConfig
object Config {
val serverUrl: String = BuildConfig.SERVER_URL
}
|
- “localhost”, para el teléfono (o el emulador), es ÉL MISMO. El comando [adb reverse tcp:8080 tcp:8080] conecta el puerto 8080 del teléfono con el puerto 8080 de la computadora mediante el cable USB (o directamente, en el caso del emulador). Esta es la solución predeterminada: [http://localhost:8080]. El comando debe volver a ejecutarse cada vez que se inicia el emulador;
- el emulador también ve la computadora en la dirección especial [10.0.2.2];
- un teléfono real conectado a la misma red Wi-Fi que la computadora puede usar la dirección de la computadora en esa red ([192.168.1.20]...), siempre que el firewall de la computadora permita el tráfico por el puerto 8080.
La dirección es un campo de la clase [BuildConfig], generada en tiempo de compilación (consulte [app/build.gradle.kts], ejemplo 01); se puede cambiar sin modificar el código:
| gradlew installDebug -Pserver=http://10.0.2.2:8080
|
Por último, el manifiesto solicita el permiso [INTERNET] y permite el tráfico HTTP “sin cifrar” ([usesCleartextTraffic]): a partir de [Android] 9, de forma predeterminada solo se permite HTTPS.
9.1. Ejemplo 22: una primera solicitud HTTP
Se solicita un CAPTCHA al servidor: [GET /api/captcha] devuelve [{ "id": "...", "svg": "<svg ...>" }]. El cliente HTTP es [OkHttp], el más utilizado en [Android] (el equivalente del paquete [http] de [Flutter]).
| // =========================================================================
// ex22/Ex22Activity.kt - una primera solicitud HTTP al servidor
// -------------------------------------------------------------------------
// El servidor JSON de RdvMedecins debe estar en ejecución (puerto 8080). Le pedimos un
// captcha: GET /api/captcha -> { "id": "...", "svg": "<svg ...>" }.
//
// - OkHttp, el cliente HTTP más usado en Android: describimos la
// solicitud (Request), el cliente la ejecuta (newCall(...).execute()) y
// devuelve la respuesta: su código de estado (code), sus encabezados
// (headers), su cuerpo (body);
// - execute() BLOQUEA hasta recibir la respuesta: Android prohíbe llamarlo
// en el hilo de la pantalla. withContext(Dispatchers.IO)
// lo ejecuta en otro hilo, y la corrutina ESPERA el resultado;
// - Json.parseToJsonElement(text): el cuerpo JSON -> objetos Kotlin;
// - la dirección del servidor depende de dónde se ejecuta la aplicación
// (emulador, teléfono...): cf. common/Config.kt;
// - tres estados que mostrar: cargando, exitoso, con error;
// - la imagen del captcha es SVG: cf. common/SvgImage.kt.
// =========================================================================
package fr.stahe.examples.ex22
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.border
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.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.Config
import fr.stahe.examples.common.SvgImage
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import okhttp3.OkHttpClient
import okhttp3.Request
// lo que devuelve GET /api/captcha
data class Captcha(val id: String, val svg: String)
// un cliente HTTP: un objeto costoso de crear, que se crea UNA SOLA VEZ
val client = OkHttpClient()
// la solicitud: una función SUSPEND, que devuelve el captcha o lanza una excepción
suspend fun readCaptcha(): Captcha = withContext(Dispatchers.IO) {
val request = Request.Builder().url("${Config.serverUrl}/api/captcha").build()
client.newCall(request).execute().use { response ->
// OkHttp NO lanza una excepción ante una respuesta de error (4xx,
// 5xx): se verifica el código de estado
if (!response.isSuccessful) {
throw Exception("the server responded ${response.code} ${response.message}")
}
val json = Json.parseToJsonElement(response.body!!.string()).jsonObject
Captcha(json["id"]!!.jsonPrimitive.content, json["svg"]!!.jsonPrimitive.content)
}
}
class Ex22Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { CaptchaPage() } }
}
}
@Composable
fun CaptchaPage() {
var captcha by remember { mutableStateOf<Captcha?>(null) }
var loading by remember { mutableStateOf(true) }
var error by remember { mutableStateOf<String?>(null) }
var requestCount by remember { mutableIntStateOf(0) }
// el número de la SOLICITUD: cambiarlo reinicia el efecto de abajo
var demand by remember { mutableIntStateOf(0) }
// la solicitud, apenas aparece la pantalla (solicitud = 0), y luego en cada
// nueva solicitud. Si llega una solicitud antes de la respuesta a la
// anterior, la corrutina anterior se CANCELA: su respuesta obsoleta
// nunca se mostrará
LaunchedEffect(demand) {
loading = true
error = null
try {
captcha = readCaptcha()
requestCount++
} catch (e: CancellationException) {
throw e // la corrutina fue cancelada (nueva solicitud): nada que mostrar
} catch (e: Exception) {
// ninguna respuesta (servidor detenido, dirección incorrecta...), o error
error = e.message ?: e.toString()
captcha = null
}
loading = false
}
ExamplePage("Example 22 - a first HTTP request") {
Text("Server: ${Config.serverUrl}", color = Color.Gray)
Spacer(Modifier.height(12.dp))
if (loading) LinearProgressIndicator(Modifier.fillMaxWidth())
error?.let {
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFEBEE))) {
Text("Unable to get a captcha: $it.\nIs the RdvMedecins JSON server running (port 8080)?", Modifier.padding(12.dp))
}
}
val c = captcha
if (c != null && !loading) {
SvgImage(
c.svg,
height = 60.dp,
modifier = Modifier.border(1.dp, Color(0xFFE0E0E0), RoundedCornerShape(6.dp)).padding(4.dp),
)
Spacer(Modifier.height(8.dp))
Text("id: ${c.id}", fontFamily = FontFamily.Monospace, fontSize = 11.sp)
}
Spacer(Modifier.height(12.dp))
Button(onClick = { demand++ }, enabled = !loading) { Text("Another image") }
Spacer(Modifier.height(8.dp))
Text("$requestCount successful request(s)", color = Color.Gray)
}
}
|
- Línea 66: un cliente HTTP, un objeto costoso de crear, que se crea UNA SOLA VEZ;
- Líneas 69–71: la solicitud, una función SUSPEND. Se describe la solicitud ([Request]); el cliente la ejecuta ([newCall(...).execute()]) y devuelve la respuesta: su código de estado, sus encabezados y su cuerpo. [execute()] BLOQUEA hasta recibir la respuesta: [Android] prohíbe llamarla en el hilo de ejecución de la pantalla ([NetworkOnMainThreadException]). [withContext(Dispatchers.IO)] la ejecuta en un hilo reservado para E/S, y la corrutina ESPERA el resultado;
- Líneas 74–75: [OkHttp] no lanza una excepción ante una respuesta de error (4xx, 5xx); en cambio, hay que verificar el código de estado. Sin embargo, sí lanza una [IOException] si no hay ninguna respuesta (servidor caído, dirección incorrecta);
- líneas 77–78: el cuerpo JSON, leído “manualmente”: [jsonObject], [jsonPrimitive.content];
- líneas 103–116: la solicitud la dispara un [LaunchedEffect] cuya clave es un número de SOLICITUD: el botón “Another image” lo incrementa, lo que reinicia el efecto. Si llega una solicitud antes de que la anterior haya obtenido respuesta, la corrutina anterior se CANCELA: su respuesta, ya obsoleta, nunca se mostrará;
- líneas 122–136: tres estados que mostrar: en curso (una barra de progreso), error y éxito.
La imagen del CAPTCHA está en formato SVG, que [Android] no puede mostrar por sí solo: la biblioteca [AndroidSVG] la convierte en una imagen ([Bitmap]):
| // =========================================================================
// common/SvgImage.kt - dibujar una imagen SVG dada como texto
// -------------------------------------------------------------------------
// La imagen del captcha la genera el servidor, en formato SVG (un texto
// que describe un dibujo). Android no puede mostrarla por sí solo: la
// biblioteca AndroidSVG la dibuja en una imagen (un Bitmap), que
// Compose muestra con el componente Image.
// =========================================================================
package fr.stahe.examples.common
import android.graphics.Bitmap
import android.graphics.Canvas
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.caverock.androidsvg.SVG
@Composable
fun SvgImage(svg: String, modifier: Modifier = Modifier, height: Dp = 50.dp, description: String? = null) {
// el dibujo solo se rehace si cambia el texto SVG (remember(svg))
val image = remember(svg) {
val document = SVG.getFromString(svg)
// dibujada 3 veces más grande que su tamaño "natural": una imagen nítida
val scale = 3f
val width = (document.documentWidth.takeIf { it > 0 } ?: 150f)
val tall = (document.documentHeight.takeIf { it > 0 } ?: 50f)
val bitmap = Bitmap.createBitmap((width * scale).toInt(), (tall * scale).toInt(), Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
canvas.scale(scale, scale)
document.renderToCanvas(canvas)
bitmap.asImageBitmap()
}
Image(image, contentDescription = description, contentScale = ContentScale.Fit, modifier = modifier.height(height))
}
|


Detenga el servidor y haga clic en “Another image”: se muestra el error.
9.2. Ejemplo 23: inicio de sesión, cookie y sesión
El servidor coloca el token JWT en una COOKIE. En un navegador, este se encarga de almacenar las cookies y de devolverlas; el código de la aplicación no tiene que hacer nada. En un teléfono no hay navegador: le corresponde a la aplicación encargarse de ello. [OkHttp] lo hace, si se le proporciona un “almacén de cookies” ([CookieJar]):
| // =========================================================================
// common/HttpClient.kt - un cliente HTTP que maneja COOKIES
// -------------------------------------------------------------------------
// El servidor de RdvMedecins coloca el token JWT en una COOKIE (httpOnly).
// En un navegador, es el navegador quien almacena las cookies y las envía
// de vuelta con cada solicitud: el código de la aplicación no interviene.
// En un teléfono NO hay navegador: le corresponde a la aplicación
// desempeñar ese papel, es decir:
// 1. leer el encabezado "Set-Cookie" de cada respuesta y almacenar las cookies;
// 2. enviarlas de vuelta en el encabezado "Cookie" de cada solicitud.
// La biblioteca OkHttp lo hace por nosotros si le damos un CookieJar
// (un "frasco de cookies"): una clase con dos funciones, saveFromResponse
// (almacenar) y loadForRequest (recuperar). Este también almacena las cookies
// en el dispositivo (SharedPreferences): seguimos con la sesión iniciada al detener
// y volver a iniciar la aplicación.
// =========================================================================
package fr.stahe.examples.common
import android.content.Context
import android.content.SharedPreferences
import androidx.core.content.edit
import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit
class DeviceCookieJar(private val storage: SharedPreferences) : CookieJar {
// nombre de la cookie -> la cookie (su valor, su dominio, su expiración...)
private val cookies = mutableMapOf<String, Cookie>()
init {
// las cookies almacenadas durante un uso anterior: cada una
// se almacena en forma de su encabezado Set-Cookie
val base = Config.serverUrl.toHttpUrl()
for (text in storage.getStringSet(KEY, emptySet()).orEmpty()) {
Cookie.parse(base, text)?.let { cookies[it.name] = it }
}
}
// la respuesta trae cookies: las almacenamos. Una cookie ya expirada
// (cierre de sesión: así la elimina el servidor) se quita
@Synchronized
override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
for (c in cookies) {
if (c.expiresAt < System.currentTimeMillis() || c.value.isEmpty()) {
this.cookies.remove(c.name)
} else {
this.cookies[c.name] = c
}
}
storage.edit { putStringSet(KEY, this@DeviceCookieJar.cookies.values.map { it.toString() }.toSet()) }
}
// sale una solicitud: las cookies que le corresponden (dirección, ruta), no expiradas
@Synchronized
override fun loadForRequest(url: HttpUrl): List<Cookie> =
cookies.values.filter { it.expiresAt >= System.currentTimeMillis() && it.matches(url) }
companion object {
private const val KEY = "rdvmedecins.cookies"
}
}
// el cliente HTTP de los ejemplos: uno solo para toda la aplicación
fun createHttpClient(context: Context): OkHttpClient = OkHttpClient.Builder()
.cookieJar(DeviceCookieJar(context.getSharedPreferences("examples", Context.MODE_PRIVATE)))
// sin respuesta tras 10 segundos: la solicitud falla
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.build()
|
- línea 29: un [CookieJar] tiene dos funciones: [saveFromResponse] (almacenar las cookies de una respuesta) y [loadForRequest] (recuperar las de una solicitud);
- líneas 33–38: al iniciar, las cookies almacenadas durante una sesión anterior —guardadas en el dispositivo ([SharedPreferences], un pequeño archivo de pares clave-valor; consulte el ejemplo 20)— se recuperan en forma de su encabezado [Set-Cookie];
- líneas 44–53: una cookie que ya venció o que está vacía se elimina; así es como el servidor elimina la cookie al cerrar sesión; [@Synchronized]: [OkHttp] puede llamar a estas funciones desde varios hilos a la vez;
- líneas 67–72: el cliente HTTP de los ejemplos, con su almacén y sus tiempos de espera.
El cliente se crea una sola vez para toda la aplicación, dentro del objeto [Application] (declarado en el manifiesto), que [Android] crea al iniciar, antes de que comience cualquier actividad:
| // =========================================================================
// ExamplesApplication.kt - el objeto "application"
// -------------------------------------------------------------------------
// Android crea UN objeto Application cuando se inicia la aplicación, antes de
// cualquier actividad, y lo mantiene hasta que se detiene (se declara en
// AndroidManifest.xml, android:name=".ExamplesApplication"). Es
// el lugar para lo que deben compartir TODAS las actividades:
// aquí, el cliente HTTP y su cookie jar (ejemplos 23 a 25). Una
// actividad lo obtiene con (application as ExamplesApplication).api.
// =========================================================================
package fr.stahe.examples
import android.app.Application
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.createHttpClient
import okhttp3.OkHttpClient
class ExamplesApplication : Application() {
// by lazy: se crea en la primera solicitud
val httpClient: OkHttpClient by lazy { createHttpClient(this) }
val api: Api by lazy { Api(httpClient) }
}
|
Una acción asíncrona (iniciar sesión, guardar, etc.) tiene un estado que la pantalla debe mostrar: ¿está en curso? ¿Terminó con un error? Una pequeña clase se encarga de esto:
| // =========================================================================
// ex23/Command.kt - una ACCIÓN, su estado, su resultado
// -------------------------------------------------------------------------
// Una acción asíncrona (iniciar sesión, guardar...) tiene un estado que
// la pantalla debe mostrar: ¿está EN CURSO (botón deshabilitado)? ¿terminó
// con un ERROR (mensaje)? Es el patrón "Command", reducido a
// lo esencial:
//
// val loginCommand = remember { Command() }
// scope.launch { loginCommand.execute { logIn() } } // lanza la acción
// loginCommand.inProgress, loginCommand.error // su estado
//
// Sus dos propiedades son estados observados por Compose: la pantalla
// se redibuja cuando la acción comienza y cuando termina.
// =========================================================================
package fr.stahe.examples.ex23
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import kotlinx.coroutines.CancellationException
class Command {
var inProgress by mutableStateOf(false)
private set
var error by mutableStateOf<String?>(null)
private set
// ejecuta la acción, si no hay otra ya en curso
suspend fun execute(action: suspend () -> Unit) {
if (inProgress) return // sin doble envío (doble pulsación del botón)
inProgress = true
error = null
try {
action()
} catch (e: CancellationException) {
throw e // una corrutina cancelada debe seguir cancelada
} catch (e: Exception) {
error = e.message ?: e.toString() // el error se CONSERVA, para mostrarlo
} finally {
// finally: se ejecuta en TODOS los casos, éxito o error
inProgress = false
}
}
fun clearError() {
error = null
}
}
|
- línea 31: evita el envío doble (tocar dos veces el botón);
- líneas 40–42: [finally]: se ejecuta en TODOS los casos, éxito y error.
La pantalla de inicio de sesión:
| // =========================================================================
// ex23/Ex23Activity.kt - iniciar sesión en el servidor de RdvMedecins
// -------------------------------------------------------------------------
// 1. al inicio: GET /api/auth/me - ¿ya hay una sesión iniciada?
// (la aplicación pudo haberse detenido; el servidor, por su parte, lee la cookie
// que se le presenta);
// 2. inicio de sesión: POST /api/auth/login, cuerpo JSON { login, password,
// captchaId, captcha }. Si tiene éxito, el servidor envía la cookie
// del token JWT (encabezado Set-Cookie);
// 3. solicitud protegida: GET /api/doctors. La cookie la acompaña;
// 4. cierre de sesión: POST /api/auth/logout - el servidor elimina la cookie.
// Es el cliente HTTP de la aplicación (common/HttpClient.kt), con su
// cookie jar, quien almacena la cookie y la envía de vuelta.
// =========================================================================
package fr.stahe.examples.ex23
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Config
import fr.stahe.examples.common.SvgImage
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.put
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
// los pocos mensajes que necesita este ejemplo (el ejemplo 25 usará diccionarios)
val messages = mapOf(
"LOGIN.ERROR" to "Incorrect login or password.",
"ERRORS.WRONG_CAPTCHA" to "The characters do not match the image.",
"ERRORS.TOO_MANY_ATTEMPTS" to "Too many failed attempts. Try again later.",
)
// una respuesta que no es 2xx se convierte en una excepción, que conserva su código y su cuerpo
class ErrorResponse(val code: Int, val body: String) : Exception("the server responded $code")
// una respuesta HTTP reducida a lo que nos interesa
data class Response(val code: Int, val body: String)
class Ex23Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
// el cliente HTTP de la aplicación, con su cookie jar
val client = (application as ExamplesApplication).httpClient
setContent { ExamplesTheme { LoginPage(client) } }
}
}
// ejecutar una solicitud, en el hilo de entrada y salida
suspend fun send(client: OkHttpClient, request: Request): Response = withContext(Dispatchers.IO) {
client.newCall(request).execute().use { Response(it.code, it.body?.string().orEmpty()) }
}
@Composable
fun LoginPage(client: OkHttpClient) {
var user by remember { mutableStateOf<JsonObject?>(null) } // null: nadie ha iniciado sesión
var doctors by remember { mutableStateOf<JsonArray?>(null) }
var captcha by remember { mutableStateOf<JsonObject?>(null) }
var ready by remember { mutableStateOf(false) } // ¿terminó la verificación inicial?
var serverError by remember { mutableStateOf<String?>(null) }
val loginCommand = remember { Command() }
var login by remember { mutableStateOf("admin") }
var password by remember { mutableStateOf("") }
var captchaAnswer by remember { mutableStateOf("") }
val scope = rememberCoroutineScope()
fun url(path: String) = "${Config.serverUrl}/api$path"
// una solicitud GET cuyo cuerpo JSON queremos; una excepción si no es 2xx
suspend fun read(path: String): JsonElement {
val r = send(client, Request.Builder().url(url(path)).build())
if (r.code >= 300) throw ErrorResponse(r.code, r.body)
return Json.parseToJsonElement(r.body)
}
// un POST con un cuerpo JSON
suspend fun post(path: String, body: JsonObject): Response =
send(client, Request.Builder().url(url(path)).post(body.toString().toRequestBody("application/json".toMediaType())).build())
suspend fun loadCaptcha() {
captcha = read("/captcha").jsonObject
captchaAnswer = ""
}
suspend fun loadDoctors() {
doctors = read("/doctors").jsonArray
}
// 1. ¿quién ha iniciado sesión? 200 -> el usuario; 401 -> nadie
LaunchedEffect(Unit) {
try {
user = read("/auth/me").jsonObject
loadDoctors()
} catch (e: ErrorResponse) {
// "catch (e: Type)": captura SOLO este tipo de excepción
if (e.code == 401) loadCaptcha() else serverError = "The server responded ${e.code}."
} catch (e: java.io.IOException) {
serverError = "Is the RdvMedecins JSON server running (${Config.serverUrl})?"
}
ready = true
}
// 2. el inicio de sesión: una acción ejecutada por el Command, que recuerda su error
suspend fun logIn() {
val r = post(
"/auth/login",
buildJsonObject {
put("login", login.trim())
put("password", password)
put("captchaId", captcha?.get("id")?.jsonPrimitive?.content)
put("captcha", captchaAnswer)
},
)
if (r.code != 200) {
// el cuerpo JSON de la respuesta de error: { statusCode, key, ... }
val key = Json.parseToJsonElement(r.body).jsonObject["key"]!!.jsonPrimitive.content
loadCaptcha() // cada imagen se usa una sola vez
throw Exception("${r.code} - ${messages[key] ?: key}")
}
password = ""
user = Json.parseToJsonElement(r.body).jsonObject
loadDoctors()
}
// 4. el cierre de sesión
suspend fun logOut() {
post("/auth/logout", JsonObject(emptyMap()))
user = null
doctors = null
loadCaptcha()
}
// un texto JSON -> su valor, sin las comillas
fun JsonObject.text(key: String) = this[key]?.jsonPrimitive?.content.orEmpty()
ExamplePage("Example 23 - logging in to the server") {
val u = user
when {
!ready -> Text("Checking the session...", color = Color.Gray)
// sesión iniciada
u != null -> Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text(
buildAnnotatedString {
append("Logged in: ")
withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append(u.text("name")) }
append(" (${u.text("login")}), role ${u.text("role")}")
},
)
Spacer(Modifier.height(8.dp))
Text("GET /api/doctors", style = MaterialTheme.typography.titleSmall)
for (d in doctors.orEmpty()) {
val o = d.jsonObject
Text("• ${o.text("title")} ${o.text("firstName")} ${o.text("lastName")}")
}
Spacer(Modifier.height(8.dp))
Text("Stop then restart the application: you stay logged in.", color = Color.Gray)
Spacer(Modifier.height(8.dp))
OutlinedButton(onClick = { scope.launch { logOut() } }) { Text("Log out") }
}
}
// sin sesión iniciada: el formulario
serverError == null -> Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
OutlinedTextField(login, { login = it }, label = { Text("Login") }, singleLine = true, modifier = Modifier.fillMaxWidth())
OutlinedTextField(
password,
{ password = it },
label = { Text("Password") },
singleLine = true,
visualTransformation = PasswordVisualTransformation(),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(12.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
captcha?.let { SvgImage(it.text("svg"), height = 50.dp) }
TextButton(onClick = { scope.launch { runCatching { loadCaptcha() } } }) { Text("Another image") }
}
OutlinedTextField(
captchaAnswer,
{ captchaAnswer = it },
label = { Text("Copy the characters of the image") },
singleLine = true,
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(16.dp))
// esta pieza sigue el estado del comando
Button(onClick = { scope.launch { loginCommand.execute { logIn() } } }, enabled = !loginCommand.inProgress) {
Text(if (loginCommand.inProgress) "Logging in..." else "Log in")
}
loginCommand.error?.let { Text(it, color = Color.Red, modifier = Modifier.padding(top = 12.dp)) }
Spacer(Modifier.height(8.dp))
Text("Accounts: admin, pelissier, martin... (password = login).", color = Color.Gray, fontSize = 12.sp)
}
}
}
serverError?.let {
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFEBEE))) { Text(it, Modifier.padding(12.dp)) }
}
}
}
|
- Línea 92: el cliente HTTP de la aplicación ([application as ExamplesApplication]: una conversión de tipo);
- Líneas 138–148: al iniciar, [GET /api/auth/me]: ¿ya se inició sesión? Es posible que la aplicación se haya cerrado; sin embargo, la cookie se conservó en el dispositivo. [catch (e: ErrorResponse)] captura ÚNICAMENTE este tipo de excepción; un 401 significa “no autorizado”;
- líneas 152–170: [POST /api/auth/login], cuerpo JSON generado por [buildJsonObject]. Si el intento falla, el cuerpo de la respuesta proporciona el código de error; se solicita un nuevo CAPTCHA (cada imagen se usa una sola vez);
- líneas 174–178: cierre de sesión, [POST /api/auth/logout]: el servidor elimina la cookie;
- línea 182: una función de extensión LOCAL, para leer texto de un objeto JSON;
- líneas 236–239: el botón refleja el estado del comando.



Detenga la aplicación (quitándola de la lista de aplicaciones recientes) y luego vuelva a iniciar el ejemplo: la sesión sigue iniciada.
9.3. Ejemplo 24: una capa de acceso a la API
El ejemplo 23 repite los mismos pasos para cada solicitud: dirección del servidor, prefijo [/api], cuerpo JSON, verificación del código de estado y lectura del cuerpo del error. Estos se agrupan en tres capas. La primera capa ejecuta una solicitud y convierte CUALQUIER error en una única clase de excepción:
| // =========================================================================
// common/ApiError.kt - UNA clase para todos los errores de la API
// -------------------------------------------------------------------------
// Todas las respuestas de error del servidor de RdvMedecins tienen la misma forma:
// { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Pero una solicitud también puede fallar DE OTRA MANERA: sin ninguna respuesta
// (red caída, servidor detenido, dirección incorrecta), o con una respuesta que no
// proviene de nuestro servidor (una página de error de un proxy). Convertimos
// todo esto en UNA sola clase de excepción, ApiError, que lleva la clave de
// traducción enviada por el servidor (y, si los hay, sus parámetros y
// el error de cada campo).
// =========================================================================
package fr.stahe.examples.common
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject
class ApiError(
val statusCode: Int, // 0: el servidor no respondió
val key: String, // p. ej.: "ERRORS.LOGIN_TAKEN"
val params: Map<String, String> = emptyMap(),
val fields: Map<String, String> = emptyMap(),
) : Exception("$statusCode $key") {
override fun toString() = "$statusCode $key"
// companion object: lo que pertenece a la CLASE (el "static" de Java)
companion object {
// una respuesta de error (4xx, 5xx) -> un ApiError
fun fromResponse(statusCode: Int, body: String): ApiError {
// runCatching: el resultado, o null si el cuerpo no es JSON
// (entonces no fue nuestro servidor quien respondió)
val json = runCatching { Json.parseToJsonElement(body).jsonObject }.getOrNull()
val key = (json?.get("key") as? JsonPrimitive)?.content
if (json == null || key == null) {
return ApiError(statusCode, if (statusCode >= 500) "ERRORS.SERVER_UNREACHABLE" else "ERRORS.SERVER_ERROR")
}
return ApiError(statusCode, key, strings(json["params"]), strings(json["fields"]))
}
// un objeto JSON { "name": "ERRORS..." } -> Map<String, String> (vacío en otro caso)
private fun strings(json: Any?): Map<String, String> =
(json as? JsonObject)?.mapValues { (_, v) -> (v as? JsonPrimitive)?.content ?: v.toString() } ?: emptyMap()
}
}
// =========================================================================
// common/Api.kt - solicitudes a la API, en una línea
// -------------------------------------------------------------------------
// En el ejemplo 23, cada solicitud repite los mismos pasos: dirección del
// servidor, prefijo /api, cuerpo JSON, prueba del código de estado, lectura del
// cuerpo de error... Aquí se agrupan:
//
// val json = api.get("/doctors")
// api.post("/appointments", buildJsonObject { put("day", day); put("slotId", 3) })
//
// - si tiene éxito, la función devuelve el cuerpo JSON (un JsonElement:
// un objeto, un arreglo...), o null si el cuerpo está vacío;
// - si falla, lanza un ApiError.
// Son funciones SUSPEND: esperan la respuesta del servidor sin
// bloquear el teléfono. La solicitud en sí se ejecuta en un hilo
// reservado para entrada y salida (Dispatchers.IO): Android
// prohíbe el acceso a la red en el hilo de la pantalla.
// Todas las solicitudes pasan por la función request: es el lugar donde
// se manejaría un problema COMÚN a todas ellas (cf. el caso de estudio y la
// respuesta 401). Usado por los ejemplos 24 y 25.
// =========================================================================
package fr.stahe.examples.common
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
class Api(private val client: OkHttpClient) {
suspend fun request(method: String, url: String, body: JsonElement? = null): JsonElement? =
withContext(Dispatchers.IO) {
// un cuerpo JSON (el servidor rechaza un POST que no lo tenga)
val httpBody = body?.toString()?.toRequestBody("application/json".toMediaType())
val request = Request.Builder().url("${Config.serverUrl}/api$url").method(method, httpBody).build()
try {
// use: la respuesta se cierra (se libera) al final del bloque
client.newCall(request).execute().use { response ->
val text = response.body?.string().orEmpty()
if (!response.isSuccessful) throw ApiError.fromResponse(response.code, text)
if (text.isEmpty()) null else Json.parseToJsonElement(text)
}
} catch (e: IOException) {
// NINGUNA respuesta (red, servidor detenido, dirección incorrecta)
throw ApiError(0, "ERRORS.SERVER_UNREACHABLE")
}
}
suspend fun get(url: String) = request("GET", url)
// un POST siempre tiene un cuerpo JSON: {} por defecto
suspend fun post(url: String, body: JsonElement = JsonObject(emptyMap())) = request("POST", url, body)
suspend fun put(url: String, body: JsonElement) = request("PUT", url, body)
suspend fun delete(url: String, body: JsonElement? = null) = request("DELETE", url, body)
}
|
- líneas 37–47: si tiene éxito, la función devuelve el cuerpo JSON ([JsonElement]), o [null] si el cuerpo está vacío; si no, un [ApiError];
- líneas 55–62: atajos según el método HTTP.
Los objetos JSON intercambiados se convierten en clases [Kotlin] y [@Serializable]:
| // =========================================================================
// common/Types.kt - los objetos JSON intercambiados con la API de RdvMedecins
// (cf. el capítulo sobre la caja negra, que describe cada ruta)
// -------------------------------------------------------------------------
// Cada clase es @Serializable: el plugin kotlinx.serialization escribe
// para ella el código que la construye a partir de JSON. La lectura VERIFICA la
// forma del JSON recibido: un campo ausente o de tipo incorrecto lanza una
// excepción al recibirlo, y no más tarde, en medio de la visualización.
// val u = json.decodeFromJsonElement<User>(response)
// Un campo OPCIONAL tiene un valor por defecto (login: String? = null).
// =========================================================================
package fr.stahe.examples.common
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer
enum class Role { ADMIN, DOCTOR, USER }
// POST /api/auth/login, GET /api/auth/me
@Serializable
data class User(val login: String, val name: String, val role: Role)
// GET /api/captcha
@Serializable
data class Captcha(val id: String, val svg: String)
// un médico o un cliente (GET /api/doctors, GET /api/clients...)
@Serializable
data class Person(
val id: Int,
val version: Int,
val title: String,
val firstName: String,
val lastName: String,
val login: String? = null, // solo para el ADMIN
) {
val fullName get() = "$title $firstName $lastName"
}
// el nombre de una persona, nada más
@Serializable
data class Identity(val title: String, val firstName: String, val lastName: String) {
override fun toString() = "$title $firstName $lastName"
}
// una línea de GET /api/schedule
@Serializable
data class ScheduleSlot(
val id: Int,
val startHour: Int,
val startMinute: Int,
val endHour: Int,
val endMinute: Int,
val free: Boolean,
val patient: Identity?,
val mine: Boolean,
val bookable: Boolean,
val appointmentId: Int?,
) {
// "8:00 - 8:20"
val timeRange: String
get() {
fun hm(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"
return "${hm(startHour, startMinute)} - ${hm(endHour, endMinute)}"
}
}
// GET /api/schedule?doctorId=...&day=...
@Serializable
data class Schedule(val doctor: Person, val day: String, val slots: List<ScheduleSlot>, val info: String?)
// el lector JSON: ignoreUnknownKeys, los campos que el cliente no usa
// se ignoran (el servidor puede agregar algunos sin romper el cliente)
val apiJson = Json { ignoreUnknownKeys = true }
// JsonElement -> objeto Kotlin: una función genérica "reified" (el tipo T
// se conoce en tiempo de ejecución); serializer<T>(): el código escrito por el plugin
inline fun <reified T> JsonElement?.read(): T =
apiJson.decodeFromJsonElement(serializer<T>(), this ?: throw IllegalStateException("empty response"))
|
- línea 37: un campo opcional tiene un valor predeterminado; [Identity?]: un objeto, o [null];
- línea 76: [ignoreUnknownKeys]: los campos que el cliente no utiliza se ignoran (el servidor puede agregarlos sin romper el cliente);
- líneas 80–81: una función de extensión GENÉRICA es “reificada” ([reified]: el tipo [T] se conoce en tiempo de ejecución, lo que [inline] permite). [serializer<T>()]: el código escrito por el complemento para [T]. La lectura VERIFICA el formato del JSON: un campo ausente o de un tipo incorrecto lanza una excepción en el momento de la recepción, y no más tarde, en medio de la visualización.
La segunda capa: una función con tipos seguros por cada ruta de la API. Las pantallas ya no conocen las URL, [OkHttp] ni JSON. Es el equivalente en el cliente de la capa DAO del servidor; en la guía de arquitectura de [Android], un “repositorio”:
| // =========================================================================
// ex24/RdvMedecins.kt - la capa de acceso a la API
// -------------------------------------------------------------------------
// Una función tipada por cada ruta de la API. Las pantallas no conocen ni las
// URL, ni OkHttp, ni el formato JSON: llaman a funciones que
// devuelven objetos Kotlin (Person, Schedule...).
// Es el equivalente en el cliente de la capa DAO del servidor: si la API
// cambia (una URL, el nombre de un campo), solo se modifica este archivo. En la
// guía de arquitectura de Android, es un "repository".
// =========================================================================
package fr.stahe.examples.ex24
import android.net.Uri
import fr.stahe.examples.common.Schedule
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.read
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
class RdvMedecins(private val api: Api) {
suspend fun getDoctors(): List<Person> = api.get("/doctors").read()
suspend fun getClients(): List<Person> = api.get("/clients").read()
// Uri.Builder construye "doctorId=1&day=2030-01-15", codificando lo que haga falta
suspend fun getSchedule(doctorId: Int, day: String): Schedule {
val params = Uri.Builder()
.appendQueryParameter("doctorId", "$doctorId")
.appendQueryParameter("day", day)
.build().encodedQuery
return api.get("/schedule?$params").read()
}
// clientId: opcional; la clave solo se coloca en el JSON si no es null
suspend fun book(day: String, slotId: Int, clientId: Int? = null) {
api.post(
"/appointments",
buildJsonObject {
put("day", day)
put("slotId", slotId)
if (clientId != null) put("clientId", clientId)
},
)
}
suspend fun cancelAppointment(appointmentId: Int) {
api.delete("/appointments/$appointmentId")
}
}
|
- línea 22: [api.get("/doctors").read()]: el tipo esperado, [List<Person>], se infiere del tipo de retorno de la función;
- líneas 28–31: [Uri.Builder] construye la cadena de parámetros, codificando la información necesaria.
La tercera capa: el estado y las acciones de la pantalla, en un [ViewModel] (consulte el ejemplo 20). Esta vez, el estado se compone de propiedades de [Compose] ([mutableStateOf]), más fáciles de leer que un [StateFlow] cuando solo la pantalla las observa:
| // =========================================================================
// ex24/ScheduleModel.kt - el "view model" de la pantalla
// -------------------------------------------------------------------------
// La guía de arquitectura de Android recomienda separar:
// - la VISTA: las funciones @Composable, que muestran y transmiten las
// acciones del usuario;
// - el VIEW MODEL (ViewModel): el estado de la pantalla (el médico elegido,
// el día, la agenda recibida...), las acciones (elegir, reservar, cancelar),
// y las llamadas a la capa de acceso a la API.
// La vista ya no tiene lógica: es fácil de leer; el view model
// no tiene componentes: es fácil de probar. Y sobrevive a la
// recreación de la actividad (rotación de la pantalla).
// Las acciones lanzan sus corrutinas en viewModelScope: se
// cancelan si el ViewModel se destruye (actividad cerrada definitivamente).
//
// También hace lo que no queremos reescribir en cada pantalla:
// - un CACHÉ: la agenda de cada (médico, día) ya leída se conserva; al
// volver a ella se muestra de inmediato, mientras se lee de nuevo en segundo plano;
// - las respuestas OBSOLETAS se ignoran: una nueva lectura CANCELA la
// anterior (cf. ejemplo 19).
// =========================================================================
package fr.stahe.examples.ex24
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import fr.stahe.examples.common.Schedule
import fr.stahe.examples.common.ScheduleSlot
import fr.stahe.examples.common.ApiError
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.Role
import fr.stahe.examples.common.User
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import java.time.LocalDate
// un mensaje que se muestra al usuario
data class Message(val success: Boolean, val text: String)
class ScheduleModel(private val rdvmedecins: RdvMedecins) : ViewModel() {
// el estado: estados de Compose, modificables solo aquí
var user by mutableStateOf<User?>(null)
private set
var doctors by mutableStateOf(listOf<Person>())
private set
var clients by mutableStateOf(listOf<Person>())
private set
var doctorId by mutableStateOf<Int?>(null)
private set
var day by mutableStateOf(LocalDate.now().plusDays(1).toString()) // mañana, "2026-10-06"
private set
var clientId by mutableStateOf<Int?>(null)
private set
var schedule by mutableStateOf<Schedule?>(null)
private set
var loading by mutableStateOf(false)
private set
var message by mutableStateOf<Message?>(null)
private set
private val cache = mutableMapOf<String, Schedule>()
private var reading: Job? = null
// valores calculados
val loggedIn get() = user != null
val isManager get() = user.let { it != null && it.role != Role.USER }
// las acciones
fun changeUser(u: User?) {
user = u
doctors = emptyList()
clients = emptyList()
schedule = null
doctorId = null
cache.clear() // los derechos han cambiado: todo se olvida
if (u == null) return
viewModelScope.launch {
try {
doctors = rdvmedecins.getDoctors()
if (isManager) clients = rdvmedecins.getClients() // un USER recibiría 403
} catch (e: ApiError) {
message = Message(false, e.toString())
}
}
}
fun chooseDoctor(id: Int?) {
doctorId = id
message = null
readSchedule()
}
fun chooseDay(d: LocalDate) {
day = d.toString()
message = null
readSchedule()
}
fun chooseClient(id: Int?) {
clientId = id
}
fun book(s: ScheduleSlot) = act("Slot ${s.timeRange} booked.") {
rdvmedecins.book(day, s.id, if (isManager) clientId else null)
}
fun cancel(s: ScheduleSlot) = act("Appointment at ${s.timeRange} cancelled.") { rdvmedecins.cancelAppointment(s.appointmentId!!) }
// una acción, y SIEMPRE una nueva lectura de la agenda: el SERVIDOR es la referencia
private fun act(success: String, action: suspend () -> Unit) {
viewModelScope.launch {
message = try {
action()
Message(true, success)
} catch (e: ApiError) {
Message(false, e.toString())
}
readSchedule()
}
}
private fun readSchedule() {
val id = doctorId ?: return
val key = "$id/$day"
// una lectura anterior sigue en curso: se cancela
reading?.cancel()
// primero el caché (o nada), luego la lectura
schedule = cache[key]
loading = true
reading = viewModelScope.launch {
try {
val read = rdvmedecins.getSchedule(id, day)
cache[key] = read
schedule = read
} catch (e: ApiError) {
schedule = null
message = Message(false, e.toString())
}
loading = false
}
}
}
|
- líneas 44–62: el estado, que solo se puede modificar aquí;
- líneas 70–83: un cambio de usuario: todo se borra (los permisos cambiaron) y luego se vuelve a cargar. [viewModelScope.launch]: una corrutina que vive tanto como el [ViewModel];
- líneas 111–119: cada acción termina SIEMPRE volviendo a leer la agenda: el SERVIDOR es la versión de referencia;
- líneas 123–140: lectura de la agenda: cualquier operación de lectura anterior que siga en curso se cancela; la caché proporciona una respuesta inmediata, que luego se reemplaza por la respuesta del servidor.
La vista, que simplemente muestra el modelo. La conexión la gestiona un componente reutilizable, la barra [common/LoginBar.kt] (el formulario del ejemplo 23, reescrito con [Api]):
| // =========================================================================
// common/LoginBar.kt - inicio / cierre de sesión, en una sola barra
// -------------------------------------------------------------------------
// El formulario del ejemplo 23, reducido a una barra y reescrito con Api.kt.
// El componente llama a onUserChange con el usuario que inició sesión (o
// null) cada vez que cambia, incluso al inicio, después de
// consultar GET /api/auth/me. Usado por los ejemplos 24 y 25.
// =========================================================================
package fr.stahe.examples.common
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
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.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
@Composable
fun LoginBar(api: Api, onUserChange: (User?) -> Unit) {
var user by remember { mutableStateOf<User?>(null) }
var captcha by remember { mutableStateOf<Captcha?>(null) }
var login by rememberSaveable { mutableStateOf("admin") }
var password by rememberSaveable { mutableStateOf("") }
var captchaAnswer by rememberSaveable { mutableStateOf("") }
var error by remember { mutableStateOf<String?>(null) }
val scope = rememberCoroutineScope()
fun changeUser(u: User?) {
user = u
onUserChange(u)
}
suspend fun newCaptcha() {
captcha = api.get("/captcha").read<Captcha>()
captchaAnswer = ""
}
// al inicio: ¿ya hay una sesión iniciada?
LaunchedEffect(Unit) {
try {
changeUser(api.get("/auth/me").read<User>())
} catch (e: ApiError) {
changeUser(null) // 401: nadie ha iniciado sesión
try {
newCaptcha()
} catch (e: ApiError) {
error = "Is the JSON server running (${Config.serverUrl})?"
}
}
}
suspend fun logIn() {
error = null
try {
val body = buildJsonObject {
put("login", login.trim())
put("password", password)
put("captchaId", captcha?.id)
put("captcha", captchaAnswer)
}
val u = api.post("/auth/login", body).read<User>()
password = ""
changeUser(u)
} catch (e: ApiError) {
error = e.toString() // "401 LOGIN.ERROR"
runCatching { newCaptcha() }
}
}
suspend fun logOut() {
runCatching { api.post("/auth/logout") }
changeUser(null)
runCatching { newCaptcha() }
}
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFECEFF1))) {
val u = user
if (u != null) {
Row(Modifier.padding(8.dp), verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.Person, contentDescription = null)
Spacer(Modifier.width(8.dp))
Text("${u.name} (${u.role})", Modifier.weight(1f))
TextButton(onClick = { scope.launch { logOut() } }) {
Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = null)
Text("Log out")
}
}
} else {
Column(Modifier.padding(8.dp)) {
Row {
OutlinedTextField(login, { login = it }, label = { Text("login") }, singleLine = true, modifier = Modifier.weight(1f))
Spacer(Modifier.width(8.dp))
OutlinedTextField(
password,
{ password = it },
label = { Text("password") },
singleLine = true,
visualTransformation = PasswordVisualTransformation(),
modifier = Modifier.weight(1f),
)
}
Row(verticalAlignment = Alignment.CenterVertically) {
// la imagen SVG del captcha, generada por NUESTRO servidor (cf. ejemplo 22)
captcha?.let { SvgImage(it.svg, height = 40.dp) }
Spacer(Modifier.width(8.dp))
OutlinedTextField(captchaAnswer, { captchaAnswer = it }, label = { Text("captcha") }, singleLine = true, modifier = Modifier.weight(1f))
IconButton(onClick = { scope.launch { logIn() } }) {
Icon(Icons.Default.Check, contentDescription = "Log in")
}
}
error?.let { Text(it, color = Color.Red) }
}
}
}
}
// =========================================================================
// ex24/Ex24Activity.kt - una agenda, con la capa de acceso a la API
// -------------------------------------------------------------------------
// Inicie sesión (barra superior), elija un médico y un día:
// se muestra la agenda. ADMIN y DOCTOR pueden reservar para un paciente y
// cancelar; un paciente (martin...) reserva para sí mismo. Cada acción
// termina con una nueva lectura de la agenda.
// Tres capas, de abajo hacia arriba:
// Api (common/Api.kt) las solicitudes HTTP, los errores;
// RdvMedecins (RdvMedecins.kt) una función tipada por cada ruta de la API;
// ScheduleModel (ScheduleModel.kt) el estado y las acciones de la pantalla;
// y la vista, más abajo, que solo muestra el modelo.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex24
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
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.LinearProgressIndicator
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
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.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.LoginBar
import fr.stahe.examples.common.ScheduleSlot
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
class Ex24Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
val api = (application as ExamplesApplication).api
setContent { ExamplesTheme { SchedulePage(api) } }
}
}
@Composable
fun SchedulePage(api: Api) {
// viewModel { ... }: el modelo de la actividad, creado por este bloque en la
// primera solicitud (necesita un parámetro: la capa de acceso a la API)
val model = viewModel { ScheduleModel(RdvMedecins(api)) }
var calendarOpen by remember { mutableStateOf(false) }
ExamplePage("Example 24 - an API access layer") {
LoginBar(api, onUserChange = { model.changeUser(it) })
if (model.loggedIn) {
DropdownList(
label = "Doctor",
value = model.doctorId,
choices = listOf<Int?>(null) + model.doctors.map { it.id },
text = { id -> model.doctors.find { it.id == id }?.fullName ?: "-- choose a doctor --" },
onChange = { model.chooseDoctor(it) },
modifier = Modifier.fillMaxWidth(),
)
Row(verticalAlignment = Alignment.CenterVertically) {
Text("Day: ${model.day}")
IconButton(onClick = { calendarOpen = true }) { Icon(Icons.Default.DateRange, contentDescription = "choose the day") }
}
if (model.isManager) {
DropdownList(
label = "Patient",
value = model.clientId,
choices = listOf<Int?>(null) + model.clients.map { it.id },
text = { id -> model.clients.find { it.id == id }?.fullName ?: "-- patient to book for --" },
onChange = { model.chooseClient(it) },
modifier = Modifier.fillMaxWidth(),
)
}
model.message?.let { m ->
Card(colors = CardDefaults.cardColors(containerColor = if (m.success) Color(0xFFE8F5E9) else Color(0xFFFFEBEE))) {
Text(m.text, Modifier.padding(10.dp))
}
}
if (model.loading) LinearProgressIndicator(Modifier.fillMaxWidth())
model.schedule?.let { schedule ->
// info: la clave enviada por el servidor cuando un paciente ya tiene una cita próxima
schedule.info?.let { Text(it, color = Color(0xFF1976D2)) }
Text(
"Schedule of ${schedule.day} - ${schedule.doctor.fullName}",
style = MaterialTheme.typography.titleSmall,
modifier = Modifier.padding(vertical = 8.dp),
)
for (s in schedule.slots) {
SlotRow(s, onBook = { model.book(s) }, onCancel = { model.cancel(s) })
}
}
}
}
if (calendarOpen) {
val state = rememberDatePickerState(
initialSelectedDateMillis = LocalDate.parse(model.day).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
)
DatePickerDialog(
onDismissRequest = { calendarOpen = false },
confirmButton = {
TextButton(onClick = {
state.selectedDateMillis?.let { model.chooseDay(Instant.ofEpochMilli(it).atZone(ZoneOffset.UTC).toLocalDate()) }
calendarOpen = false
}) { Text("OK") }
},
) { DatePicker(state = state) }
}
}
// una línea de la agenda: el rango de horas, el ocupante, los botones permitidos
@Composable
fun SlotRow(s: ScheduleSlot, onBook: () -> Unit, onCancel: () -> Unit) {
ListItem(
leadingContent = { Text(s.timeRange, Modifier.width(96.dp)) },
headlineContent = {
if (s.free) {
SuggestionChip(
onClick = {},
label = { Text("Free") },
colors = SuggestionChipDefaults.suggestionChipColors(containerColor = Color(0xFFC8E6C9)),
)
} else {
SuggestionChip(
onClick = {},
label = { Text(s.patient?.toString() ?: "Booked") },
colors = SuggestionChipDefaults.suggestionChipColors(
containerColor = if (s.mine) Color(0xFFC5CAE9) else Color(0xFFE0E0E0),
),
)
}
},
// los botones siguen los derechos calculados por el servidor
trailingContent = {
when {
s.bookable -> IconButton(onClick = onBook) {
Icon(Icons.Default.AddCircle, contentDescription = "Book", tint = Color(0xFF2E7D32))
}
s.appointmentId != null -> IconButton(onClick = onCancel) {
Icon(Icons.Default.Close, contentDescription = "Cancel", tint = Color.Red)
}
}
},
)
}
|
- línea 79: [viewModel [ ... ]]: el modelo, creado por este bloque en la primera solicitud (requiere un parámetro);
- líneas 86–90: la lista de médicos: sus opciones son [Int?] y [null] para “-- choose a doctor --”;
- líneas 169–172: los botones de cada línea corresponden a los permisos CALCULADOS POR EL SERVIDOR ([bookable], [appointmentId]).



A la izquierda y en el centro, ADMIN reserva el primer horario para Jean MARTIN; a la derecha, con la sesión iniciada como [martin]: el servidor puso [bookable] en [false] para todos los horarios, porque este paciente ya tiene una cita futura, como indica la clave [SCHEDULE.ALREADY_BOOKED_INFO]. Esta clave sin procesar no es muy significativa: el ejemplo 25 traduce las claves del servidor.
9.4. Ejemplo 25: errores devueltos por el servidor
El servidor valida TODO lo que recibe (consulte el ejemplo 07) y, en caso de rechazo, responde con un JSON de error, que proporciona la clave del mensaje general y la clave de error de CADA campo:
| 400 { key: 'ERRORS.INVALID_FORM', fields: { lastName: 'ERRORS.LASTNAME_REQUIRED' } }
409 { key: 'ERRORS.PATIENT_ALREADY_EXISTS', fields: { firstName: ..., lastName: ... } }
409 { key: 'ERRORS.CONCURRENT_UPDATE' }
|
Hay muchas de estas claves. Los clientes del servidor —[Vue.js], [Angular], [React], y [Flutter]—las traducen mediante diccionarios JSON, uno por idioma. En lugar de copiar estos cientos de textos en archivos [strings.xml] (y de escribir la tabla clave → recurso del ejemplo 21), reutilizamos estos diccionarios tal cual, almacenados en la carpeta [assets/] de la aplicación: archivos incluidos con la aplicación, que se leen por su ruta ([assets/i18n/ex25_fr.json], [ex25_en.json]):
| // =========================================================================
// ex25/Dictionary.kt - los diccionarios compartidos con los otros clientes
// -------------------------------------------------------------------------
// El servidor de RdvMedecins solo devuelve CLAVES ("ERRORS.LOGIN_TAKEN"),
// en gran cantidad: los mensajes de error de cada campo, de cada
// ruta... Los clientes web (Vue.js, Angular, React) y Flutter de este
// servidor las traducen con DICCIONARIOS JSON, uno por idioma, donde
// cada texto tiene su clave:
// { "ERRORS": { "LOGIN_TAKEN": "This login is already used..." } }
// En lugar de copiar estos cientos de textos en archivos strings.xml (y
// escribir la tabla clave -> recurso del ejemplo 21), reutilizamos estos
// diccionarios tal cual. Se almacenan en la carpeta assets/ de
// la aplicación: archivos que se distribuyen con ella, leídos por su ruta.
// - t("FORM.ADDED", mapOf("name" to "Marie DUPONT")): el texto del
// idioma actual, cuyos parámetros {{name}} se reemplazan;
// - una clave desconocida se muestra tal cual: vemos lo que falta.
// El idioma sigue siendo el de la APLICACIÓN (ejemplo 21): el diccionario
// se elige según este.
// =========================================================================
package fr.stahe.examples.ex25
import android.content.Context
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
class Dictionary(context: Context, file: String) {
// el contenido del archivo JSON, leído una vez por todas
private val root: JsonObject = context.assets.open(file).bufferedReader().use { reader ->
Json.parseToJsonElement(reader.readText()) as JsonObject
}
// "FORM.ADDED" -> root["FORM"]["ADDED"]; null si falta
private fun find(key: String): String? {
var node: JsonElement? = root
for (part in key.split('.')) {
node = (node as? JsonObject)?.get(part)
}
return (node as? JsonPrimitive)?.takeIf { it.isString }?.content
}
fun t(key: String, params: Map<String, String> = emptyMap()): String {
val text = find(key) ?: return key
// {{name}} -> el valor del parámetro name (o {{name}} si no se proporciona)
return Regex("\\{\\{(\\w+)\\}\\}").replace(text) { m -> params[m.groupValues[1]] ?: m.value }
}
}
// el diccionario del idioma actual: assets/i18n/<prefix>_<language>.json
@Composable
fun rememberDictionary(prefix: String): Dictionary {
val context = LocalContext.current
val language = LocalConfiguration.current.locales[0].language.let { if (it == "fr") "fr" else "en" }
// se vuelve a leer solo si cambia el idioma
return remember(language) { Dictionary(context, "i18n/${prefix}_$language.json") }
}
|
- líneas 34–35: el archivo JSON, leído una vez por todas ([context.assets.open]);
- líneas 39–48: ["FORM.ADDED"] → [root["FORM"]["ADDED"]]; una clave desconocida se muestra tal cual: así se ve lo que falta;
- línea 50: los parámetros [{{name}}] se reemplazan mediante una expresión regular;
- líneas 56–60: el diccionario del idioma de la APLICACIÓN (ejemplo 21), que se vuelve a leer solo si cambia.
El modelo de la pantalla: este formulario no realiza ninguna validación en el teléfono; todo se envía al servidor.
| // =========================================================================
// ex25/ClientsModel.kt - el estado de la pantalla de clientes
// -------------------------------------------------------------------------
// Este formulario NO hace validación alguna en el teléfono, a propósito:
// todo se envía al servidor, que responde, en caso de rechazo, con un error
// JSON (convertido en un ApiError por common/Api.kt):
//
// 400 { key: 'ERRORS.INVALID_FORM', fields: { lastName: 'ERRORS.LASTNAME_REQUIRED' } }
// 409 { key: 'ERRORS.PATIENT_ALREADY_EXISTS', fields: { firstName: ..., lastName: ... } }
// 409 { key: 'ERRORS.CONCURRENT_UPDATE' } (bloqueo optimista)
//
// El error de CADA campo (ApiError.fields) se almacena en el estado y
// se muestra bajo el campo; su mensaje es la CLAVE enviada por el servidor,
// que la pantalla traduce. Modificar un campo borra su error.
// El estado está en un ViewModel: cambiar el idioma RECREA la actividad
// (cf. ejemplo 21), y la entrada en curso no debe perderse.
// =========================================================================
package fr.stahe.examples.ex25
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.ApiError
import fr.stahe.examples.common.Person
import fr.stahe.examples.common.Role
import fr.stahe.examples.common.User
import fr.stahe.examples.common.read
import fr.stahe.examples.ex23.Command
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
// un mensaje por traducir: una clave y sus parámetros
data class KeyMessage(val key: String, val params: Map<String, String> = emptyMap())
class ClientsModel(private val api: Api) : ViewModel() {
var user by mutableStateOf<User?>(null)
private set
var clients by mutableStateOf(listOf<Person>())
private set
// el formulario: editedId == null -> creación, de lo contrario actualización
var editedId by mutableStateOf<Int?>(null)
private set
private var version = 0
// los valores escritos, por nombre de campo (los nombres que espera el servidor)
var input by mutableStateOf(empty)
private set
// el error de cada campo (una CLAVE de traducción), devuelto por el servidor
var errors by mutableStateOf(mapOf<String, String>())
private set
// el mensaje general del último error, y el de un éxito
var pageError by mutableStateOf<ApiError?>(null)
private set
var success by mutableStateOf<KeyMessage?>(null)
private set
// envío al servidor: un Command (ejemplo 23), que indica si está en curso
val sending = Command()
val isAdmin get() = user?.role == Role.ADMIN
suspend fun onUserChange(u: User?) {
user = u
clients = emptyList()
if (u?.role == Role.ADMIN) reload()
}
private suspend fun reload() {
clients = try {
api.get("/clients").read()
} catch (e: ApiError) {
emptyList()
}
}
private fun clearMessages() {
errors = emptyMap()
pageError = null
success = null
}
// un campo modificado: su valor cambia, su error desaparece
fun change(field: String, value: String) {
input = input + (field to value)
errors = errors - field
}
fun newForm() {
editedId = null
version = 0
input = empty
clearMessages()
}
fun edit(c: Person) {
editedId = c.id
// la VERSIÓN leída con el registro vuelve con la actualización: si
// alguien ha modificado el registro mientras tanto, el servidor responderá 409
// CONCURRENT_UPDATE
version = c.version
input = mapOf("title" to c.title, "firstName" to c.firstName, "lastName" to c.lastName, "login" to (c.login ?: ""), "password" to "")
clearMessages()
}
suspend fun save() {
clearMessages()
val body = buildJsonObject {
for ((field, value) in input) put(field, value)
put("version", version)
}
try {
val id = editedId
val client: Person = (if (id == null) api.post("/clients", body) else api.put("/clients/$id", body)).read()
val key = if (id == null) "FORM.ADDED" else "FORM.UPDATED"
newForm() // formulario vaciado, mensajes borrados...
// ... excepto este
success = KeyMessage(key, mapOf("name" to "${client.firstName} ${client.lastName}", "login" to (client.login ?: "")))
reload()
} catch (e: ApiError) {
pageError = e // el mensaje general
errors = e.fields // el error de cada campo
}
}
suspend fun remove(c: Person) {
clearMessages()
try {
api.delete("/clients/${c.id}")
success = KeyMessage("FORM.DELETED", mapOf("name" to "${c.firstName} ${c.lastName}"))
} catch (e: ApiError) {
pageError = e
}
reload()
}
companion object {
val empty = mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "")
}
}
|
- líneas 49–53: la entrada, por nombre de campo (los nombres que espera el servidor), y el error de cada campo (una traducción);
- líneas 88–90: modificar un campo borra su error;
- línea 105: la VERSIÓN leída del registro se reenvía con la modificación; si alguien modificó el registro mientras tanto, el servidor responde con un 409 [CONCURRENT_UPDATE] (bloqueo optimista);
- líneas 110–126: guardado: en caso de error, el mensaje general y el error de cada campo ([e.fields]) se almacenan en el estado.
La pantalla:
| // =========================================================================
// ex25/Ex25Activity.kt - mostrar los errores del SERVIDOR
// -------------------------------------------------------------------------
// La gestión de los clientes (cuenta admin), cf. ClientsModel.kt. La pantalla
// muestra, bajo cada campo, el error que el servidor le asoció,
// traducido por los diccionarios (Dictionary.kt), y el mensaje general
// al pie del formulario.
// Pruebe: un nombre vacío, un título "Dr", un homónimo (Alice DURAND), un
// login ya tomado (martin), el mismo registro modificado en dos dispositivos...
// =========================================================================
package fr.stahe.examples.ex25
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.app.AppCompatDelegate
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.os.LocaleListCompat
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ExamplesApplication
import fr.stahe.examples.common.Api
import fr.stahe.examples.common.LoginBar
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex16.ConfirmDialog
import fr.stahe.examples.ex16.rememberConfirmation
import kotlinx.coroutines.launch
class Ex25Activity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
val api = (application as ExamplesApplication).api
setContent { ExamplesTheme { ClientsPage(api) } }
}
}
@Composable
fun ClientsPage(api: Api) {
val model = viewModel { ClientsModel(api) }
val dict = rememberDictionary("ex25")
// un atajo: t("KEY") llama a dict.t("KEY")
fun t(key: String, params: Map<String, String> = emptyMap()) = dict.t(key, params)
val confirmation = rememberConfirmation()
val scope = rememberCoroutineScope()
var languageMenu by remember { mutableStateOf(false) }
// un campo de entrada, con su error (una clave del servidor) traducido
@Composable
fun Field(field: String, secret: Boolean = false) {
val error = model.errors[field]
OutlinedTextField(
value = model.input[field].orEmpty(),
onValueChange = { model.change(field, it) },
label = { Text(t("FORM.${field.uppercase()}")) },
singleLine = true,
isError = error != null,
supportingText = error?.let { e -> { Text(t(e)) } },
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
modifier = Modifier.fillMaxWidth(),
)
}
ExamplePage(
title = t("FORM.PAGE_TITLE"),
// el idioma: un menú
actions = {
IconButton(onClick = { languageMenu = true }) { Icon(Icons.Default.MoreVert, contentDescription = "language") }
DropdownMenu(expanded = languageMenu, onDismissRequest = { languageMenu = false }) {
for (l in listOf("fr", "en")) {
DropdownMenuItem(text = { Text(l.uppercase()) }, onClick = {
languageMenu = false
AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(l))
})
}
}
},
) {
LoginBar(api, onUserChange = { u -> scope.launch { model.onUserChange(u) } })
if (model.user != null && !model.isAdmin) {
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFFFF8E1))) {
Text(t("FORM.ADMIN_ONLY"), Modifier.padding(12.dp))
}
}
if (model.isAdmin) {
for (c in model.clients) {
ListItem(
headlineContent = { Text(c.fullName) },
supportingContent = { Text(c.login ?: "") },
trailingContent = {
Row {
IconButton(onClick = { model.edit(c) }) { Icon(Icons.Default.Edit, contentDescription = t("FORM.EDIT")) }
IconButton(onClick = {
scope.launch {
val name = "${c.firstName} ${c.lastName}"
if (confirmation.confirm(t("FORM.DELETE_CONFIRM", mapOf("name" to name)))) model.remove(c)
}
}) {
Icon(Icons.Outlined.Delete, contentDescription = t("FORM.DELETE"), tint = Color.Red)
}
}
},
)
}
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text(t(if (model.editedId == null) "FORM.TITLE_ADD" else "FORM.TITLE_EDIT"), style = MaterialTheme.typography.titleMedium)
// un título "Dr" que el servidor rechazará: para ver ERRORS.INVALID_TITLE
DropdownList(
label = t("FORM.TITLE"),
value = model.input["title"].orEmpty(),
choices = listOf("Mr", "Mme", "Melle", "Dr"),
onChange = { model.change("title", it) },
error = model.errors["title"]?.let { t(it) },
modifier = Modifier.width(200.dp),
)
Field("firstName")
Field("lastName")
Field("login")
Field("password", secret = true)
Row(Modifier.padding(top = 12.dp)) {
Button(onClick = { scope.launch { model.sending.execute { model.save() } } }, enabled = !model.sending.inProgress) {
Text(t("FORM.SAVE"))
}
Spacer(Modifier.width(8.dp))
OutlinedButton(onClick = { model.newForm() }) { Text(t("FORM.CANCEL")) }
}
model.success?.let { s ->
Text(t(s.key, s.params), color = Color(0xFF2E7D32), modifier = Modifier.padding(top = 12.dp))
}
// el mensaje general, y el estado HTTP, para entender
model.pageError?.let { e ->
Text(
buildAnnotatedString {
withStyle(SpanStyle(color = Color.Red)) { append(t(e.key, e.params)) }
withStyle(SpanStyle(color = Color.Gray, fontSize = 12.sp)) { append(" ($e)") }
},
modifier = Modifier.padding(top = 12.dp),
)
}
}
}
}
}
ConfirmDialog(confirmation)
}
|
- líneas 79–81: el diccionario y un atajo [t(...)];
- líneas 88–96: un campo y su error, una clave del servidor, traducida;
- líneas 106–111: el idioma, en un menú de la barra superior ([DropdownMenu]);
- líneas 170–174: el mensaje general y el código de estado HTTP, como referencia.



A la izquierda, un registro con nombre y apellido en blanco: error 400; en el centro, un homónimo de Alice DURAND: error 409; a la derecha, el mismo error en francés: la entrada actual sobrevivió a la recreación de la actividad, gracias a [ViewModel].