Saltar a contenido

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 rememberSaveable con Saver propio.

Todo el código es el del proyecto IsmaelUIKit de la UD4, ampliado con dos componentes nuevos (PanelPuntero y Tecla), compilado y ejecutado en el emulador (se omiten los import).

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:

  1. Responde: solo a los eventos que le interesan, y a cada evento le tiene asociada una acción concreta.
  2. Recuerda: su estado visible sobrevive a una rotación de pantalla.
  3. Se deja mirar: desde fuera (Layout Inspector, uiautomator, un lector de pantalla) se ve qué es, cómo se llama y dónde está.

Diagrama del modelo de eventos: fuente, evento, oyente y acción, y su recorrido en Compose como gesto, modifier, lambda y estado

Figura 1. El recorrido de un evento: un componente detecta, avisa y alguien actúa.

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.

app/src/main/java/com/example/uikit/demo/MainActivity.kt (escena 6)
    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:

uiautomator dump, escena 6 (datos reales)
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=""

Pantalla vertical Que sobrevive al giro con dos campos rellenos: rememberSaveable con Sigo despues del giro y remember a secas con Me pierdo

Figura 2. Antes del giro: los dos campos tienen texto.

Pantalla apaisada tras girar: el campo rememberSaveable conserva su texto y el campo remember ha quedado vacio

Figura 3. Después del giro: la actividad se ha destruido y recreado. El campo guardado sigue entero; el otro ha vuelto a nacer vacío.

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:

fun PanelPuntero(configuracion: ConfigPuntero, onCambio: (ConfigPuntero) -> Unit, ...)

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.

ui/src/main/java/com/example/uikit/Nota.kt
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),
)
ui/src/main/java/com/example/uikit/Tecla.kt
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 y waitForUpOrCancellation() 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
        },
) { /* … */ }
  • FocusRequester pide el foco y se encadena con focusRestorer() 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 focusGroup y 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
  1. Detectar: onClick/onValueChange en el propio componente.
  2. Interpretar: el valor llega por parámetro de la lambda.
  3. Validar: deVelocidad(texto) (§8), con require.
  4. Cambiar el estado: config = config.copy(...).
  5. 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:

configuracion.copy(velocidad = 50)        // objeto NUEVO; el anterior sigue intacto

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.

ui/src/main/java/com/example/uikit/ConfigPuntero.kt
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.

ui/src/main/java/com/example/uikit/PanelPuntero.kt (primera parte)
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.

ui/src/main/java/com/example/uikit/PanelPuntero.kt (segunda parte)
/**
 * 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.

Pantalla Configuracion del puntero con el boton 50 y el boton Derecho seleccionados, el interruptor apagado, un raton dibujado con el boton derecho en amarillo y una barra verde de 60 dp

Figura 4. El caso práctico 1, ejecutado: cuerpo, dos botones, rueda y la barra de velocidad con la correspondencia 0 → 20 rojo, 25 → 40 naranja, 50 → 60 verde. La línea 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 — ConfigPuntero con 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.

app/src/main/java/com/example/uikit/demo/MainActivity.kt (escena 5)
/** 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)
    }
}

Teclado de piano con siete teclas blancas Do Re Mi Fa Sol La Si y un recuadro con el registro de pulsaciones 1 Do C 261.63 Hz, 2 Sol G 392.0 Hz, 3 Mi E 329.63 Hz

Figura 5. Tres toques reales: Do → Sol → Mi. El registro lo escribe la lambda onTocar: si el evento no hubiera llegado, la casilla diría «Toca una tecla».

Teclado de piano con la tecla Fa pintada en amarillo mientras el dedo la mantiene pulsada

Figura 6. La tecla Fa hundida, con el dedo aún puesto. El amarillo aparece entre 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: remember para lo interno de la pantalla, rememberSaveable para lo que el usuario escribió, y Saver para tipos propios.
  • Eventos: fuente → evento → oyente → acción; el oyente es un parámetro de la función y el Modifier de 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

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.