5.1 — Explotación de componentes visuales¶
El trabajo de ingeniería: capturar lo que hace el usuario, convertirlo en acciones y conservar el estado del componente. Las herramientas: Jetpack Compose y
rememberSaveableconSaverpropio.Todo el código es el del proyecto
IsmaelUIKitde la UD4, ampliado con dos componentes nuevos (PanelPunteroyTecla), compilado y ejecutado en el emulador (se omiten losimport).
Resultado de aprendizaje que trabaja esta unidad¶
RA3. Crea componentes visuales valorando y empleando herramientas específicas (RD 405/2023, módulo 0488), con el criterio de eventos que en la UD4 quedó abierto y aquí se cierra, más uno del RA1. Las pruebas unitarias sobre los componentes (RA3 e) se trabajarán más adelante.
| CE | Criterio de evaluación | Dónde se trabaja |
|---|---|---|
| RA3 d | Se han determinado los eventos a los que debe responder el componente y se les han asociado las acciones correspondientes. | §3 tabla de eventos, §4 Tecla, §8 y §9 casos prácticos |
| RA1 g | Se han asociado acciones a los eventos de la interfaz. | §6 flujo de asociación, §8 |
| RA3 c | Propiedades con valores por defecto. | §7, ConfigPuntero inmutable |
| RA3 h | Aplicaciones cuyo interfaz utiliza los componentes creados. | las escenas nuevas del MainActivity |
1. Introducción y contextualización práctica¶
En la UD4 fabricaste componentes. Este tema los explota: convertirlos en piezas que responden al usuario, sobreviven a que el sistema destruya la actividad y se pueden inspeccionar desde fuera.
Un componente «explotado» cumple tres cosas:
- Responde: solo a los eventos que le interesan, y a cada evento le tiene asociada una acción concreta.
- Recuerda: su estado visible sobrevive a una rotación de pantalla.
- Se deja mirar: desde fuera (Layout Inspector,
uiautomator, un lector de pantalla) se ve qué es, cómo se llama y dónde está.
2. Características fundamentales del componente explotado¶
2.1 Introspección¶
Introspección es la capacidad de que el entorno descubra qué es un componente y qué propiedades tiene sin conocer su código. No hace falta abrir el fuente: se le pregunta al componente y él mismo se describe.
La idea viene de los entornos visuales de toda la vida: el editor examinaba la clase del componente para descubrir sus propiedades y sus eventos y mostrarlos en la paleta, sin que nadie se los explicara a mano. Un componente que se deja inspeccionar se puede reutilizar, porque quien lo recibe sabe qué ofrece sin leer cómo está hecho.
En Compose, la introspección de una interfaz es el árbol de semántica: un árbol paralelo al de la interfaz en el que cada pieza visible declara qué significa. El sistema lo consulta para saber qué hay en la pantalla. Cada nodo describe:
- Rol: qué es la pieza (un botón, una casilla, un interruptor, una imagen…).
- Contenido: el texto o la descripción que la identifica.
- Estado: si está activada, seleccionada, habilitada o enfocada.
- Acciones: qué se puede hacer con ella (pulsarla, desplazarla, escribir en ella).
- Posición y tamaño: la caja que ocupa en pantalla, que es también el área que acepta el toque.
Quien más se apoya en este árbol son los servicios de accesibilidad: un lector de pantalla como TalkBack lee en voz alta el rol, el contenido y el estado de cada pieza. También lo leen las herramientas de inspección del sistema, que enseñan desde fuera qué contiene la interfaz.
Buena parte de la descripción sale sola: un botón con un texto dentro ya se describe con ese texto. Pero un componente que se pinta a sí mismo (una tecla de piano dibujada, un gráfico) no tiene ningún texto del que sacar su nombre: en ese caso, describirse es responsabilidad de quien crea el componente.
2.2 Persistencia del componente¶
El componente tiene que poder guardar y recuperar su estado. En Android eso no es un lujo: al girar el móvil, el sistema destruye la actividad y la vuelve a crear. Si no guardas nada, la pantalla vuelve en blanco.
En Compose hay dos formas de recordar y la diferencia importa: remember vive mientras vive la composición; rememberSaveable sobrevive a la destrucción de la actividad porque viaja en el Bundle del sistema.
var sobrevive by rememberSaveable { mutableStateOf("") } // pasa por el Bundle
var sePierde by remember { mutableStateOf("") } // vive solo en la composicion
rememberSaveable solo sabe guardar tipos que caben en un Bundle (números, texto, Parcelable,
listas de esas cosas). A un tipo propio hay que enseñarle a guardarse con un Saver: dos funciones,
una que reduce el objeto a algo serializable y otra que lo reconstruye (§8, SaverConfigPuntero).
Comprobado en el emulador, girando el dispositivo con adb shell settings put system user_rotation 1.
Volcado de uiautomator (lo que el sistema ve de la pantalla), antes y después del giro:
ANTES campo-sobrevive text="Sigo despues del giro" campo-se-pierde text="Me pierdo"
DESPUES campo-sobrevive text="Sigo despues del giro" campo-se-pierde text=""


Qué NO se guarda en el Bundle
El Bundle de estado tiene un tope pequeño. Se guarda lo que el usuario ha puesto o elegido:
texto del formulario, filtro de la lista, índice de la pestaña. No se guarda lo que se puede volver
a pedir (el listado del servidor, una imagen descargada): eso es la capa de datos, que trata PMDM.
3. Eventos: clases, componentes y métodos¶
La programación basada en eventos tiene tres piezas: fuente (el componente que genera el evento), objeto de evento (lo que se envía) y oyente (quien lo escucha y actúa). Lo que se decide al diseñar un componente es el contrato: a qué responde cada pieza y qué hace cuando responde.
En Compose no se registran oyentes: el oyente es un parámetro de la función y el objeto evento casi nunca se ve, porque se interpreta dentro del Modifier de entrada. El contrato se declara en la firma:
Con esa línea ya está dicho todo: el componente no cambia nada por dentro, devuelve la configuración completa cuando el usuario toca, y no sabe qué hará el llamador con ella.
3.1 Qué eventos tiene cada componente¶
| Componente | Evento(s) que le interesan | Acción razonable |
|---|---|---|
Button |
onClick |
emitir el evento propio con el estado nuevo |
Switch |
onCheckedChange(activada) |
copiar la configuración con el booleano cambiado |
OutlinedTextField |
onValueChange, onKeyboardAction |
validar, y solo escribir si es válido |
Slider |
onValueChange, onValueChangeFinished |
previsualizar durante el arrastre y confirmar al soltar |
Tecla (propio) |
onPulsar, onSoltar |
sonar y pintar la tecla hundida |
FiguraRaton (propio) |
ninguno: solo recibe | pintar según lo que le pasan |
| Pantalla completa | teclas (DPAD, Tab), foco | mover el foco de forma predecible |
La fila de FiguraRaton es la importante
Un componente de dibujo no necesita eventos: es una función de ConfigPuntero a píxeles. Si le
metes estado dentro, introduces una segunda fuente de verdad. Cuanta más lógica de presentación esté en componentes que solo reciben parámetros, menos pruebas hacen falta y menos fallos hay.
4. Tipos de evento y su Modifier¶
| Tipo de evento | Cómo se captura en Compose | Notas |
|---|---|---|
| Acción (pulsar un control) | onClick = { ... } de Button o Modifier.clickable |
La lambda está en el propio componente: ya sabes cuál se ha tocado. |
| Teclado | Modifier.onPreviewKeyEvent { } / onKeyEvent { } |
Devuelve true si te lo quedas, false para que siga subiendo. |
| Puntero: pulsar y soltar | Modifier.pointerInput { awaitEachGesture { ... } } |
Para componentes propios que se pintan a sí mismos. |
| Puntero: entrar y salir (ratón) | Modifier.hoverable |
En táctil casi no se usa. |
| Arrastre | Modifier.pointerInput { detectDragGestures { … } } |
El arrastre viene con la distancia acumulada. |
| Foco | Modifier.onFocusEvent { estado.hasFocus }, FocusRequester |
Con teclado físico o DPAD no es opcional. |
| Cambio de valor | onValueChange de Slider, TextField, Checkbox |
Todo evento en Compose se gestiona igual: un Modifier que observa y una lambda que actúa. Lo único que cambia entre un evento y otro es el Modifier que se pone delante.
Código 1. Las teclas del piano. Tecla es un componente propio sin botón debajo, así que el gesto
se captura con pointerInput.
package com.example.uikit
/**
* Datos del teclado del caso práctico 2: nombre en español (lo que ve el alumno), letra inglesa
* y frecuencia real, que es lo que necesita `AudioTrack` para generar el sonido.
*/
data class Nota(val nombre: String, val inglesa: String, val frecuenciaHz: Double)
/** Las siete teclas del caso práctico 2. */
val ESCALA: List<Nota> = listOf(
Nota("Do", "C", 261.63),
Nota("Re", "D", 293.66),
Nota("Mi", "E", 329.63),
Nota("Fa", "F", 349.23),
Nota("Sol", "G", 392.00),
Nota("La", "A", 440.00),
Nota("Si", "B", 493.88),
)
package com.example.uikit
/**
* Una tecla del piano. Un componente propio no tiene botón debajo, así que el gesto se detecta
* con `pointerInput`, en versión suspend (`awaitEachGesture`).
*
* El componente **no sabe que suena nada**: avisa por sus dos eventos y quien lo use decide.
*/
@Composable
fun Tecla(
nota: Nota,
presionada: Boolean,
onPulsar: (Nota) -> Unit,
onSoltar: (Nota) -> Unit,
modifier: Modifier = Modifier,
) {
val forma = RoundedCornerShape(bottomStart = 10.dp, bottomEnd = 10.dp)
Box(
contentAlignment = Alignment.BottomCenter,
modifier = modifier
.width(44.dp)
.height(150.dp)
.background(if (presionada) Color(0xFFFFF176) else Color.White, forma)
.border(1.dp, Color(0xFF37474F), forma)
.semantics { contentDescription = "Tecla ${nota.nombre}" } // para el lector de pantalla
.testTag("tecla-${nota.nombre}") // nombre estable de la tecla
.pointerInput(nota) {
awaitEachGesture { // cada toque es un bucle de gestos
awaitFirstDown(requireUnconsumed = false) // el dedo toca: pulsacion
onPulsar(nota) // aqui sonaria la nota
waitForUpOrCancellation() // espera la subida del dedo
onSoltar(nota) // el dedo se levanta
}
},
) {
Text(
nota.nombre,
fontSize = 13.sp,
color = Color(0xFF37474F),
modifier = Modifier.padding(bottom = 10.dp),
)
}
}
/**
* Fila de teclas. Es un componente de orden superior: recibe la escala y el evento, y
* **esconde** el estado «qué tecla está abajo ahora» porque nadie de fuera necesita saberlo.
*/
@Composable
fun TecladoPiano(
notas: List<Nota> = ESCALA,
onTocar: (Nota) -> Unit,
modifier: Modifier = Modifier,
) {
var pulsada by remember { mutableStateOf<String?>(null) } // solo interes interno
Row(
modifier = modifier.padding(8.dp),
horizontalArrangement = Arrangement.spacedBy(3.dp),
) {
notas.forEach { nota ->
Tecla(
nota = nota,
presionada = pulsada == nota.nombre,
onPulsar = { pulsada = nota.nombre; onTocar(nota) },
onSoltar = { if (pulsada == nota.nombre) pulsada = null },
)
}
}
}
Dentro del pointerInput hay un mini-protocolo que es bueno saber leer:
awaitEachGesture { }— bucle: se reactiva con cada gesto nuevo sobre el componente.awaitFirstDown()espera a que el dedo toque ywaitForUpOrCancellation()espera a que se levante. Entre las dos, el componente está «pulsado».- El bloque es suspend: se pausa sin bloquear el hilo de la interfaz, mientras no llames a algo bloqueante.
pointerInput(nota)lleva una clave: si la nota cambia, el bloque se reinicia y deja de escuchar el gesto viejo. Sin clave, la lambda se queda con el valor de la primera composición: es la fuente de errores de eventos más frecuente en Compose.
5. Foco y teclado físico¶
En un móvil el foco importa: mando de consola, teclado Bluetooth, accesibilidad y navegación por controles. Las piezas que hay que conocer:
var foco by remember { mutableStateOf(false) }
Box(
Modifier
.onFocusEvent { evento -> foco = evento.hasFocus } // gana o pierde el foco
.onPreviewKeyEvent { evento -> // antes de que el campo se lo coma
if (evento.key == Key.Enter && evento.type == KeyEventType.KeyUp) {
onPulsar(nota); true // true = me lo he quedado
} else false // false = que siga subiendo
},
) { /* … */ }
FocusRequesterpide el foco y se encadena confocusRestorer()para recuperarlo tras una recomposición.- El recorrido del foco va en el orden en que se declara la interfaz; si el orden visual no coincide
con el del árbol, se arregla con
focusGroupy el orden de foco, no a mano.
6. Asociación de acciones a eventos¶
Asociar una acción a un evento sigue siempre el mismo flujo:
flowchart LR
A[1. Detectar<br/>Modifier de gesto] --> B[2. Interpretar<br/>lambda con datos ya procesados]
B --> C[3. Validar<br/>convertir y rechazar lo imposible]
C --> D[4. Mutar el estado<br/>MutableState fuera del componente]
D --> E[5. Recomponer<br/>Compose repinta lo que cambió]
E -.el usuario ve el cambio.-> A
- Detectar:
onClick/onValueChangeen el propio componente. - Interpretar: el valor llega por parámetro de la lambda.
- Validar:
deVelocidad(texto)(§8), conrequire. - Cambiar el estado:
config = config.copy(...). - Refrescar la vista: nada que hacer, Compose observa el
MutableState.
El error de concepto que hay que arrancar: la acción de un evento no repinta, cambia el estado. Quien repinta es el sistema de composición.
Cuatro antipatrones que se ven en los exámenes
| Antipatrón | Por qué se rompe |
|---|---|
Mutar una lista dentro del @Composable sin mutableStateListOf |
Compose no se entera: la pantalla no cambia y parece que «el evento no llega». |
| Guardar en el evento el valor anterior («para poder volver») | Dos copias de la verdad: se desincronizan al girar la pantalla. |
| Petición de red o disco dentro de la lambda del clic | Si tarda, la interfaz se bloquea. Se lanza en una corrutina o con LaunchedEffect. |
when de 12 ramas dentro del componente para decidir qué hacer |
El componente deja de ser reutilizable: la decisión es del llamador. |
7. Propiedades y valores por defecto en un componente con estado¶
Criterio RA3 c, que en la UD4 se resolvió con un enum y un texto. Aquí la propiedad es un objeto de
dominio, y la forma de cambiarla es inmutable:
Con objetos inmutables, el evento puede entregar la configuración completa: no hay ambigüedad sobre qué ha cambiado ni quién lo cambió, y el Saver puede serializar el objeto entero de golpe. Además, un data class da equals (Compose puede comparar y no repintar de más), copy (actualizaciones parciales) y toString (un volcado legible en el log).
8. Caso práctico 1: «Configuración del puntero»¶
Enunciado. Interfaz para configurar la velocidad del puntero (0, 25 o 50) y el botón principal (izquierdo o derecho), con una barra de velocidad pintada a mano (0 → 20 dp roja, 25 → 40 dp naranja, 50 → 60 dp verde) y un ratón dibujado donde se resalta el botón elegido.
Solución. Tres botones para la velocidad (el valor entra ya validado: no existe la velocidad 37),
dos para el botón principal y un Switch para la animación. Cada control dispara el mismo evento
onCambio con la configuración completa, y el dibujo se repinta solo al cambiar el estado.
Código 2. Las propiedades, su guardado y su validación.
package com.example.uikit
/** Qué botón del ratón hace de principal. */
enum class BotonRaton(val etiqueta: String) {
IZQUIERDO("Izquierdo"),
DERECHO("Derecho"),
}
/**
* Propiedades del panel de puntero.
*
* Es un `data class` inmutable: en lugar de mutar el objeto, el componente **fabrica uno nuevo**
* con `copy(...)` y lo devuelve por el evento. Así el cambio es trazable y se puede guardar.
*/
data class ConfigPuntero(
val velocidad: Int = 25,
val principal: BotonRaton = BotonRaton.IZQUIERDO,
val animacion: Boolean = true,
) {
companion object {
/**
* Parsea la velocidad tecleada por el usuario. Un `IllegalArgumentException` en mitad del
* evento hunde la aplicacion, asi que se comprueba aqui y se captura en la pantalla.
*/
fun deVelocidad(texto: String): ConfigPuntero {
val numero = texto.trim().toIntOrNull()
?: throw NumberFormatException("«$texto» no es un número")
require(numero in setOf(0, 25, 50)) { "Velocidad no admitida: $numero" }
return ConfigPuntero(velocidad = numero)
}
}
/** Longitud y color de la barra del caso práctico: 0→20 rojo, 25→40 naranja, 50→60 verde. */
val barra: Pair<Float, Long>
get() = when (velocidad) {
0 -> 20f to 0xFFD32F2FL
50 -> 60f to 0xFF388E3CL
else -> 40f to 0xFFF9A825L
}
}
/**
* Cómo se guarda `ConfigPuntero` cuando el sistema destruye la actividad (al girar, por ejemplo).
*
* `rememberSaveable` no sabe qué es un `ConfigPuntero`: hay que decirle cómo reducirlo a algo
* que quepa en el `Bundle` (aqui un `IntArray` de 3: velocidad, boton, animacion) y cómo
* reconstruirlo. Eso es un `Saver`.
*/
val SaverConfigPuntero: Saver<ConfigPuntero, IntArray> = Saver(
save = { config ->
intArrayOf(
config.velocidad, // 0, 25 o 50
if (config.principal == BotonRaton.IZQUIERDO) 0 else 1,
if (config.animacion) 1 else 0,
)
},
restore = { guardado ->
ConfigPuntero(
velocidad = guardado[0],
principal = if (guardado[1] == 0) BotonRaton.IZQUIERDO else BotonRaton.DERECHO,
animacion = guardado[2] == 1,
)
},
)
Código 3. El componente que emite los eventos.
package com.example.uikit
/**
* Panel de configuración del puntero. Hay botones por opción y un `Switch`: **cada control
* dispara el mismo evento** `onCambio` con la configuración completa, porque el componente
* es inmutable y no se toca a si mismo.
*
* @param configuracion lo que hay ahora (viene de fuera: el componente no lo recuerda)
* @param onCambio evento: se llama con la configuración nueva cada vez que el usuario toca algo
*/
@Composable
fun PanelPuntero(
configuracion: ConfigPuntero,
onCambio: (ConfigPuntero) -> Unit,
modifier: Modifier = Modifier,
) {
Column(
modifier = modifier.fillMaxWidth(),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Text("Velocidad del puntero", style = MaterialTheme.typography.titleSmall)
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
listOf(0, 25, 50).forEach { velocidad ->
val elegido = velocidad == configuracion.velocidad
Button(
onClick = { onCambio(configuracion.copy(velocidad = velocidad)) },
colors = coloresElegido(elegido),
modifier = Modifier
.testTag("velocidad-$velocidad")
.semantics { contentDescription = "Velocidad $velocidad" },
) { Text("$velocidad") }
}
}
Text("Botón principal", style = MaterialTheme.typography.titleSmall)
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
BotonRaton.entries.forEach { boton ->
val elegido = boton == configuracion.principal
Button(
onClick = { onCambio(configuracion.copy(principal = boton)) },
colors = coloresElegido(elegido),
modifier = Modifier
.testTag("boton-${boton.name}")
.semantics { contentDescription = "Botón ${boton.etiqueta}" },
) { Text(boton.etiqueta) }
}
}
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(12.dp),
) {
Switch(
checked = configuracion.animacion,
onCheckedChange = { activada -> onCambio(configuracion.copy(animacion = activada)) },
modifier = Modifier.testTag("animacion"),
)
Text("Animación del puntero")
}
FiguraRaton(configuracion) // la prueba visual del estado
Text(
"Barra: ${configuracion.barra.first.toInt()} dp",
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.testTag("estado-barra"),
)
}
}
/** Botón pintado como elegido o no elegido, sin APIs experimentales de Material 3. */
@Composable
private fun coloresElegido(elegido: Boolean) = ButtonDefaults.buttonColors(
containerColor = if (elegido) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
contentColor = if (elegido) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant,
)
Código 4. El ratón dibujado con DrawScope. No tiene eventos: solo recibe la configuración.
/**
* Ratón dibujado a mano (caso práctico 1) con `DrawScope`, en **dp**: se ve igual en cualquier
* densidad de pantalla. La barra reproduce la correspondencia del enunciado.
*/
@Composable
fun FiguraRaton(configuracion: ConfigPuntero, modifier: Modifier = Modifier) {
val (longitudBarra, colorBarra) = configuracion.barra
val centro = if (configuracion.principal == BotonRaton.IZQUIERDO) -1f else 1f
Canvas(modifier = modifier.fillMaxWidth().height(190.dp).testTag("figura-raton")) {
val cx = size.width / 2f
val cuerpo = Color(0xFF90A4AE)
val borde = Color(0xFF546E7A)
// 1) cuerpo del ratón: rectangulo muy redondeado
drawRoundRect(
color = cuerpo,
topLeft = Offset(cx - 60f.dp.toPx(), 12f.dp.toPx()),
size = Size(120f.dp.toPx(), 140f.dp.toPx()),
cornerRadius = CornerRadius(60f.dp.toPx()),
)
// 2) los dos botones; el elegido se pinta claro
val anchoBoton = 50f.dp.toPx()
val xIzquierda = cx - 54f.dp.toPx()
val xDerecha = cx + 4f.dp.toPx()
listOf(xIzquierda, xDerecha).forEachIndexed { indice, x ->
val esElegido = (indice == 0 && centro < 0) || (indice == 1 && centro > 0)
drawRoundRect(
color = if (esElegido) Color(0xFFFFF176) else Color(0xFFECEFF1),
topLeft = Offset(x, 20f.dp.toPx()),
size = Size(anchoBoton, 52f.dp.toPx()),
cornerRadius = CornerRadius(20f.dp.toPx()),
)
}
// 3) la rueda y la linea que separa los botones
drawRoundRect(
color = Color(0xFF455A64),
topLeft = Offset(cx - 5f.dp.toPx(), 34f.dp.toPx()),
size = Size(10f.dp.toPx(), 24f.dp.toPx()),
cornerRadius = CornerRadius(5f.dp.toPx()),
)
drawLine(borde, Offset(cx, 20f.dp.toPx()), Offset(cx, 76f.dp.toPx()), strokeWidth = 2f.dp.toPx())
// 4) la barra de velocidad: longitud y color segun la propiedad `barra`
drawRoundRect(
color = Color(colorBarra),
topLeft = Offset(16f.dp.toPx(), 168f.dp.toPx()),
size = Size(longitudBarra.dp.toPx(), 14f.dp.toPx()),
cornerRadius = CornerRadius(7f.dp.toPx()),
)
}
}
Resultado. Tocado con adb shell input tap: velocidad 50, botón Derecho, animación apagada.

Barra: 60 dp sale del estado real del componente.Lista de comprobación de los criterios:
- RA3 d — los eventos del panel están declarados en su firma y conectados a una acción.
- RA3 c —
ConfigPunterocon valores por defecto (25,IZQUIERDO,true). - RA1 g — la acción asociada (cambiar la configuración) cambia el estado y se ve en el dibujo.
9. Caso práctico 2: «Teclado de piano»¶
Enunciado. Siete teclas (Do a Si) que suenan al pulsarlas.
Solución. El componente TecladoPiano del §4 distingue pulsar de soltar y avisa con onTocar. El
sonido lo genera una función aparte de la app, tocarNota(frecuencia), que calcula la onda y la
reproduce con AudioTrack en un hilo propio para no bloquear la interfaz. El componente no sabe nada
de sonido: solo emite el evento.
Código 5. La escena, con un registro de lo que suena: es la prueba visible del evento, porque el sonido no se ve en una captura.
/** Escena 5: caso practico 2 (teclado de piano). El log demuestra que el evento llego. */
@Composable
private fun EscenaPiano() {
val registro = remember { androidx.compose.runtime.mutableStateListOf<String>() }
Column(
modifier = Modifier.fillMaxSize().padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Text("Teclado de piano", style = MaterialTheme.typography.titleMedium)
TecladoPiano(onTocar = { nota ->
registro.add("${registro.size + 1}. ${nota.nombre} (${ nota.inglesa }) · ${nota.frecuenciaHz} Hz")
tocarNota(nota.frecuenciaHz) // sonido real: no se ve en la captura
})
Card(modifier = Modifier.fillMaxWidth()) {
Column(modifier = Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
Text("Registro de pulsaciones", style = MaterialTheme.typography.labelMedium)
if (registro.isEmpty()) Text("Toca una tecla")
registro.takeLast(4).forEach { linea -> Text(linea, style = MaterialTheme.typography.bodyMedium) }
}
}
Text("ESCENA 5 - piano", style = MaterialTheme.typography.bodySmall)
}
}

onTocar: si el evento no hubiera llegado, la casilla diría «Toca una tecla».
awaitFirstDown() y waitForUpOrCancellation() y desaparece al soltar: es la señal visual del par de eventos.10. Errores típicos al explotar componentes¶
| Error | Síntoma | Solución |
|---|---|---|
remember donde tocaba rememberSaveable |
la pantalla se limpia al girar el móvil | el estado que el usuario escribió, a rememberSaveable (con Saver si es un tipo propio) |
Saver que no reconstruye un campo |
tras el giro falta media configuración | probar el giro, no solo el arranque |
| Evento que muta el parámetro que le pasó el padre | Compose no recompone o lo hace tarde | el parámetro es val: se emite un objeto nuevo por el evento |
Clave equivocada en pointerInput |
el gesto responde con datos del elemento anterior | la clave debe ser lo que cambia: pointerInput(nota) |
11. Resumen¶
- Un componente explotado responde, recuerda y se deja inspeccionar. Las tres cosas, no una.
- Introspección: el árbol de semántica. Cada pieza declara su rol, contenido, estado, acciones y caja, y el entorno lo descubre sin leer su código.
- Persistencia:
rememberpara lo interno de la pantalla,rememberSaveablepara lo que el usuario escribió, ySaverpara tipos propios. - Eventos: fuente → evento → oyente → acción; el oyente es un parámetro de la función y el
Modifierde entrada lo captura (clickable,pointerInput,onKeyEvent,onFocusEvent). - Acciones: un evento cambia el estado; el sistema de composición repinta. Nunca al revés.
Bibliografía y fuentes¶
Documentación oficial de Android
- Android Developers. Puntero y gestos en Compose (
Modifier.pointerInput,awaitEachGesture). https://developer.android.com/develop/ui/compose/touch-input/pointer-input/understand-gestures - Android Developers. Interacción con teclado y foco (
onPreviewKeyEvent,FocusRequester). https://developer.android.com/develop/ui/compose/touch-input/keyboard-input/commands y https://developer.android.com/develop/ui/compose/touch-input/focus/keyboard-focus - Android Developers. Semántica en Compose (
semantics,contentDescription,testTagsAsResourceId). https://developer.android.com/develop/ui/compose/accessibility - Android Developers. Guardar el estado de la interfaz (
rememberSaveable,Saver). https://developer.android.com/topic/libraries/architecture/saving-states - Google. uiautomator. https://developer.android.com/training/testing/other-components/ui-automator
- Kotlin Foundation. Data classes y copy. https://kotlinlang.org/docs/data-classes.html
Normativa del módulo
- Real Decreto 405/2023, de 29 de mayo (BOE-A-2023-13221). Módulo profesional 0488 Desarrollo de interfaces: RA3 (criterios c, d y h) y RA1 g), que son los que ordenan este tema.