3. Primeros pasos con Kotlin y Jetpack Compose
3.1. Ejemplo 01: la estructura de una aplicación Android
3.1.1. El proyecto
El proyecto de ejemplo fue creado por [Android Studio] (plantilla [Empty Activity], véase el capítulo anterior) y luego completado. Un proyecto [Android] es un proyecto [Gradle]: la herramienta que descarga las bibliotecas, compila el código [Kotlin] y genera el archivo [.apk] que se instala en el teléfono. Se describe mediante unos pocos archivos escritos en [Kotlin] (los archivos [.kts], “Kotlin script”).
3.1.2. El archivo settings.gradle.kts
| // =========================================================================
// settings.gradle.kts - la configuración GLOBAL del proyecto Gradle
// (generado por Android Studio; solo se cambió rootProject.name)
// =========================================================================
// dónde busca Gradle sus PLUGINS (el plugin de Android, el plugin de Compose...)
pluginManagement {
repositories {
google {
content {
includeGroupByRegex("com\\.android.*")
includeGroupByRegex("com\\.google.*")
includeGroupByRegex("androidx.*")
}
}
mavenCentral()
gradlePluginPortal()
}
}
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}
// dónde busca Gradle las BIBLIOTECAS: google() para AndroidX y Compose,
// mavenCentral() para OkHttp, kotlinx.serialization, AndroidSVG
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
}
}
rootProject.name = "examples_kotlin"
// un solo módulo: la aplicación, en la carpeta app/
include(":app")
|
- líneas 7–17: dónde busca [Gradle] sus PLUGINS (extensiones de [Gradle]: el complemento de [Android], el compilador de [Compose]...): el repositorio de Google y el repositorio central de bibliotecas Java ([Maven Central]);
- líneas 25–29: dónde busca [Gradle] las BIBLIOTECAS de la aplicación;
- líneas 3–11: el nombre del proyecto y su único módulo, la aplicación, en la carpeta [app/].
3.1.3. El catálogo de versiones: gradle/libs.versions.toml
Todas las versiones de complementos y bibliotecas se reúnen en un único archivo con formato TOML:
| # =========================================================================
# gradle/libs.versions.toml - el "catálogo de versiones" del proyecto
# -------------------------------------------------------------------------
# TODAS las versiones de los plugins y las bibliotecas, en un único lugar.
# Los archivos build.gradle.kts hacen referencia a ellas por su nombre
# (libs.okhttp, libs.plugins.kotlin.compose...). Es el equivalente de la
# sección dependencies del pubspec.yaml de Flutter.
# =========================================================================
[versions]
agp = "9.4.1"
kotlin = "2.2.10"
coreKtx = "1.17.0"
lifecycle = "2.9.4"
activityCompose = "1.11.0"
composeBom = "2026.02.01"
appcompat = "1.7.1"
navigation = "2.9.5"
datastore = "1.1.7"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
androidsvg = "1.4"
junit = "4.13.2"
junitVersion = "1.3.0"
espressoCore = "3.7.0"
testRunner = "1.7.0"
[libraries]
# — 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" }
androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
# — agregado para los ejemplos —
# los íconos básicos de Material (Add, Delete, Search...)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# el ciclo de vida de la actividad visto desde Compose (ejemplos 13, 20)
androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
# viewModel() en una función @Composable (ejemplos 20, 24, 25)
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# el idioma PROPIO de la aplicación (ejemplos 21, 25)
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
# el enrutador (ejemplos 17, 18)
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
# un pequeño diccionario clave -> valor, guardado en el dispositivo (ejemplo 20)
androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }
# el cliente HTTP (ejemplos 22 a 25)
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# (de)serialización JSON (ejemplos 17, 18, 22 a 25)
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
# dibujar una imagen SVG (ejemplo 03, CAPTCHA de los ejemplos 22 a 25)
androidsvg = { group = "com.caverock", name = "androidsvg-aar", version.ref = "androidsvg" }
[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# genera el código de (de)serialización de las clases @Serializable
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
- sección [[versions]]: los números de versión, con nombre;
- sección [[libraries]]: las bibliotecas, identificadas por su grupo y su nombre ([Maven]) y su versión. Las bibliotecas de [Compose] no tienen versión: es el “BOM” ([compose-bom], “Bill of Materials”) el que fija versiones compatibles para todas a la vez;
- Sección [[plugins]]: los complementos de [Gradle]. Los archivos [build.gradle.kts] hacen referencia a ellos por su nombre: [libs.okhttp], [libs.plugins.kotlin.compose] (los guiones se reemplazan por puntos).
El propósito de cada biblioteca se explica en los comentarios; cada una se mostrará en el ejemplo que la utiliza.
3.1.4. El archivo app/build.gradle.kts
La configuración propia de la aplicación:
| // =========================================================================
// app/build.gradle.kts - la configuración del módulo "app": la aplicación
// de los 25 ejemplos. Generado por Android Studio (plantilla "Empty Activity"),
// y luego completado (líneas marcadas "added").
// =========================================================================
plugins {
// el plugin de Android: compila el código Kotlin (el propio plugin de Android 9
// incluye el soporte de Kotlin) y produce el archivo .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 "paquete" base del código (clase R, BuildConfig...)
namespace = "fr.stahe.examples"
// la versión de la API de Android usada para COMPILAR
compileSdk {
version = release(37)
}
defaultConfig {
// el identificador ÚNICO de la aplicación en el teléfono
applicationId = "fr.stahe.examples"
// la versión de Android más antigua aceptada: Android 8.0 (API 26)
minSdk = 26
// la versión de Android para la que se ha probado la aplicación
targetSdk = 37
versionCode = 1
versionName = "1.0"
// agregado: la dirección del servidor JSON (ejemplos 22 a 25), se puede cambiar en
// tiempo de compilación: gradlew installDebug -Pserver=http://192.168.1.20:8080
val server = providers.gradleProperty("server").getOrElse("http://localhost:8080")
buildConfigField("String", "SERVER_URL", "\"$server\"")
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
optimization {
enable = false
}
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
buildFeatures {
compose = true
// agregado: la clase BuildConfig (BuildConfig.SERVER_URL)
buildConfig = true
}
}
dependencies {
// el "BOM" de Compose: versiones mutuamente compatibles para todas las
// bibliotecas de Compose, declaradas 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 los ejemplos
implementation(libs.androidx.compose.material.icons.core)
implementation(libs.androidx.lifecycle.runtime.compose)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.appcompat)
implementation(libs.androidx.navigation.compose)
implementation(libs.androidx.datastore.preferences)
implementation(libs.okhttp)
implementation(libs.kotlinx.serialization.json)
implementation(libs.androidsvg)
// las pruebas: aquí, la toma de las capturas de pantalla del curso (carpeta androidTest)
testImplementation(libs.junit)
androidTestImplementation(platform(libs.androidx.compose.bom))
androidTestImplementation(libs.androidx.compose.ui.test.junit4)
androidTestImplementation(libs.androidx.espresso.core)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.test.runner)
debugImplementation(libs.androidx.compose.ui.test.manifest)
debugImplementation(libs.androidx.compose.ui.tooling)
}
|
- líneas 6–13: los complementos aplicados al módulo: el complemento de [Android] (que también compila [Kotlin]), el compilador de [Compose] (que transforma las funciones [@Composable]) y el complemento [kotlinx.serialization] (que escribe el código de conversión a JSON de las clases [@Serializable]; véase el Ejemplo 05);
- líneas 18–21: [namespace], el paquete base del código (el de la clase de recursos [R]); [compileSdk], la versión de la API y de [Android] usada para la compilación;
- líneas 24–32: [applicationId], el identificador único de la aplicación en el teléfono; [minSdk = 26]: la aplicación se instala en [Android] 8.0 y versiones posteriores; [targetSdk], la versión para la que se probó;
- líneas 33–36: un campo de la clase [BuildConfig], generado en tiempo de compilación: la dirección del servidor JSON (ejemplos 22–25), que se puede cambiar al compilar ([-Pserver=...]);
- líneas 52–55: [compose = true] activa [Compose]; [buildConfig = true], la clase [BuildConfig];
- Líneas 59–88: las bibliotecas de la aplicación ([implementation]), de las pruebas instrumentadas ([androidTestImplementation]) y de la versión de depuración únicamente ([debugImplementation]).
3.1.5. El archivo AndroidManifest.xml
El manifiesto es la “cédula de identidad” de la aplicación para el sistema [Android]: sus permisos, su clase [Application], sus ACTIVIDADES, las pantallas que [Android] puede iniciar:
| <?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
AndroidManifest.xml - la "cédula de identidad" de la aplicación
............................................................................
Sus permisos, su clase Application, sus actividades (una por
ejemplo, más el menú).
===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- acceso a la red (ejemplos 22 a 25): se concede automáticamente, sin
preguntarle al usuario -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- android:name: la clase Application (ExamplesApplication.kt).
android:usesCleartextTraffic="true": permite HTTP "en texto plano"
(http:// y no https://), bloqueado por defecto desde Android 9: el
servidor JSON de este curso escucha en HTTP simple.
android:localeConfig: los idiomas de la aplicación (ejemplo 21) -->
<application
android:name=".ExamplesApplication"
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:localeConfig="@xml/locales_config"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.Examples"
android:usesCleartextTraffic="true"
tools:targetApi="33">
<!-- el menú: la actividad lanzada por el ícono de la aplicación
(el filtro MAIN / LAUNCHER) -->
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- los ejemplos. exported="false": solo la aplicación puede
abrirlos (adb, sin embargo, siempre puede).
windowSoftInputMode="adjustResize": el teclado reduce la pantalla
en lugar de ocultarla -->
<activity android:name=".ex01.Ex01Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex02.Ex02Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex03.Ex03Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex04.Ex04Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex05.Ex05Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex06.Ex06Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex07.Ex07Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex08.Ex08Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex09.Ex09Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex10.Ex10Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex11.Ex11Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex12.Ex12Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex13.Ex13Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex14.Ex14Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex15.Ex15Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex16.Ex16Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex19.Ex19Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex20.Ex20Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex21.Ex21Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex22.Ex22Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex23.Ex23Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex24.Ex24Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<activity android:name=".ex25.Ex25Activity" android:exported="false" android:windowSoftInputMode="adjustResize" />
<!-- ejemplos 17 y 18: direcciones app://examples/... y
app://examples18/... ("deep links"), que otra
aplicación (o adb) puede abrir: un filtro de intención VIEW -->
<activity android:name=".ex17.Ex17Activity" android:exported="true" android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="app" android:host="examples" />
</intent-filter>
</activity>
<activity android:name=".ex18.Ex18Activity" android:exported="true" android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="app" android:host="examples18" />
</intent-filter>
</activity>
<!-- ejemplo 21: antes de Android 13, es AppCompat quien almacena el
idioma elegido por la aplicación (autoStoreLocales) -->
<service
android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
android:enabled="false"
android:exported="false">
<meta-data
android:name="autoStoreLocales"
android:value="true" />
</service>
</application>
</manifest>
|
- línea 13: permiso para acceder a la red (ejemplos 22 a 25);
- líneas 20–32: la aplicación: su clase [Application] (ejemplo 23), su ícono, su nombre ([@string/app_name], un recurso, véase el ejemplo 21), su tema y el tráfico HTTP en “texto plano” (el servidor de este curso no usa HTTPS);
- líneas 37–43: el menú, la actividad de inicio: el filtro de intents [MAIN] / [LAUNCHER] representa en realidad la actividad que inicia el ícono de la aplicación;
- líneas 49–71: una actividad de ejemplo; [exported="false"]: solo la aplicación puede abrirlas.
3.1.6. La actividad: Ex01Activity.kt
Código del Ejemplo 01:
| // =========================================================================
// ex01/Ex01Activity.kt - una primera aplicación
// -------------------------------------------------------------------------
// Una pantalla de una aplicación Android es una ACTIVIDAD: una clase que
// hereda de ComponentActivity, que el sistema crea cuando se
// inicia la aplicación. Con Jetpack Compose, la actividad casi no hace nada:
// delega su pantalla a funciones @Composable (setContent).
// Una función @Composable DESCRIBE una parte de la pantalla (un texto, un
// botón, una columna...) llamando a otras funciones @Composable:
// forman un ÁRBOL. Compose ejecuta estas funciones para construir
// la pantalla; las EJECUTA DE NUEVO cuando cambia un dato que leen (un "estado"):
// esto es la RECOMPOSICIÓN. Nunca modificamos la pantalla nosotros mismos.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex01
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplesTheme
import java.time.LocalTime
import java.time.format.DateTimeFormatter
// datos "ordinarios", fuera de las funciones @Composable: nunca cambian
const val TITLE = "Welcome to Kotlin"
val languages = listOf("Kotlin", "Jetpack Compose", "Material Design")
// "12:05:09": la hora actual
fun currentTime(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
// la actividad: el punto de entrada de la pantalla (declarada en AndroidManifest.xml)
class Ex01Activity : ComponentActivity() {
// onCreate: Android lo llama cuando se crea la actividad
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// la aplicación también dibuja debajo de la barra de estado y de la barra de navegación
enableEdgeToEdge()
// setContent: Compose toma el control de la pantalla y muestra en ella la
// función @Composable dada, envuelta por el tema de los ejemplos
setContent {
ExamplesTheme {
HomePage()
}
}
}
}
// una función @Composable: su nombre empieza con mayúscula, como una
// clase (es una pieza de interfaz), y no devuelve nada (Unit)
@Composable
fun HomePage() {
// el ESTADO: variables observadas por Compose. Modificarlas provoca
// la reejecución (recomposición) de las funciones que las leen.
// rememberSaveable: el valor se conserva de una ejecución de la función
// a la siguiente... e incluso cuando Android recrea la actividad (rotación
// de pantalla, cambio de idioma)
var counter by rememberSaveable { mutableIntStateOf(0) }
var time by rememberSaveable { mutableStateOf(currentTime()) }
// Scaffold: la estructura de una pantalla Material (barra superior, contenido...)
Scaffold(
topBar = { TopAppBar(title = { Text("Example 01 - a first application") }) },
) { insets ->
// Column: hijos colocados uno debajo del otro; los insets
// del Scaffold (el espacio de la barra superior), y luego 16 dp más
Column(modifier = Modifier.padding(insets).padding(16.dp)) {
Text(TITLE, style = MaterialTheme.typography.headlineSmall)
Spacer(Modifier.height(12.dp))
Text(
"This screen is built by Jetpack Compose, from the activity " +
"Ex01Activity and the function HomePage.",
)
Spacer(Modifier.height(8.dp))
// ${expression} inserta el valor de una expresión en una cadena
Text("It is written in ${languages.joinToString(", ")} (${languages.size} technologies).")
Spacer(Modifier.height(16.dp))
// onClick: la función (aquí una "lambda") que se llama al presionar.
// Modificamos el ESTADO; Compose actualiza la pantalla
Button(onClick = {
counter++
time = currentTime()
}) {
Text("Click me")
}
Spacer(Modifier.height(16.dp))
Text(
"You clicked $counter times (last click: $time).",
fontWeight = FontWeight.Bold,
color = Color(0xFF087EA4),
)
}
}
}
|
- línea 16: el paquete ([package]) del archivo: cada ejemplo tiene el suyo, lo que permite que nombres idénticos (una función [HomePage]) aparezcan en dos ejemplos;
- línea 14: [@file:OptIn(...)]: algunas funciones de [Material 3] ([TopAppBar]) siguen marcadas como “experimentales”; declaramos que las usamos con pleno conocimiento de los riesgos;
- líneas 47–48: datos ordinarios, fuera de cualquier función [@Composable]; [const val]: una constante conocida en tiempo de compilación;
- línea 54: la ACTIVIDAD, una clase que hereda de [ComponentActivity]. [Android] la crea cuando se inicia la pantalla y luego llama a su función [onCreate];
- líneas 59–64: [enableEdgeToEdge()]: la aplicación también dibuja debajo de la barra de estado y debajo de la barra de navegación del teléfono (esta es la regla desde [Android] 15) ; [setContent [ ... ]]: [Compose] toma el control de la pantalla y muestra allí el contenido del bloque. [ExamplesTheme] (archivo [common/Theme.kt]) aplica los colores de [Material 3] a todo lo que contiene;
- líneas 7–73: una función [@Composable]: DESCRIBE una parte de la pantalla llamando a otras funciones [@Composable]. Por convención, su nombre comienza con mayúscula, como una clase; no devuelve nada;
- líneas 79–80: el ESTADO. [mutableIntStateOf(0)] crea un valor OBSERVADO por [Compose]: cuando cambia, [Compose] vuelve a ejecutar las funciones que lo leen (recomposición). [by] delega la variable [counter] en este estado: [counter++] se escribe igual que para una variable ordinaria. [rememberSaveable]: el valor se conserva de una ejecución de la función a la siguiente (sin [remember], cada ejecución restablecería el estado a 0)... e incluso cuando [Android] RECREA la actividad, lo que hace cada vez que la pantalla gira;
- Líneas 83–85: [Scaffold], la estructura de una pantalla [Material]: una barra superior ([topBar]) y un contenido. El contenido es una lambda que recibe los MÁRGENES que debe respetar (la posición de la barra superior);
- línea 88: [Column] coloca a sus hijos uno debajo del otro. [Modifier]: el método de [Compose] para ajustar un componente (márgenes, tamaño, fondo, respuesta a gestos, etc.): los modificadores se encadenan en el orden en que se aplican;
- líneas 89–97: texto y espaciado ([Spacer]); [MaterialTheme.typography.headlineSmall]: uno de los estilos de texto del tema; ["$[...]"] inserta una expresión en una cadena;
- líneas 101–105: un botón. [onClick] recibe la función (una lambda) que se ejecutará cuando se presione el botón: cambia el estado y nada más. Nunca interactuamos directamente con la pantalla: [Compose] vuelve a ejecutar [HomePage], que muestra el nuevo contador; la última lambda, encerrada entre llaves después de los paréntesis, es el CONTENIDO del botón (su texto);
- líneas 109–111: un texto que lee el estado; se actualizará con cada clic.
El tema de los ejemplos, [common/Theme.kt]:
| // =========================================================================
// common/Theme.kt - el tema compartido por todos los ejemplos
// -------------------------------------------------------------------------
// MaterialTheme: los colores, textos y formas de Material
// Design 3, que TODOS los componentes Material colocados dentro usan
// (botones, campos, tarjetas...). Le damos un conjunto de colores (un
// ColorScheme), claro u oscuro, construido en torno a un azul índigo.
// ExamplesTheme(dark = true): el tema oscuro (cf. ejemplo 20).
// =========================================================================
package fr.stahe.examples.common
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
// los colores del tema claro: los demás son los valores predeterminados de Material 3
private val lightColors = lightColorScheme(
primary = Color(0xFF4355B9),
onPrimary = Color.White,
primaryContainer = Color(0xFFDEE0FF),
onPrimaryContainer = Color(0xFF00105C),
secondaryContainer = Color(0xFFE0E1F9),
onSecondaryContainer = Color(0xFF181A2C),
surface = Color(0xFFFBF8FF),
surfaceContainer = Color(0xFFEFEDF4),
surfaceContainerLow = Color(0xFFF5F2FA),
)
// los colores del tema oscuro
private val darkColors = darkColorScheme(
primary = Color(0xFFBAC3FF),
onPrimary = Color(0xFF08218A),
primaryContainer = Color(0xFF293CA0),
onPrimaryContainer = Color(0xFFDEE0FF),
secondaryContainer = Color(0xFF434659),
onSecondaryContainer = Color(0xFFE0E1F9),
)
// una función @Composable que "envuelve" un contenido: el parámetro
// content es a su vez una función @Composable (cf. ejemplo 12)
@Composable
fun ExamplesTheme(dark: Boolean = false, content: @Composable () -> Unit) {
MaterialTheme(
colorScheme = if (dark) darkColors else lightColors,
content = content,
)
}
|
- [lightColorScheme(...)], [darkColorScheme(...)]: los colores de [Material 3], claro y oscuro; los colores no especificados conservan sus valores predeterminados;
- [ExamplesTheme(dark, content)]: una función [@Composable] que recibe... otra función [@Composable], su contenido. Este es el mecanismo central de la composición (véase el Ejemplo 12): [ExamplesTheme [ HomePage() ]] llama a [MaterialTheme] con este contenido.
3.1.7. Ejecución
En [Android Studio], el botón [Run] inicia la aplicación: aparece el menú de ejemplos; la primera línea abre el Ejemplo 01. Después de dos clics en el botón:


Gire el teléfono (o el emulador, con el botón de rotación de su barra de herramientas): [Android] destruye la actividad y luego la recrea, y sin embargo el contador se mantiene, gracias a [rememberSaveable]. Reemplace [rememberSaveable] por [remember]: el contador vuelve a 0 en cada rotación. Esta es una diferencia clave con [Flutter], donde la pantalla persiste durante la rotación: con [Android], cuando cambian los ajustes del dispositivo (orientación, idioma, tamaño del texto, etc.), la actividad se recrea.
3.2. Ejemplo 02: estado y valores calculados
Una calculadora sencilla de precios con IVA incluido, que distingue entre el estado (lo que el usuario ha ingresado) y el cálculo resultante. En este ejemplo, la estructura de la pantalla (barra superior, contenido desplazable) se define de una vez por todas en [common/ExamplePage.kt]:
| // =========================================================================
// common/ExamplePage.kt - la estructura común de las pantallas de los ejemplos
// -------------------------------------------------------------------------
// Todos los ejemplos (del 02 en adelante) tienen la misma estructura de pantalla: una
// barra superior con un título y luego un contenido en una columna, que SE DESPLAZA si
// excede la altura de la pantalla. En lugar de reescribirla 25 veces,
// la escribimos una sola vez, en una función @Composable que recibe el contenido como
// parámetro (cf. ejemplo 12):
//
// ExamplePage("Example 02 - state") {
// Text("...") // el contenido: componentes, uno debajo del otro
// Button(...) { ... }
// }
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.common
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ColumnScope
import androidx.compose.foundation.layout.RowScope
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
@Composable
fun ExamplePage(
title: String,
// un ícono a la izquierda del título (ninguno por defecto)
icon: @Composable () -> Unit = {},
// botones a la derecha de la barra superior (ninguno por defecto)
actions: @Composable RowScope.() -> Unit = {},
// el área de los mensajes efímeros (Snackbar, cf. ejemplo 16), opcional
messages: SnackbarHostState? = null,
// el contenido: una función @Composable, llamada DENTRO de una Column
content: @Composable ColumnScope.() -> Unit,
) {
Scaffold(
topBar = {
TopAppBar(
title = { Text(title, style = MaterialTheme.typography.titleMedium, maxLines = 2) },
navigationIcon = icon,
actions = actions,
)
},
snackbarHost = { if (messages != null) SnackbarHost(messages) },
) { insets ->
Column(
modifier = Modifier
// los insets del Scaffold: debajo de la barra superior, encima de
// la barra de navegación del teléfono
.padding(insets)
.consumeWindowInsets(insets)
// el teclado del teléfono no oculta la parte inferior de la pantalla
.imePadding()
.fillMaxSize()
// la columna se desplaza si es más alta que la pantalla
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(4.dp),
content = content,
)
}
}
|
- [content: @Composable ColumnScope.() -> Unit]: el contenido es una función [@Composable] a la que se llama DENTRO de una [Column] (por lo tanto, puede usar modificadores propios de las columnas, como [weight]);
- [verticalScroll(rememberScrollState())]: la columna se desplaza si supera la altura de la pantalla; [imePadding()]: el teclado del teléfono no oculta la parte inferior de la pantalla;
- Se llama con una lambda final: [ExamplePage("title") [ Text(...) ; Button(...) ]].
El código del ejemplo:
| // =========================================================================
// ex02/Ex02Activity.kt - estado y valores calculados
// -------------------------------------------------------------------------
// Una pequeña calculadora de precios con IVA incluido:
// - el ESTADO: variables mutableStateOf; cambiarlas reejecuta
// (recompone) la función que las lee, que construye la pantalla con los
// nuevos valores;
// - un valor CALCULADO a partir del estado NO es un estado: es una
// simple variable local, recalculada en cada ejecución de la función.
// Siempre está al día, sin nada que sincronizar;
// - un dato que depende de los valores SUCESIVOS del estado (el historial
// de los totales) se actualiza donde cambia el estado;
// - el título de la aplicación en la lista de aplicaciones recientes
// sigue al estado, como el resto de la pantalla (TaskTitle).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex02
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.KeyboardArrowDown
import androidx.compose.material3.Card
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SegmentedButton
import androidx.compose.material3.SegmentedButtonDefaults
import androidx.compose.material3.SingleChoiceSegmentedButtonRow
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableDoubleStateOf
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.common.TaskTitle
import java.text.NumberFormat
import java.util.Locale
// un formateador de montos en euros, al estilo inglés (€1,234.50), cf. ejemplo 09
val euros: NumberFormat = NumberFormat.getCurrencyInstance(Locale.US).apply { currency = java.util.Currency.getInstance("EUR") }
// las tasas de IVA propuestas
val rates = listOf(5.5, 10.0, 20.0)
// "2,5" o "2.5" -> 2.5; un texto que no es un número -> 0
fun price(text: String): Double = text.replace(',', '.').toDoubleOrNull() ?: 0.0
// el total con IVA incluido: una función PURA (su resultado solo depende de sus parámetros)
fun totalInclVat(priceExclVat: Double, quantity: Int, vatRate: Double): Double = quantity * priceExclVat * (1 + vatRate / 100)
class Ex02Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { CalculatorPage() } }
}
}
@Composable
fun CalculatorPage() {
// el estado: lo que el usuario ha escrito o elegido
var label by rememberSaveable { mutableStateOf("Pen") }
var priceText by rememberSaveable { mutableStateOf("2.5") } // el texto del campo, tal como se escribió
var quantity by rememberSaveable { mutableIntStateOf(1) }
var vatRate by rememberSaveable { mutableDoubleStateOf(20.0) }
// el historial de los últimos 5 cambios del total con IVA: una lista
// NO MODIFICABLE, reemplazada por una nueva lista en cada cambio
var history by rememberSaveable { mutableStateOf(listOf<String>()) }
// valores CALCULADOS: simples variables locales, recalculadas en
// cada ejecución de la función
val priceExclVat = price(priceText)
val totalExclVat = quantity * priceExclVat
val vatAmount = totalExclVat * vatRate / 100
val inclVat = totalExclVat + vatAmount
// TODOS los cambios del estado pasan por esta función local:
// anota el total con IVA antes del cambio, aplica el cambio y
// completa el historial si el total ha cambiado
fun change(update: () -> Unit) {
val old = inclVat
update()
// las variables de estado YA tienen su nuevo valor
val newTotal = totalInclVat(price(priceText), quantity, vatRate)
if (newTotal != old) {
history = (listOf("${euros.format(old)} -> ${euros.format(newTotal)}") + history).take(5)
}
}
// el título de la aplicación SIGUE al estado, como todo lo demás
TaskTitle("Incl. VAT: ${euros.format(inclVat)}")
val totalStyle = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold)
ExamplePage("Example 02 - state") {
Card {
Column(Modifier.padding(16.dp)) {
// un campo CONTROLADO: muestra value y llama a onValueChange
// en cada pulsación de tecla, con el nuevo texto
OutlinedTextField(
value = label,
// cambiar el elemento restablece la cantidad a 1: se hace donde
// sabemos POR QUÉ cambia el estado
onValueChange = { newValue ->
change {
label = newValue
quantity = 1
}
},
label = { Text("Item") },
modifier = Modifier.fillMaxWidth(),
)
OutlinedTextField(
value = priceText,
onValueChange = { text -> change { priceText = text } },
label = { Text("Unit price excl. VAT") },
// el teclado numérico del teléfono
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(12.dp))
Row(verticalAlignment = Alignment.CenterVertically) {
// weight(1f): el texto ocupa todo el ancho restante
Text("Quantity (back to 1 if the item changes)", Modifier.weight(1f))
// enabled = false: el botón está deshabilitado
IconButton(onClick = { change { quantity-- } }, enabled = quantity > 0) {
Icon(Icons.Default.KeyboardArrowDown, contentDescription = "minus")
}
Text("$quantity", style = totalStyle)
IconButton(onClick = { change { quantity++ } }) {
Icon(Icons.Default.Add, contentDescription = "plus")
}
}
Spacer(Modifier.height(8.dp))
// botones de los cuales solo UNO está seleccionado: la tasa de IVA
SingleChoiceSegmentedButtonRow(Modifier.fillMaxWidth()) {
rates.forEachIndexed { i, t ->
SegmentedButton(
selected = t == vatRate,
onClick = { change { vatRate = t } },
shape = SegmentedButtonDefaults.itemShape(index = i, count = rates.size),
) {
Text("${t.toString().removeSuffix(".0")} %")
}
}
}
Spacer(Modifier.height(12.dp))
OutlinedButton(onClick = {
change {
label = "Pen"
priceText = "2.5"
quantity = 1
vatRate = 20.0
}
}) {
Text("Reset")
}
}
}
Card {
Column(Modifier.padding(16.dp)) {
Text("$quantity x $label", style = MaterialTheme.typography.titleLarge)
HorizontalDivider(Modifier.padding(vertical = 8.dp))
Line("Total excl. VAT", euros.format(totalExclVat))
Line("VAT ($vatRate %)", euros.format(vatAmount))
Line("Total incl. VAT", euros.format(inclVat), totalStyle)
}
}
Card {
Column(Modifier.padding(16.dp).fillMaxWidth()) {
Text("History of the total incl. VAT", style = MaterialTheme.typography.titleSmall)
// una línea de texto por elemento del historial (cf. ejemplo 03)
for (line in history) {
Text("• $line")
}
}
}
}
}
// una línea "etiqueta ....... monto": una función @Composable que construye
// otras. style: un parámetro opcional, con su valor predeterminado
@Composable
fun Line(label: String, amount: String, style: TextStyle = MaterialTheme.typography.bodyLarge) {
Row(Modifier.padding(vertical = 4.dp)) {
Text(label, Modifier.weight(1f), style = style)
Text(amount, style = style)
}
}
|
- líneas 72–75: funciones PURAS, fuera de la pantalla: el precio ingresado (["2,5"] o ["2.5"]) convertido en número, el total con IVA;
- líneas 88–94: el estado. [history] es una lista NO MODIFICABLE ([listOf]): se reemplaza por una lista nueva con cada cambio, lo que [Compose] detecta (la asignación del estado);
- líneas 98–101: los valores CALCULADOS son simplemente variables locales. La función se vuelve a ejecutar con cada cambio de estado: siempre están actualizados, por lo que no hay nada que sincronizar;
- líneas 106–112: una función LOCAL, por la que pasan todos los cambios: registra el total antes del cambio, aplica el cambio ([update()]: la función pasada como parámetro), calcula el nuevo total y actualiza el historial. Las variables de estado ya tienen sus nuevos valores inmediatamente después de la asignación; [take(5)] conserva las primeras cinco líneas;
- línea 117: el título de la aplicación en la lista de aplicaciones recientes sigue al estado (función [TaskTitle] de [common/TaskTitle.kt], que llama a [setTaskDescription] de la actividad);
- líneas 125–136: un campo CONTROLADO: muestra [value] y llama a [onValueChange] con cada pulsación de tecla, con el nuevo texto. Con [Compose], el texto de un campo es simplemente otro estado: no hay que crear ni liberar ningún controlador, y [Reset] solo necesita cambiar el estado;
- línea 143: [KeyboardOptions(keyboardType = KeyboardType.Decimal)]: el teclado numérico del teléfono;
- líneas 147–156: la cantidad: [enabled = quantity > 0] deshabilita el botón “menos” en 0; [Modifier.weight(1f)]: el texto ocupa todo el ancho restante de la línea;
- líneas 44–168: botones “segmentados”, de los cuales solo UNO está seleccionado: la tasa de IVA. [forEachIndexed] recorre la lista con el índice de cada elemento; [itemShape] redondea las esquinas del primer y del último elemento;
- líneas 209–212: [Line], una función [@Composable] con parámetros, uno de los cuales es opcional ([style], con su valor predeterminado).


A la izquierda, después de tocar [+] dos veces, seleccionar 10% e ingresar 3.2; a la derecha, el artículo ha cambiado: la cantidad volvió a 1 y el historial registró cada cambio del total.
3.3. Ejemplo 03: escribir un árbol de componentes
[Compose] no tiene un lenguaje de plantillas: para condiciones y bucles, usamos las instrucciones de [Kotlin], directamente dentro de la función [@Composable]. Una lista de médicos, filtrada por una entrada:
| // =========================================================================
// ex03/Ex03Activity.kt - escribir un árbol de componentes
// -------------------------------------------------------------------------
// Compose no tiene lenguaje de plantillas (ni HTML ni XML): las
// pantallas se escriben en Kotlin, con llamadas anidadas a funciones
// @Composable. Y para las condiciones y los bucles, usamos... las
// instrucciones ordinarias de Kotlin, DIRECTAMENTE en la función:
// - if (condition) { Component() } : un componente que solo EXISTE
// si la condición es verdadera;
// - if (c) { A() } else { B() } : uno O el otro;
// - for (x in list) { Component(x) } : un componente por elemento;
// - when (value) { case -> ... } : un valor entre varios.
// Una función @Composable es una función como cualquier otra: todo el
// lenguaje está disponible para describir la pantalla.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex03
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.Face
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.Search
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.SuggestionChipDefaults
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.alpha
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.R
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
// una "enumeración": los únicos valores posibles de una especialidad
enum class Specialty { GENERAL_PRACTITIONER, PEDIATRICIAN, CARDIOLOGIST }
// una clase DATA: sus propiedades son val, un objeto Doctor nunca
// cambia. Kotlin le agrega equals, hashCode, toString y copy
data class Doctor(
val id: Int,
val title: String,
val firstName: String,
val lastName: String,
val specialty: Specialty,
val available: Boolean,
)
val doctors = listOf(
Doctor(1, "Mme", "Marie", "PELISSIER", Specialty.GENERAL_PRACTITIONER, true),
Doctor(2, "Mr", "Paul", "TATOU", Specialty.PEDIATRICIAN, false),
Doctor(3, "Melle", "Sophie", "DUPONT", Specialty.CARDIOLOGIST, true),
)
// "un valor entre varios, según un valor": una EXPRESIÓN when.
// El compilador verifica que se traten todos los casos de la enumeración
fun label(s: Specialty): String = when (s) {
Specialty.GENERAL_PRACTITIONER -> "general practitioner"
Specialty.PEDIATRICIAN -> "pediatrician"
Specialty.CARDIOLOGIST -> "cardiologist"
}
// un ícono y su color: un "par" de valores (Pair), escrito con "to"
fun icon(s: Specialty): Pair<ImageVector, Color> = when (s) {
Specialty.PEDIATRICIAN -> Icons.Default.Face to Color(0xFFFF9800)
Specialty.CARDIOLOGIST -> Icons.Default.Favorite to Color.Red
else -> Icons.Default.AddCircle to Color(0xFF009688) // else: todos los demás casos
}
class Ex03Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { DoctorsPage() } }
}
}
@Composable
fun DoctorsPage() {
var filter by rememberSaveable { mutableStateOf("") } // el texto buscado
var onlyAvailable by rememberSaveable { mutableStateOf(false) }
var showHelp by rememberSaveable { mutableStateOf(true) }
// la lista mostrada: una variable ordinaria, recalculada en cada ejecución
val text = filter.trim().lowercase()
val displayed = doctors.filter { d ->
(!onlyAvailable || d.available) &&
"${d.firstName} ${d.lastName} ${label(d.specialty)}".lowercase().contains(text)
}
ExamplePage(
title = "Example 03 - components",
// una imagen vectorial incluida con la aplicación (res/drawable/doctor.xml)
icon = {
Image(
painter = painterResource(R.drawable.doctor),
contentDescription = null,
modifier = Modifier.padding(12.dp).size(28.dp),
)
},
) {
OutlinedTextField(
value = filter,
onValueChange = { filter = it }, // it: el único parámetro de una lambda
placeholder = { Text("search...") },
leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
modifier = Modifier.fillMaxWidth(),
)
// un interruptor, con su etiqueta
ListItem(
headlineContent = { Text("available only") },
trailingContent = { Switch(checked = onlyAvailable, onCheckedChange = { onlyAvailable = it }) },
)
TextButton(onClick = { showHelp = !showHelp }) {
Text(if (showHelp) "Hide help" else "Show help")
}
// un if: este componente solo EXISTE si showHelp es true
if (showHelp) {
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFE1F5FE))) {
Text(
"Type a name or a specialty. Unavailable doctors are greyed out.",
Modifier.padding(12.dp),
)
}
}
// "uno de los tres bloques": un when sin argumento, como una serie de if
when {
doctors.isEmpty() -> Text("No doctor.")
displayed.isEmpty() -> Text("No doctor matches \"$filter\".", color = Color(0xFFFF5722))
else -> Column {
// un componente por médico, con su posición: withIndex()
for ((i, d) in displayed.withIndex()) {
DoctorRow(i + 1, d)
}
}
}
Spacer(Modifier.height(12.dp))
// un estilo CALCULADO: el tamaño del texto depende del número de médicos mostrados
Text(
"${displayed.size} doctor(s) displayed - the size of this text depends on it.",
fontSize = (12 + displayed.size * 2).sp,
)
}
}
// una línea de la lista: una función @Composable con parámetros
@Composable
fun DoctorRow(rank: Int, d: Doctor) {
val (image, color) = icon(d.specialty) // una "desestructuración" del par
ListItem(
// alpha: los médicos no disponibles se muestran atenuados
modifier = Modifier.alpha(if (d.available) 1f else 0.5f),
leadingContent = { Text("$rank", style = MaterialTheme.typography.titleMedium) },
headlineContent = { Text("${d.title} ${d.firstName} ${d.lastName}") },
// FlowRow: como un Row, pero salta a la línea siguiente si falta espacio
supportingContent = {
FlowRow(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
Icon(image, contentDescription = null, tint = color, modifier = Modifier.size(18.dp))
Text(label(d.specialty))
}
},
trailingContent = {
SuggestionChip(
onClick = {},
label = { Text(if (d.available) "available" else "unavailable") },
// un color elegido mediante una expresión condicional
colors = SuggestionChipDefaults.suggestionChipColors(
containerColor = if (d.available) Color(0xFFC8E6C9) else Color(0xFFE0E0E0),
),
)
},
)
}
|
- líneas 68–78: una enumeración y una clase de datos ([data class]): [Kotlin] escribe [equals], [hashCode], [toString] y [copy];
- líneas 89–99: una EXPRESIÓN [when]: un valor entre varios; el compilador verifica que se traten todos los casos de la enumeración ([else]: todos los demás). [to] crea un par ([Pair]);
- líneas 117–120: la lista mostrada, calculada en cada ejecución a partir del estado ([filter]);
- líneas 126–130: [icon]: una ranura de [ExamplePage] para el ícono de la barra superior. [painterResource(R.drawable.doctor)]: una imagen de la aplicación (un archivo VECTORIAL, el formato vectorial de [Android], convertido a partir del archivo SVG del ejemplo de Flutter con [New / Vector Asset] de [Android Studio]). [R]: la clase generada que asigna un número a cada recurso;
- línea 136: [it]: el nombre del único parámetro de una lambda;
- línea 150: un [if]: el componente solo EXISTE si la condición es verdadera;
- líneas 159–165: un [when] sin argumentos (una secuencia de [if]): uno de los tres bloques; un bucle [for], con el índice de cada elemento ([withIndex()] y una desestructuración [(i, d)]);
- línea 173: un estilo calculado: el tamaño del texto depende del número de médicos ([sp]: la unidad para el texto, que sigue el ajuste de tamaño de texto del teléfono; [dp]: la unidad para las distancias);
- líneas 180–199: una línea de lista ([ListItem], con sus posiciones [leadingContent], [headlineContent]...), atenuada con [Modifier.alpha] si el médico no está disponible; [FlowRow]: una fila que pasa a la línea siguiente si no hay espacio suficiente; una viñeta ([SuggestionChip]) cuyo color depende del médico.



3.4. Ejemplo 04: eventos
Una lista de tareas pendientes: se pueden agregar elementos, marcarlos y eliminarlos (con un botón o deslizando la línea, el gesto típico en un dispositivo móvil), además de un área sensible al tacto. Un componente interactivo recibe FUNCIONES como parámetros para llamarlas cuando ocurre algo: son los “eventos” de [Compose].
| // =========================================================================
// ex04/Ex04Activity.kt - reaccionar a las acciones del usuario
// -------------------------------------------------------------------------
// Un componente interactivo recibe como parámetros las FUNCIONES que debe llamar
// cuando algo ocurre ("callbacks", lambdas de Kotlin):
// - onClick = { ... } : se llama al presionar (botones);
// - onClick = { remove(t) } : la lambda pasa sus propios argumentos;
// - onValueChange, onCheckedChange : la función recibe un valor (el
// texto, la casilla marcada...);
// - Modifier.pointerInput : agrega gestos (toque, doble
// toque, pulsación larga...) a CUALQUIER
// componente;
// - SwipeToDismissBox : deslizar una línea para
// eliminarla, el gesto típico de los móviles.
// Para dar el foco a un campo desde el código, le asociamos un
// FocusRequester.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex04
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Button
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.SwipeToDismissBox
import androidx.compose.material3.Text
import androidx.compose.material3.rememberSwipeToDismissBoxState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.math.roundToInt
// una tarea: una data class NO MODIFICABLE; para "marcarla",
// hacemos una copia: task.copy(done = true)
data class Task(val id: Int, val label: String, val done: Boolean = false)
class Ex04Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { TasksPage() } }
}
}
@Composable
fun TasksPage() {
// listas OBSERVADAS por Compose: agregar, eliminar o reemplazar un
// elemento provoca la recomposición. (remember, y no rememberSaveable:
// se pierden si se recrea la actividad, cf. ejemplo 20)
val tasks = remember {
mutableStateListOf(Task(1, "Install Android Studio", done = true), Task(2, "Read the chapter on events"))
}
val log = remember { mutableStateListOf<String>() }
var input by remember { mutableStateOf("") }
var nextId by remember { mutableIntStateOf(3) }
// el FocusRequester: una forma de dar el foco al campo (el cursor y el
// teclado del teléfono) desde el código
val focus = remember { FocusRequester() }
fun trace(message: String) {
val time = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm"))
log.add(0, "$time $message")
}
// lo llaman el botón Y la tecla "OK" del teclado (keyboardActions)
fun add() {
val label = input.trim()
if (label.isEmpty()) {
return
}
tasks.add(Task(nextId++, label))
trace("added \"$label\"")
input = ""
// el foco vuelve al campo: se puede escribir la siguiente tarea
focus.requestFocus()
}
fun toggle(task: Task, done: Boolean) {
// REEMPLAZAMOS la tarea con una copia modificada
tasks[tasks.indexOf(task)] = task.copy(done = done)
trace("\"${task.label}\": ${if (done) "done" else "to do"}")
}
fun remove(task: Task, how: String) {
tasks.remove(task)
trace("removed \"${task.label}\" ($how)")
}
// la densidad de pantalla: para convertir píxeles en dp
val density = LocalDensity.current.density
ExamplePage("Example 04 - events") {
Row(verticalAlignment = Alignment.CenterVertically) {
OutlinedTextField(
value = input,
onValueChange = { input = it },
placeholder = { Text("new task (Escape to clear)") },
singleLine = true,
// la tecla "OK" del teclado del teléfono agrega la tarea
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
keyboardActions = KeyboardActions(onDone = { add() }),
modifier = Modifier
.weight(1f)
.focusRequester(focus)
// un teclado físico (emulador, tableta): Escape vacía el campo
.onPreviewKeyEvent { event ->
if (event.key == Key.Escape) {
input = ""
true // el evento se ha manejado
} else {
false // el evento continúa su camino
}
},
)
Spacer(Modifier.width(8.dp))
Button(onClick = { add() }) { Text("Add") }
}
Spacer(Modifier.height(12.dp))
for (t in tasks) {
// key(t.id): la IDENTIDAD de la línea. El estado de cada línea (su
// deslizamiento) sigue a SU tarea, aunque la lista cambie (cf. el curso)
key(t.id) {
TaskRow(
task = t,
onToggle = { done -> toggle(t, done) },
onRemove = { how -> remove(t, how) },
)
}
}
Spacer(Modifier.height(12.dp))
// pointerInput: cualquier componente se vuelve sensible a los gestos
Box(
contentAlignment = Alignment.Center,
modifier = Modifier
.fillMaxWidth()
.height(80.dp)
.background(Color(0xFFE7F5FF), RoundedCornerShape(8.dp))
.pointerInput(Unit) {
detectTapGestures(
// la posición de la pulsación, relativa al componente (en píxeles)
onPress = { p -> trace("press at (${(p.x / density).roundToInt()}, ${(p.y / density).roundToInt()})") },
onDoubleTap = { trace("double tap") },
onLongPress = { trace("long press") },
)
},
) {
Text("Touch this area (tap, double tap, long press)")
}
Spacer(Modifier.height(16.dp))
Text("Log", style = MaterialTheme.typography.titleSmall)
for (line in log) {
Text(line, fontSize = 12.sp)
}
}
}
// una línea de la lista: la tarea, y DOS funciones para notificar al llamador
@Composable
fun TaskRow(task: Task, onToggle: (Boolean) -> Unit, onRemove: (String) -> Unit) {
// el estado de deslizamiento de la línea (¿dónde está?)
val swipe = rememberSwipeToDismissBoxState()
// SwipeToDismissBox: deslizar la línea hacia la izquierda la elimina
SwipeToDismissBox(
state = swipe,
enableDismissFromStartToEnd = false,
// onDismiss: se llama cuando la línea se ha deslizado por completo
onDismiss = { onRemove("swipe") },
// lo que aparece DEBAJO de la línea cuando se desliza
backgroundContent = {
Box(
contentAlignment = Alignment.CenterEnd,
modifier = Modifier.fillMaxSize().background(Color(0xFFFFCDD2)).padding(end = 16.dp),
) {
Icon(Icons.Default.Delete, contentDescription = null)
}
},
) {
ListItem(
// la caja está A LA IZQUIERDA, como en una lista de tareas;
// pasa su nuevo valor (un Boolean)
leadingContent = { Checkbox(checked = task.done, onCheckedChange = onToggle) },
headlineContent = {
Text(
task.label,
style = if (task.done) {
TextStyle(textDecoration = TextDecoration.LineThrough, color = Color.Gray)
} else {
TextStyle.Default
},
)
},
trailingContent = {
IconButton(onClick = { onRemove("button") }) {
Icon(Icons.Outlined.Delete, contentDescription = "remove", tint = Color.Red)
}
},
)
}
}
|
- línea 84: una tarea, un objeto NO MODIFICABLE; al marcarla se crea una copia ([copy(done = true)]) que la REEMPLAZA;
- líneas 99–102: [mutableStateListOf]: una lista OBSERVADA por [Compose]; agregar, quitar o reemplazar un elemento provoca una reconstrucción. Aquí conservamos [remember] (no [rememberSaveable]): estas listas se pierden si la actividad se recrea;
- línea 107: un [FocusRequester], mediante el cual el código da el foco (el cursor y el teclado) al campo después de cada adición ([focus.requestFocus()]);
- líneas 115–135: tres funciones locales que modifican el estado y mantienen el registro;
- líneas 149–150: [imeAction = ImeAction.Done]: la tecla de confirmación del teclado del teléfono pasa a ser “OK”, y [keyboardActions] especifica qué hacer cuando se presiona: agregar la tarea;
- líneas 68–160: [onPreviewKeyEvent] recibe las pulsaciones de un teclado FÍSICO (el de la PC en el emulador, o el de una tableta): [Escape] borra el campo. Devolver [true] detiene el evento;
- líneas 171–175: [key(t.id)] asigna una IDENTIDAD a cada línea. Sin [key], [Compose] asocia el estado de una fila (en este caso, su posición de desplazamiento) con su POSICIÓN en la lista: después de una eliminación, la fila siguiente heredaría el estado de la fila eliminada. Las dos expresiones lambda [onToggle] y [onRemove] “capturan” la tarea [t] y transmiten lo que la línea les pasa;
- líneas 187–192: [Modifier.pointerInput] hace que CUALQUIER componente responda a gestos: distingue entre un toque simple, un toque doble y una pulsación larga. La posición se da en píxeles: se convierte a [dp] con la densidad de la pantalla ([LocalDensity]);
- línea 208: [TaskRow] recibe la tarea y DOS funciones para notificar a quien la llama: no modifica la lista por sí misma (véase el Ejemplo 11);
- líneas 212–218: [SwipeToDismissBox]: la línea se mueve hacia la izquierda ([enableDismissFromStartToEnd = false] impide el movimiento en la otra dirección) y deja ver [backgroundContent]; al llegar al final, se llama a [onDismiss];
- línea 230: la casilla de verificación transmite su nuevo valor ([Boolean]): se le pasa directamente [onToggle], que tiene el tipo correcto [(Boolean) -> Unit];



A la izquierda, se agregó una tarea, se marcó otra y se tocó el área; en el centro, la primera fila se desliza hacia la izquierda; a la derecha, se eliminó y el registro lo confirma.
3.5. Ejemplo 05: todos los tipos de campos
Con [Compose], TODOS los campos son CONTROLADOS: el campo muestra un valor del estado y notifica cada cambio mediante una función que actualiza el estado. Lo que transmite esta función depende del campo:
- [OutlinedTextField]: el nuevo texto ([String]);
- [Checkbox], [Switch]: un [Boolean];
- [RadioButton], [FilterChip]: nada: la opción ESTÁ seleccionada;
- [Slider]: un [Float];
- [DatePickerDialog]: una fecha, al confirmar.
Para la lista desplegable, [Material 3] no proporciona un componente único y autónomo: se ensambla de una vez por todas en [common/DropdownList.kt]:
| // =========================================================================
// common/DropdownList.kt - una lista desplegable, lista para usar
// -------------------------------------------------------------------------
// Material 3 para Compose no tiene un componente "lista desplegable" en una
// sola pieza: se ensambla a partir de tres elementos - ExposedDropdownMenuBox,
// un campo de texto de solo lectura y el menú ExposedDropdownMenu. Lo
// hacemos aquí de una vez por todas (ejemplos 05 a 08, 24, 25):
//
// DropdownList("Country", value = country, choices = listOf("fr", "be", "ch"),
// text = { countryNames[it] }, onChange = { country = it })
//
// La función es GENÉRICA (<T>): las opciones pueden ser cadenas,
// números, médicos... text indica cómo MOSTRAR una opción. Una opción
// puede ser null ("— choose —") si T es un tipo "anulable" (Int?).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.common
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuAnchorType
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
@Composable
fun <T> DropdownList(
label: String,
value: T,
choices: List<T>,
onChange: (T) -> Unit,
modifier: Modifier = Modifier,
text: (T) -> String = { it.toString() },
// un mensaje de error debajo del campo (cf. ejemplos 07 y 25)
error: String? = null,
) {
// ¿está abierto el menú? un estado ESPECÍFICO de cada lista desplegable
var open by remember { mutableStateOf(false) }
ExposedDropdownMenuBox(expanded = open, onExpandedChange = { open = it }, modifier = modifier) {
// el campo que muestra la opción actual; menuAnchor lo convierte en el
// punto de anclaje del menú (tocarlo abre el menú)
OutlinedTextField(
value = text(value),
onValueChange = {},
readOnly = true,
singleLine = true,
label = { Text(label) },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = open) },
isError = error != null,
supportingText = if (error == null) null else { { Text(error) } },
modifier = Modifier.menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable).fillMaxWidth(),
)
// el menú: una línea por opción
ExposedDropdownMenu(expanded = open, onDismissRequest = { open = false }) {
for (c in choices) {
DropdownMenuItem(
text = { Text(text(c)) },
onClick = {
onChange(c)
open = false
},
)
}
}
}
}
|
- líneas 36–44: [fun <T> DropdownList]: una función GENÉRICA: las opciones pueden ser cadenas, números, médicos... [text] especifica cómo mostrar una opción (de forma predeterminada, su [toString()]);
- línea 47: el estado propio de cada lista: ¿está abierto el menú?
- líneas 48–49: [ExposedDropdownMenuBox] asocia un campo de SOLO LECTURA ([readOnly = true]), que muestra la opción actual, con un menú; [menuAnchor] convierte el campo en el punto de anclaje del menú;
- líneas 63–68: una línea de menú por opción; al presionarla se notifica a quien llama ([onChange(c)]) y se cierra el menú.
El código del ejemplo:
| // =========================================================================
// ex05/Ex05Activity.kt - todo tipo de campos
// -------------------------------------------------------------------------
// Con Compose, TODOS los campos son CONTROLADOS: un campo muestra un
// valor del estado (value, checked, selected...) y notifica cada
// cambio mediante una función (onValueChange, onCheckedChange, onClick...),
// que actualiza el estado. El estado es la única fuente de verdad: modificar
// el estado (desde el código) modifica el campo. Lo que la función transmite
// depende del campo:
// - OutlinedTextField -> el nuevo texto (String);
// - Checkbox, Switch -> Boolean;
// - RadioButton -> nada: onClick es la elección;
// - DropdownList (common/) -> el valor del elemento elegido;
// - FilterChip -> nada: onClick alterna el chip;
// - Slider -> Float;
// - DatePickerDialog (un diálogo) -> una fecha, al confirmar.
// Todo ocurre en el teléfono, sin servidor.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex05
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.selectableGroup
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.Checkbox
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Slider
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
val titles = listOf("Mr", "Mme", "Melle")
val hobbies = listOf("sport", "music", "reading", "cinema")
val countries = mapOf("fr" to "France", "be" to "Belgium", "ch" to "Switzerland")
val languages = mapOf("fr" to "French", "en" to "English", "es" to "Spanish")
// todos los valores, reunidos en un objeto (lo que se enviaría a un servidor).
// @Serializable: el plugin kotlinx.serialization puede convertirlo a JSON
@Serializable
data class Model(
val title: String,
val name: String,
val age: Int?,
val presentation: String,
val newsletter: Boolean,
val hobbies: List<String>,
val country: String,
val languages: List<String>,
val birthDate: String?,
val satisfaction: Int,
)
// el convertidor JSON: prettyPrint, JSON con sangría
val indentedJson = Json { prettyPrint = true }
class Ex05Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { FormPage() } }
}
}
@Composable
fun FormPage() {
// un estado por campo del formulario
var title by rememberSaveable { mutableStateOf("Mme") }
var name by rememberSaveable { mutableStateOf("") }
var age by rememberSaveable { mutableStateOf("30") }
var presentation by rememberSaveable { mutableStateOf("") } // el valor VALIDADO
var draft by rememberSaveable { mutableStateOf("") } // el texto que se está escribiendo
var newsletter by rememberSaveable { mutableStateOf(false) }
var myHobbies by rememberSaveable { mutableStateOf(setOf("reading")) } // un CONJUNTO: sin duplicados
var myCountry by rememberSaveable { mutableStateOf("fr") }
var myLanguages by rememberSaveable { mutableStateOf(setOf<String>()) }
var birthDate by rememberSaveable { mutableStateOf<LocalDate?>(null) } // null: todavía no se ha elegido
var satisfaction by rememberSaveable { mutableFloatStateOf(3f) }
var sent by rememberSaveable { mutableStateOf<String?>(null) }
var calendarOpen by rememberSaveable { mutableStateOf(false) }
// el modelo: un valor CALCULADO a partir del estado
val model = Model(
title = title,
name = name.trim(),
age = age.toIntOrNull(), // null si el campo está vacío
presentation = presentation,
newsletter = newsletter,
hobbies = myHobbies.toList(),
country = myCountry,
languages = myLanguages.toList(),
birthDate = birthDate?.toString(), // "2026-10-05": el formato de fecha de la API de RdvMedecins
satisfaction = satisfaction.toInt(),
)
val titleStyle = MaterialTheme.typography.titleSmall
ExamplePage("Example 05 - controlled fields") {
Text("Title", style = titleStyle)
// selectableGroup: un grupo de botones de opción (para la accesibilidad)
Row(Modifier.selectableGroup(), verticalAlignment = Alignment.CenterVertically) {
for (t in titles) {
// selectable: TODA la línea (botón + texto) reacciona a la pulsación
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.selectable(selected = title == t, onClick = { title = t }, role = Role.RadioButton),
) {
RadioButton(selected = title == t, onClick = null)
Text(t)
Spacer(Modifier.width(12.dp))
}
}
}
Row {
OutlinedTextField(value = name, onValueChange = { name = it }, label = { Text("Name") }, modifier = Modifier.weight(2f))
Spacer(Modifier.width(12.dp))
OutlinedTextField(
value = age,
onValueChange = { age = it },
label = { Text("Age") },
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
modifier = Modifier.weight(1f),
)
}
// onFocusChanged: notifica cuando el campo GANA o PIERDE el foco. La
// presentación solo se copia al estado al salir del campo
OutlinedTextField(
value = draft,
onValueChange = { draft = it },
label = { Text("Presentation (updated when leaving the field)") },
minLines = 2,
modifier = Modifier.fillMaxWidth().onFocusChanged { state ->
if (!state.isFocused) presentation = draft
},
)
// una sola casilla: true / false. toggleable: toda la línea reacciona
ListItem(
modifier = Modifier.toggleable(value = newsletter, onValueChange = { newsletter = it }, role = Role.Checkbox),
leadingContent = { Checkbox(checked = newsletter, onCheckedChange = null) },
headlineContent = { Text("Receive the newsletter") },
)
Text("Hobbies", style = titleStyle)
// varios chips para UN conjunto: el valor se agrega o se quita
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
for (h in hobbies) {
FilterChip(
selected = h in myHobbies,
onClick = { myHobbies = if (h in myHobbies) myHobbies - h else myHobbies + h },
label = { Text(h) },
)
}
}
// una lista desplegable: value indica qué elemento está elegido
DropdownList(
label = "Country",
value = myCountry,
choices = countries.keys.toList(),
text = { code -> countries.getValue(code) },
onChange = { myCountry = it },
modifier = Modifier.width(220.dp),
)
Text("Spoken languages", style = titleStyle)
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
for ((code, label) in languages) {
FilterChip(
selected = code in myLanguages,
onClick = { myLanguages = if (code in myLanguages) myLanguages - code else myLanguages + code },
label = { Text(label) },
)
}
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text("Satisfaction: ${satisfaction.toInt()} / 5", style = titleStyle)
// un control deslizante de 1 a 5: 3 pasos intermedios (2, 3, 4)
Slider(
value = satisfaction,
onValueChange = { satisfaction = it },
valueRange = 1f..5f,
steps = 3,
modifier = Modifier.weight(1f).padding(start = 8.dp),
)
}
ListItem(
leadingContent = { Icon(Icons.Default.DateRange, contentDescription = null) },
headlineContent = { Text("Date of birth") },
supportingContent = { Text(birthDate?.toString() ?: "not chosen") },
trailingContent = { OutlinedButton(onClick = { calendarOpen = true }) { Text("Choose") } },
)
// FlowRow: los botones saltan a la línea siguiente en una pantalla estrecha
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = { sent = Json.encodeToString(Model.serializer(), model) }) { Text("Send") }
// el estado modificado POR EL CÓDIGO: los campos lo siguen
OutlinedButton(onClick = {
title = "Mr"
name = "MARTIN"
age = "42"
myHobbies = setOf("sport", "cinema")
myCountry = "be"
}) { Text("Fill in by code") }
}
Spacer(Modifier.height(8.dp))
Text("The model, live", style = titleStyle)
Text(
indentedJson.encodeToString(Model.serializer(), model),
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp),
)
// un bloque que solo existe después de un envío; ?.let: solo si sent no es null
sent?.let { json ->
Text("Last submission", style = titleStyle)
Text(
json,
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFE8F5E9)).padding(8.dp),
)
}
}
// el diálogo del calendario: solo existe si calendarOpen es true
if (calendarOpen) {
// el estado del calendario: la fecha seleccionada, en milisegundos (UTC)
val calendarState = rememberDatePickerState(
initialSelectedDateMillis = (birthDate ?: LocalDate.of(2000, 1, 1)).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
)
DatePickerDialog(
onDismissRequest = { calendarOpen = false },
confirmButton = {
TextButton(onClick = {
calendarState.selectedDateMillis?.let { ms ->
birthDate = Instant.ofEpochMilli(ms).atZone(ZoneOffset.UTC).toLocalDate()
}
calendarOpen = false
}) { Text("OK") }
},
dismissButton = { TextButton(onClick = { calendarOpen = false }) { Text("Cancel") } },
) {
DatePicker(state = calendarState)
}
}
}
|
- líneas 89–101: todos los valores del formulario, agrupados en una clase [@Serializable]: el complemento [kotlinx.serialization] genera en tiempo de compilación el código que la convierte a JSON ([Json.encodeToString(Model.serializer(), model)]);
- Líneas 118–130: un estado por campo. [myHobbies] es un CONJUNTO no modificable ([Set]): [myHobbies + h] y [myHobbies - h] generan conjuntos nuevos; [birthDate] es una fecha “anulable” ([LocalDate?]): [null] hasta que se selecciona un valor;
- líneas 133–143: el modelo, un valor CALCULADO en cada ejecución; [toIntOrNull()]: el número, o [null] si el texto no es un número;
- líneas 150–157: botones de opción. [Modifier.selectable] hace que TODA la línea (el botón y el texto) sea clicable; por lo tanto, el botón en sí no tiene acción ([onClick = null]); [selectableGroup] agrupa los botones para las herramientas de accesibilidad;
- Líneas 177–182: la presentación se copia al estado solo al SALIR del campo; [onFocusChanged] activa una notificación cuando el campo gana o pierde el foco;
- líneas 187–189: una casilla de verificación, que funciona igual que los botones de opción ([Modifier.toggleable] en toda la línea);
- líneas 193–198: casillas de verificación ([FilterChip]) para seleccionar varios valores; [FlowRow] las pasa a la línea siguiente si no hay espacio suficiente;
- líneas 203–208: la lista desplegable de [common/];
- líneas 224–228: un control deslizante de 1 a 5: [steps = 3] con pasos intermedios;
- líneas 236–248: “Rellenar por código”: se modifica el estado y los campos lo siguen;
- líneas 251–259: el modelo mostrado en JSON, con sangría ([Json [ prettyPrint = true ]]); [sent?.let [ ... ]]: el bloque existe solo si [sent] no es [null];
- Líneas 271–288: la ventana del calendario existe solo si [calendarOpen] es verdadero. [DatePicker] opera en milisegundos desde el 1 de enero de 1970 (hora UTC): la conversión funciona en ambos sentidos con [java.time] ([LocalDate], [Instant], [ZoneOffset.UTC]).



El calendario ([DatePickerDialog]) está en inglés: [Material 3] sigue el idioma de la aplicación (véase el Ejemplo 21).
El Ejemplo 05 tenía una variable de estado por campo. Para un formulario real, preferimos UN objeto que contenga todos los valores y describimos sus cambios en una sola función PURA, el REDUCER: [reducer(currentState, action) -> newState]. La pantalla ya no modifica el estado: informa lo que ha ocurrido (“el campo LASTNAME ahora tiene el valor ‘Dupont’”, “se ha salido del campo LASTNAME”), y el reducer deduce de ello el nuevo estado.
| // =========================================================================
// ex06/Ex06Activity.kt - un formulario, un objeto, un reducer
// -------------------------------------------------------------------------
// El ejemplo 05 tenía una variable de estado por campo del formulario. Para un
// formulario real, preferimos UN objeto que contenga todos los valores, el
// MODELO (aquí un objeto Profile, no modificable), y describimos sus
// cambios en una sola función, el REDUCER:
//
// reducer(currentState, action) -> newState
//
// La pantalla ya no modifica el estado: DESCRIBE lo que ocurrió, con un
// objeto ProfileAction (Update(Field.LASTNAME, "Dupont"), Leave(Field.LASTNAME)...),
// y el reducer deduce de ahí el nuevo estado. Toda la lógica está en un
// solo lugar, en una función PURA (misma entrada, misma salida, sin efecto
// secundario), fácil de probar.
// Kotlin se presta bien a ello: una interfaz "sealed" enumera todas las acciones
// posibles, y el compilador verifica un when sobre una acción (un
// caso olvidado es un error).
//
// El estado también guarda, para cada campo, si ha sido "tocado" (abandonado al
// menos una vez); de ahí deducimos si está "modificado" (su valor difiere del
// valor inicial) y si está deshabilitado.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
package fr.stahe.examples.ex06
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.selection.selectable
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Slider
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.JsonObject
// el nombre de cada campo del formulario
enum class Field { TITLE, FIRSTNAME, LASTNAME, AGE, NEWSLETTER, EMAIL, COUNTRY, PRESENTATION }
// los datos del formulario: un objeto NO MODIFICABLE (todo es val). Para
// "modificarlo", hacemos una copia: profile.copy(lastName = "DUPONT"). La
// función copy la escribe Kotlin para cualquier clase "data"
data class Profile(
val title: String,
val firstName: String,
val lastName: String,
val age: Int,
val newsletter: Boolean,
val email: String,
val country: String,
val presentation: String,
) {
// el valor de un campo, designado por su nombre
fun value(f: Field): Any = when (f) {
Field.TITLE -> title
Field.FIRSTNAME -> firstName
Field.LASTNAME -> lastName
Field.AGE -> age
Field.NEWSLETTER -> newsletter
Field.EMAIL -> email
Field.COUNTRY -> country
Field.PRESENTATION -> presentation
}
// una copia en la que UN campo, designado por su nombre, tiene un nuevo valor
fun withValue(f: Field, v: Any): Profile = when (f) {
Field.TITLE -> copy(title = v as String)
Field.FIRSTNAME -> copy(firstName = v as String)
Field.LASTNAME -> copy(lastName = v as String)
Field.AGE -> copy(age = v as Int)
Field.NEWSLETTER -> copy(newsletter = v as Boolean)
Field.EMAIL -> copy(email = v as String)
Field.COUNTRY -> copy(country = v as String)
Field.PRESENTATION -> copy(presentation = v as String)
}
// el objeto JSON del perfil: un campo JSON por campo del formulario
fun toJson(): JsonObject = JsonObject(
Field.entries.associate { f ->
val v = value(f)
f.name.lowercase() to when (v) {
is Int -> JsonPrimitive(v) // "is": una prueba de tipo; v es entonces un Int
is Boolean -> JsonPrimitive(v)
else -> JsonPrimitive(v.toString())
}
},
)
}
val initial = Profile(
title = "Mme",
firstName = "Marie",
lastName = "PELISSIER",
age = 30,
newsletter = false,
email = "",
country = "fr",
presentation = "",
)
// el estado completo: los valores y los campos ya abandonados
data class State(val values: Profile, val touched: Set<Field>)
// las acciones posibles. "sealed": no hay otras que las
// declaradas aquí, el compilador lo sabe
sealed interface ProfileAction {
data class Update(val field: Field, val value: Any) : ProfileAction
data class Leave(val field: Field) : ProfileAction
data object Uppercase : ProfileAction // un objeto único: la acción no tiene datos
data object Reset : ProfileAction
}
// el reducer: NUNCA modifica el estado recibido, devuelve uno nuevo.
// En cada rama del when, action tiene el tipo de la rama ("smart cast"):
// action.field es accesible para un Update
fun reducer(state: State, action: ProfileAction): State = when (action) {
is ProfileAction.Update -> state.copy(values = state.values.withValue(action.field, action.value))
is ProfileAction.Leave -> state.copy(touched = state.touched + action.field)
ProfileAction.Uppercase -> state.copy(
values = state.values.copy(firstName = state.values.firstName.uppercase(), lastName = state.values.lastName.uppercase()),
)
ProfileAction.Reset -> State(initial, emptySet())
}
val titles = listOf("Mr", "Mme", "Melle")
val trackedFields = listOf(Field.FIRSTNAME, Field.LASTNAME, Field.AGE, Field.EMAIL)
val countryNames = mapOf("fr" to "France", "be" to "Belgium", "ch" to "Switzerland")
val indentedJson = Json { prettyPrint = true }
class Ex06Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { ProfilePage() } }
}
}
@Composable
fun ProfilePage() {
var state by remember { mutableStateOf(State(initial, emptySet())) }
// LA única forma de cambiar el estado: describir lo que ocurrió
fun dispatch(action: ProfileAction) {
state = reducer(state, action)
}
val v = state.values
// valores DEDUCIDOS del estado
fun modified(f: Field) = v.value(f) != initial.value(f)
fun disabled(f: Field) = f == Field.EMAIL && !v.newsletter // el correo electrónico exige el boletín informativo
val formModified = Field.entries.any { modified(it) }
val titleStyle = MaterialTheme.typography.titleSmall
// un campo de texto enlazado al modelo: una función @Composable LOCAL
@Composable
fun TextField(field: Field, label: String, modifier: Modifier = Modifier, lines: Int = 1) {
// ¿ya ha tenido el foco el campo? (un estado específico de CADA campo)
var hadFocus by remember { mutableStateOf(false) }
OutlinedTextField(
value = v.value(field) as String,
onValueChange = { text -> dispatch(ProfileAction.Update(field, text)) },
label = { Text(label) },
enabled = !disabled(field),
minLines = lines,
// el campo se ABANDONA cuando pierde el foco... después de haberlo tenido
modifier = modifier.onFocusChanged { f ->
if (f.isFocused) {
hadFocus = true
} else if (hadFocus) {
dispatch(ProfileAction.Leave(field))
}
},
)
}
ExamplePage("Example 06 - a reducer") {
Row(verticalAlignment = Alignment.CenterVertically) {
for (t in titles) {
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.selectable(selected = v.title == t, onClick = { dispatch(ProfileAction.Update(Field.TITLE, t)) }),
) {
RadioButton(selected = v.title == t, onClick = null)
Text(t)
Spacer(Modifier.width(12.dp))
}
}
}
Row {
TextField(Field.FIRSTNAME, "First name", Modifier.weight(1f))
Spacer(Modifier.width(12.dp))
TextField(Field.LASTNAME, "Last name", Modifier.weight(1f))
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text("Age: ${v.age}", style = titleStyle)
Slider(
value = v.age.toFloat(),
onValueChange = { a -> dispatch(ProfileAction.Update(Field.AGE, a.toInt())) },
valueRange = 0f..120f,
steps = 119,
// se suelta el control deslizante: el campo ha sido "abandonado"
onValueChangeFinished = { dispatch(ProfileAction.Leave(Field.AGE)) },
modifier = Modifier.weight(1f).padding(start = 8.dp),
)
}
ListItem(
headlineContent = { Text("Receive the newsletter") },
trailingContent = {
Switch(checked = v.newsletter, onCheckedChange = { yes -> dispatch(ProfileAction.Update(Field.NEWSLETTER, yes)) })
},
)
TextField(Field.EMAIL, "E-mail (if newsletter)", Modifier.fillMaxWidth())
DropdownList(
label = "Country",
value = v.country,
choices = countryNames.keys.toList(),
text = { countryNames.getValue(it) },
onChange = { c -> dispatch(ProfileAction.Update(Field.COUNTRY, c)) },
modifier = Modifier.width(220.dp),
)
TextField(Field.PRESENTATION, "About you", Modifier.fillMaxWidth(), lines = 2)
Spacer(Modifier.height(8.dp))
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
OutlinedButton(onClick = { dispatch(ProfileAction.Uppercase) }) { Text("Name in uppercase") }
OutlinedButton(onClick = { dispatch(ProfileAction.Reset) }) { Text("Reset") }
}
Spacer(Modifier.height(8.dp))
Text("The model, live", style = titleStyle)
Text(
indentedJson.encodeToString(JsonObject.serializer(), v.toJson()),
fontFamily = FontFamily.Monospace,
fontSize = 12.sp,
modifier = Modifier.fillMaxWidth().background(Color(0xFFF5F5F5)).padding(8.dp),
)
Spacer(Modifier.height(8.dp))
Text("The state of the fields", style = titleStyle)
// una pequeña tabla: un Row por línea, columnas del mismo ancho (weight)
val headers = listOf("field", "touched", "modified", "disabled")
Row { for (h in headers) Text(h, Modifier.weight(1f), fontWeight = FontWeight.Bold) }
HorizontalDivider()
for (f in trackedFields) {
Row {
Text(f.name.lowercase(), Modifier.weight(1f))
Text("${f in state.touched}", Modifier.weight(1f))
Text("${modified(f)}", Modifier.weight(1f))
Text("${disabled(f)}", Modifier.weight(1f))
}
}
Spacer(Modifier.height(8.dp))
// un texto con varios estilos: buildAnnotatedString
Text(
buildAnnotatedString {
append("form modified: ")
withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append("$formModified") }
},
)
}
}
|
- línea 77: el nombre de cada campo, una lista;
- líneas 82–113: el perfil, que no se puede modificar, con dos funciones para leer o reemplazar el campo designado por su nombre ([v as String]: una conversión de tipo, verificada en tiempo de ejecución);
- líneas 117–123: el perfil en JSON: [Field.entries], la lista de valores de la enumeración; [associate] genera un [Map]; [is Int]: una comprobación de tipo, tras la cual [v] se reconoce como un [Int] (el “smart cast”);
- línea 141: el estado completo: los valores y todos los campos de los que ya se ha salido (“touched”);
- líneas 145–149: las acciones posibles. [sealed]: no hay otras además de las declaradas aquí, y el compilador lo sabe. [data object]: una acción sin datos, un objeto único;
- líneas 155–161: el reducer: un [when] sobre la acción, sin [else]: el compilador verifica que se traten TODAS las acciones. En cada rama, [action] tiene el tipo de la rama: [action.field] es accesible para un [Update];
- líneas 179–183: el estado y la ÚNICA forma de cambiarlo, [dispatch(action)];
- líneas 188–190: valores DEDUCIDOS del estado: un campo está “modificado” si su valor difiere del valor inicial; el correo electrónico está deshabilitado sin el boletín;
- líneas 195–209: una función [@Composable] LOCAL (definida dentro de otra): un campo de texto enlazado al modelo. Cada campo tiene su propio estado ([hadFocus]): se “sale” de él cuando pierde el foco después de haberlo tenido;
- líneas 236–241: el control deslizante de la edad: se llama a [onValueChangeFinished] cuando se suelta;
- líneas 277–285: una tabla sencilla, un [Row] por fila, con columnas de igual ancho ([weight(1f)]);
- líneas 291–293: texto con varios estilos: [buildAnnotatedString].


El reducer es una función normal: puede probarse sin pantalla, con una simple prueba unitaria ([assertEquals(expected, reducer(state, action))]).
El formulario “Crear una cuenta” de la aplicación RdvMedecins, con las mismas reglas que el servidor. Una función pura, [validate(account)], devuelve los errores; estos solo se muestran para los campos de los que ya se ha salido o después de un intento de envío del formulario.
| // =========================================================================
// ex07/Ex07Activity.kt - validar un formulario, a mano
// -------------------------------------------------------------------------
// Una función PURA, validate(account), devuelve los errores de los campos;
// la llamamos en cada ejecución de la función @Composable: los errores
// están, por tanto, siempre al día.
// No los mostramos de inmediato (un formulario vacío cubierto de rojo es
// desagradable): solo para un campo ya abandonado ("touched"). Enviar
// marca todos los campos como touched, y solo actúa si el formulario
// es válido. Un OutlinedTextField muestra un error debajo del campo cuando
// se le da isError = true y un supportingText.
//
// Mismas reglas que el servidor de RdvMedecins (formulario "Create an account").
// ADVERTENCIA: esta validación es solo una COMODIDAD para el usuario (una
// respuesta inmediata, sin un viaje de ida y vuelta al servidor). No protege
// nada: cualquiera puede enviar al servidor una solicitud hecha
// a mano (curl...). Por lo tanto, el servidor SIEMPRE revalida todo (cf. ejemplo 25).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex07
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
enum class Field { TITLE, FIRSTNAME, LASTNAME, LOGIN, PASSWORD, CONFIRMATION }
// la cuenta, tal como se escribió
data class Account(
val title: String,
val firstName: String,
val lastName: String,
val login: String,
val password: String,
val confirmation: String,
)
val titles = listOf("Mr", "Mme", "Melle")
val loginFormat = Regex("^[a-z0-9._-]{1,30}$")
const val PASSWORD_MIN = 6
// las reglas: una función pura, que solo depende de su argumento.
// Devuelve, para cada campo con error, su mensaje. buildMap: llenamos
// un Map modificable, la función devuelve un Map NO MODIFICABLE
fun validate(a: Account): Map<Field, String> = buildMap {
if (a.title !in titles) put(Field.TITLE, "Choose a title from the list.")
when {
a.firstName.isBlank() -> put(Field.FIRSTNAME, "The first name is required.")
a.firstName.length > 20 -> put(Field.FIRSTNAME, "The first name must not exceed 20 characters.")
}
when {
a.lastName.isBlank() -> put(Field.LASTNAME, "The last name is required.")
a.lastName.length > 20 -> put(Field.LASTNAME, "The last name must not exceed 20 characters.")
}
when {
a.login.isEmpty() -> put(Field.LOGIN, "The login is required.")
!loginFormat.matches(a.login) -> put(Field.LOGIN, "Unaccented lower-case letters, digits, dot, hyphen, underscore.")
}
when {
a.password.isEmpty() -> put(Field.PASSWORD, "The password is required.")
a.password.length < PASSWORD_MIN -> put(Field.PASSWORD, "At least $PASSWORD_MIN characters.")
}
// una regla que compara DOS campos
if (a.confirmation != a.password) put(Field.CONFIRMATION, "The confirmation does not match the password.")
}
class Ex07Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { AccountPage() } }
}
}
@Composable
fun AccountPage() {
var account by remember { mutableStateOf(Account("Mr", "", "", "", "", "")) }
var touched by remember { mutableStateOf(setOf<Field>()) }
var submitAttempted by remember { mutableStateOf(false) }
var success by remember { mutableStateOf(false) }
// los errores: recalculados en cada ejecución, nunca guardados en el estado
val errors = validate(account)
// el error que se MUESTRA para un campo: solo si ha sido tocado
fun error(f: Field): String? = if (f in touched) errors[f] else null
fun send() {
submitAttempted = true
touched = Field.entries.toSet() // todos los errores aparecen
// aquí, la cuenta se enviaría al servidor (cf. ejemplo 25)
success = errors.isEmpty()
}
// un campo de texto: etiqueta, error y una marca de verificación verde si está
// tocado y es válido. value: el valor del campo; update: la función que
// construye la cuenta modificada
@Composable
fun AccountField(f: Field, label: String, value: String, update: (String) -> Account, secret: Boolean = false) {
var hadFocus by remember { mutableStateOf(false) }
val message = error(f)
OutlinedTextField(
value = value,
onValueChange = { text ->
account = update(text)
success = false
},
label = { Text(label) },
singleLine = true,
isError = message != null,
supportingText = message?.let { m -> { Text(m) } },
// los caracteres de una contraseña están ocultos
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
trailingIcon = if (f in touched && message == null) {
{ Icon(Icons.Default.CheckCircle, contentDescription = null, tint = Color(0xFF2E7D32)) }
} else {
null
},
// el campo abandonado (después de haber tenido el foco) pasa a estar "tocado"
modifier = Modifier.fillMaxWidth().onFocusChanged { fs ->
if (fs.isFocused) hadFocus = true else if (hadFocus) touched = touched + f
},
)
}
ExamplePage("Example 07 - validation") {
DropdownList(
label = "Title",
value = account.title,
choices = titles,
onChange = { t -> account = account.copy(title = t) },
modifier = Modifier.width(200.dp),
)
AccountField(Field.FIRSTNAME, "First name", account.firstName, { account.copy(firstName = it) })
AccountField(Field.LASTNAME, "Last name", account.lastName, { account.copy(lastName = it) })
AccountField(Field.LOGIN, "Login", account.login, { account.copy(login = it) })
AccountField(Field.PASSWORD, "Password", account.password, { account.copy(password = it) }, secret = true)
AccountField(Field.CONFIRMATION, "Confirmation", account.confirmation, { account.copy(confirmation = it) }, secret = true)
Spacer(Modifier.height(16.dp))
Button(onClick = { send() }) { Text("Create the account") }
Spacer(Modifier.height(12.dp))
if (submitAttempted && errors.isNotEmpty()) {
Message("The form contains ${errors.size} error(s).", Color(0xFFFFEBEE))
}
if (success) {
Message("Valid form: it could be sent to the server.", Color(0xFFE8F5E9))
}
}
}
// un pequeño componente privado de este archivo: un mensaje sobre un fondo de color
@Composable
private fun Message(text: String, color: Color) {
Text(text, Modifier.fillMaxWidth().background(color, RoundedCornerShape(8.dp)).padding(12.dp))
}
|
- líneas 69–70: una expresión regular ([Regex]) y una constante;
- líneas 75–94: las reglas. [buildMap [ ... ]]: se llena un [Map] modificable (mediante [put]); la función devuelve un [Map] NO modificable. La última regla compara DOS campos;
- línea 113: los errores se RECALCULAN en cada ejecución, nunca se borran del estado: siempre están actualizados;
- línea 116: el error QUE SE DEBE MOSTRAR para un campo: solo si ha sido modificado;
- Líneas 118–122: el envío marca todos los campos como tocados (se muestran todos los errores) y tiene éxito solo si no hay errores;
- líneas 129–151: un campo de la cuenta. [update] es una función que genera la cuenta modificada ([[ account.copy(firstName = it) ]]); [isError] y [supportingText] muestran el error debajo del campo; [PasswordVisualTransformation] oculta los caracteres; una marca de verificación verde ([trailingIcon]) para un campo que se ha actualizado y es válido;
- línea 183: [private]: un componente visible solo en este archivo.


ATENCIÓN: esta validación es simplemente una COMODIDAD para el usuario (una respuesta inmediata, sin un viaje de ida y vuelta al servidor). No protege nada: cualquiera puede enviar al servidor una solicitud elaborada manualmente (con [curl]; véase el capítulo sobre el servidor). Por lo tanto, el servidor SIEMPRE vuelve a validar todo (véase el Ejemplo 25).
3.8. Ejemplo 08: campos que pueden validarse a sí mismos
[Flutter] tiene sus propios formularios ([Form], [FormField]); [Compose] no. Así que escribimos la herramienta nosotros mismos, en unas pocas líneas, con clases ordinarias que MANTIENEN un estado observado por [Compose] (“state holders”): este es el enfoque estándar con [Compose].
| // =========================================================================
// ex08/Form.kt - campos que pueden validarse a sí mismos
// -------------------------------------------------------------------------
// Compose no ofrece ninguna herramienta de formularios (ningún equivalente a Form
// de Flutter ni a los formularios de Angular): la escribimos nosotros mismos, en
// unas pocas líneas, con clases ordinarias que MANTIENEN un estado
// observado por Compose ("state holders"):
// - una REGLA es una función: (value) -> null si el valor es correcto,
// de lo contrario el mensaje de error;
// - un FormField guarda su valor y su error, y se valida a sí mismo:
// primero a petición (validate()), luego en cada pulsación de tecla, en cuanto
// el usuario lo ha modificado;
// - un Form agrupa campos: validate() los valida a TODOS,
// muestra sus errores y devuelve true si todo está bien.
// =========================================================================
package fr.stahe.examples.ex08
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
// typealias: un nombre más significativo para un tipo de función
typealias Rule = (String) -> String?
// FÁBRICAS de reglas: cada una devuelve una función de validación
fun required(message: String): Rule = { v -> if (v.isBlank()) message else null }
// una regla que COMPLETA otra: "?:" (el operador Elvis) da el
// resultado de other, si no es null, y en caso contrario el del resto
fun maximum(max: Int, other: Rule): Rule = { v -> other(v) ?: if (v.length > max) "$max characters at most." else null }
class FormField(initialValue: String = "", private val rule: Rule = { null }) {
// el estado del campo: observado por Compose, modificable solo AQUÍ (private set)
var value by mutableStateOf(initialValue)
private set
var error by mutableStateOf<String?>(null)
private set
// ¿ya ha modificado el usuario el campo?
private var modified = false
// una pulsación de tecla: el campo se valida a sí mismo en cuanto el usuario lo ha modificado
fun change(newValue: String) {
value = newValue
modified = true
error = rule(value)
}
fun validate(): Boolean {
error = rule(value)
return error == null
}
// revalidar, solo si el usuario ya ha modificado el campo
fun revalidate() {
if (modified) validate()
}
}
// vararg: cualquier número de campos, Form(firstName, lastName, login...)
class Form(private vararg val fields: FormField) {
// map primero (TODOS los campos se validan y muestran su error),
// all después (¿están todos bien?)
fun validate(): Boolean = fields.map { it.validate() }.all { it }
}
|
- línea 23: [typealias]: un nombre para un tipo de función: una REGLA recibe el valor y devuelve [null] si es válido; en caso contrario, un mensaje de error;
- líneas 26–30: FÁBRICAS de reglas (funciones que devuelven una función). [?:], el operador “Elvis”: el valor de la izquierda si no es [null]; en caso contrario, el valor de la derecha;
- líneas 32–56: un campo: su valor y su error son estados de [Compose] ([mutableStateOf]) que solo se pueden modificar desde dentro de la clase ([private set]). Un campo se valida a petición ([validate()]) y luego con cada pulsación de tecla una vez que el usuario lo ha modificado;
- líneas 61–64: un formulario agrupa campos ([vararg]: cualquier número de parámetros). Primero, [map]: se validan TODOS los campos y muestran sus posibles errores; luego, [all]: ¿son todos válidos?
El Ejemplo 07, reescrito con estas clases:
| // =========================================================================
// ex08/Ex08Activity.kt - un formulario reutilizable
// -------------------------------------------------------------------------
// El formulario del ejemplo 07, escrito con las clases de Form.kt:
// las reglas se adjuntan a los campos, la pantalla solo tiene que mostrar
// cada campo y llamar a form.validate() al enviar.
// Los campos se guardan en una clase, AccountForm, creada UNA SOLA VEZ
// (remember): sobrevive a las recomposiciones.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex08
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.examples.common.DropdownList
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
val titles = listOf("Mr", "Mme", "Melle")
// los campos del formulario y sus reglas
class AccountForm {
var title by mutableStateOf("Mr")
val firstName = FormField(rule = maximum(20, required("The first name is required.")))
val lastName = FormField(rule = maximum(20, required("The last name is required.")))
// una regla escrita directamente: una lambda
val login = FormField(
rule = { v ->
when {
v.isEmpty() -> "The login is required."
!Regex("^[a-z0-9._-]{1,30}$").matches(v) -> "Unaccented lower-case letters, digits, dot, hyphen, underscore."
else -> null
}
},
)
val password = FormField(
rule = { v ->
when {
v.isEmpty() -> "The password is required."
v.length < 6 -> "At least 6 characters."
else -> null
}
},
)
// una regla que lee OTRO campo
val confirmation = FormField(
rule = { v -> if (v == password.value) null else "The confirmation does not match the password." },
)
val form = Form(firstName, lastName, login, password, confirmation)
// los valores, en JSON (lo que se enviaría al servidor)
fun toJson(): String = JsonObject(
mapOf(
"title" to JsonPrimitive(title),
"firstName" to JsonPrimitive(firstName.value.trim()),
"lastName" to JsonPrimitive(lastName.value.trim()),
"login" to JsonPrimitive(login.value),
"password" to JsonPrimitive(password.value),
),
).toString()
}
class Ex08Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { AccountPage() } }
}
}
@Composable
fun AccountPage() {
val account = remember { AccountForm() }
// null: aún no hay envío; "": envío rechazado; de lo contrario, el JSON enviado
var sent by remember { mutableStateOf<String?>(null) }
ExamplePage("Example 08 - a reusable form") {
DropdownList(
label = "Title",
value = account.title,
choices = titles,
onChange = { account.title = it },
modifier = Modifier.width(200.dp),
)
TextField(account.firstName, "First name")
TextField(account.lastName, "Last name")
TextField(account.login, "Login")
// la contraseña cambia: se revalida la confirmación (si ya se ha escrito)
TextField(account.password, "Password", secret = true, after = { account.confirmation.revalidate() })
TextField(account.confirmation, "Confirmation", secret = true)
Spacer(Modifier.height(16.dp))
Button(onClick = { sent = if (account.form.validate()) account.toJson() else "" }) {
Text("Create the account")
}
Spacer(Modifier.height(12.dp))
// ?.let: este bloque solo existe si sent no es null
sent?.let { s ->
Text(
if (s.isEmpty()) "Invalid form." else "Valid form: $s",
Modifier
.fillMaxWidth()
.background(if (s.isEmpty()) Color(0xFFFFEBEE) else Color(0xFFE8F5E9), RoundedCornerShape(8.dp))
.padding(12.dp),
)
}
}
}
// la visualización de un FormField: su valor, su error. after: lo que debe
// hacerse después de cada pulsación de tecla (nada, por defecto)
@Composable
fun TextField(field: FormField, label: String, secret: Boolean = false, after: () -> Unit = {}) {
OutlinedTextField(
value = field.value,
onValueChange = {
field.change(it)
after()
},
label = { Text(label) },
singleLine = true,
isError = field.error != null,
supportingText = field.error?.let { m -> { Text(m) } },
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
modifier = Modifier.fillMaxWidth(),
)
}
|
- Líneas 48–77: los campos del formulario y sus reglas, agrupados en una clase; la confirmación tiene una regla que lee OTRO campo ([password.value]);
- línea 101: [remember [ AccountForm() ]]: el objeto se crea UNA SOLA VEZ y sobrevive a las recomposiciones;
- línea 120: envío: [account.form.validate()] valida todo y determina si el envío es posible;
- líneas 140–152: mostrar un campo: su valor, su error y [after], que especifica qué hacer después de cada pulsación de tecla: cuando cambia la contraseña, se vuelve a validar la confirmación.


En una función [@Composable], los valores se formatean con funciones estándar. Las funciones utilizadas en la aplicación se reúnen en un único archivo:
| // =========================================================================
// ex09/Formatting.kt - funciones de formateo "caseras"
// -------------------------------------------------------------------------
// Compose no tiene un mecanismo propio de formateo (Angular tiene sus
// "pipes"): en una función @Composable, llamamos a
// FUNCIONES ordinarias, guardadas en un archivo y que se pueden probar por separado:
// timeRange(slot) -> "8:00 - 8:20"
// timeRange(slot, Part.START) -> "8:00"
// Kotlin también permite AGREGAR funciones y propiedades a un
// tipo existente, mediante EXTENSIONES: "marie pelissier".capitalized ->
// "Marie Pelissier".
// Para fechas, números y montos, las clases de Java
// (java.time, java.text) conocen las convenciones de cada idioma
// (cf. Ex09Activity.kt).
// =========================================================================
package fr.stahe.examples.ex09
// un intervalo de tiempo, tal como lo describe la API de RdvMedecins
data class Slot(val startHour: Int, val startMinute: Int, val endHour: Int, val endMinute: Int)
enum class Part { ALL, START, END }
// "8:05" en lugar de "8:5"; private: invisible fuera de este archivo
private fun time(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"
// un parámetro OPCIONAL, con su valor predeterminado: part = Part.ALL
fun timeRange(s: Slot, part: Part = Part.ALL): String = when (part) {
Part.START -> time(s.startHour, s.startMinute)
Part.END -> time(s.endHour, s.endMinute)
Part.ALL -> "${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}"
}
// EXTENSIONES del tipo String: nuevas propiedades para TODAS las
// cadenas. En el cuerpo, this designa la cadena
// "marie pelissier" -> "Marie Pelissier"; \p{L}: una letra, con o sin acento
val String.capitalized: String
get() = Regex("\\p{L}+").replace(this) { m ->
m.value.lowercase().replaceFirstChar { it.uppercase() }
}
// "Marie PELISSIER" -> "MP"
val String.initials: String
get() = split(Regex("\\s+")).filter { it.isNotEmpty() }.joinToString("") { it.first().uppercase() }
|
- líneas 24–30: un parámetro OPCIONAL, con su valor predeterminado ([part = Part.ALL]); [padStart(2, '0')]: “8:05” en lugar de “8:5”;
- Líneas 36–43: EXTENSIONES: [Kotlin] permite asignar propiedades (y funciones) a un tipo existente, en este caso, a todas las cadenas. En el cuerpo, [this] hace referencia a la cadena: ["marie pelissier".capitalized] es “Marie Pelissier”.
Para las fechas, los números y los importes, las clases de [Java] ([java.time], [java.text]) siguen las convenciones de cada idioma:
| // =========================================================================
// ex09/Ex09Activity.kt - formatear valores
// -------------------------------------------------------------------------
// Cada fila de la tabla muestra un fragmento de código y lo que muestra.
// Los formateadores (DateTimeFormatter, NumberFormat) se crean una vez
// por todas, fuera de las funciones @Composable: construirlos cuesta más
// que usarlos.
// Java conoce de antemano los nombres de los días y de los meses de cada idioma:
// no hay nada que cargar antes de usarlos.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.examples.ex09
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import java.text.NumberFormat
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle
import java.util.Locale
// fechas: formatos "predefinidos" (SHORT, MEDIUM, LONG, FULL), o un patrón
val shortDate: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale.US)
val fullDate: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(Locale.US)
val timeOnly: DateTimeFormatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM).withLocale(Locale.US)
val frenchDay: DateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).withLocale(Locale.FRANCE)
val pattern: DateTimeFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy HH:mm", Locale.US)
// números y montos
val euros: NumberFormat = NumberFormat.getCurrencyInstance(Locale.US).apply { currency = java.util.Currency.getInstance("EUR") }
val integer: NumberFormat = NumberFormat.getNumberInstance(Locale.US)
// apply: configura el objeto recién creado y lo devuelve
val percent: NumberFormat = NumberFormat.getPercentInstance(Locale.US).apply { minimumFractionDigits = 1 }
const val DAY = "2026-10-05" // una fecha en el formato de la API de RdvMedecins
const val PRICE = 1234.5
const val RATE = 0.055
const val NAME = "marie pelissier"
val doctor = mapOf("title" to "Mme", "firstName" to "Marie", "lastName" to "PELISSIER")
val languages = listOf("Kotlin", "Compose", "Dart", "Swift", "SQL")
val slots = listOf(Slot(8, 0, 8, 20), Slot(8, 20, 8, 40), Slot(14, 5, 14, 25))
class Ex09Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { FormattingPage() } }
}
}
@Composable
fun FormattingPage() {
var now by remember { mutableStateOf(LocalDateTime.now()) }
// (código mostrado, valor): una fila de la tabla, como un par
val rows = listOf(
"shortDate.format(now)" to shortDate.format(now),
"fullDate.format(now)" to fullDate.format(now),
"timeOnly.format(now)" to timeOnly.format(now),
"pattern.format(now)" to pattern.format(now),
"fullDate.format(LocalDate.parse(DAY))" to fullDate.format(LocalDate.parse(DAY)),
"frenchDay.format(LocalDate.parse(DAY))" to frenchDay.format(LocalDate.parse(DAY)),
"now.toString()" to now.toString(),
"euros.format(PRICE)" to euros.format(PRICE),
"integer.format(PRICE)" to integer.format(PRICE),
"\"%.1f\".format(Locale.ROOT, PRICE)" to "%.1f".format(Locale.ROOT, PRICE),
"percent.format(RATE)" to percent.format(RATE),
"NAME.uppercase()" to NAME.uppercase(),
"NAME.capitalized" to NAME.capitalized,
"\"RDV\".lowercase()" to "RDV".lowercase(),
"languages.take(3).joinToString(\", \")" to languages.take(3).joinToString(", "),
"JsonObject(...).toString()" to JsonObject(doctor.mapValues { JsonPrimitive(it.value) }).toString(),
// dos transformaciones seguidas: el resultado de la primera pasa a la segunda
"NAME.capitalized.initials" to NAME.capitalized.initials,
)
ExamplePage("Example 09 - formatting") {
// una tabla: la primera columna ocupa el 55 % del ancho (weight)
Row(Modifier.padding(4.dp)) {
Text("In the code", Modifier.weight(0.55f), fontWeight = FontWeight.Bold)
Text("Displayed", Modifier.weight(0.45f), fontWeight = FontWeight.Bold)
}
// un par puede "desestructurarse": (code, value)
for ((code, value) in rows) {
HorizontalDivider()
Row(Modifier.padding(4.dp)) {
Text(code, Modifier.weight(0.55f), fontFamily = FontFamily.Monospace, fontSize = 11.sp, color = Color(0xFFC7254E))
Text(value, Modifier.weight(0.45f))
}
}
Spacer(Modifier.height(16.dp))
Text("Going through the entries of a Map", style = MaterialTheme.typography.titleSmall)
for ((key, value) in doctor) {
Text("$key = $value")
}
Spacer(Modifier.height(16.dp))
Text("A home-made function: timeRange", style = MaterialTheme.typography.titleSmall)
for (s in slots) {
Text("${timeRange(s)} (start: ${timeRange(s, Part.START)})")
}
Spacer(Modifier.height(16.dp))
OutlinedButton(onClick = { now = LocalDateTime.now() }) { Text("Refresh the time") }
}
}
|
- líneas 51–62: los formateadores, creados de una vez por todas fuera de las funciones [@Composable] (crearlos cuesta más que usarlos). [FormatStyle.MEDIUM], [FULL]...: formatos “predefinidos”; [ofPattern]: un patrón; [apply [ ... ]] configura el objeto que acaba de crearse y lo devuelve;
- líneas 85–103: cada línea de la tabla es un par (código mostrado, valor), generado con [to];
- línea 113: un par, como una entrada de un [Map], se “desempaqueta”: [for ((code, value) in rows)].


Nota ["%.1f".format(Locale.ROOT, PRICE)]: sin el idioma “neutro” [Locale.ROOT], [format] usaría el idioma del teléfono y escribiría “1234,5” en francés. Esto es lo que se necesita para la visualización, no para los datos enviados a un servidor.