Saltar a contenido

4.1 — Creación de componentes visuales

El trabajo de ingeniería de este tema: crear una pieza nueva, darle propiedades y empaquetarla para reutilizarla, con Jetpack Compose, un módulo de librería y las previews.

Cada bloque marcado como Código N es código real del proyecto IsmaelUIKit, compilado y ejecutado, comentado línea a línea (se omiten solo 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).

CE Criterio de evaluación Dónde se trabaja
a Se han identificado las herramientas para diseño y prueba de componentes. §6.3 previews, §7 herramientas
b Se han creado componentes visuales. §6 BadgeEstado y SelectorMes, §9 LienzoFiguras
c Se han definido sus métodos y propiedades con asignación de valores por defecto. §4 y §6, parámetros con defecto
d Se han determinado los eventos a los que debe responder el componente y se les han asociado las acciones correspondientes. §6.3 SelectorMes, §11 caso del abono
e Se han realizado pruebas unitarias sobre los componentes desarrollados. La unidad 11 (evaluación del funcionamiento)
f Se han documentado los componentes creados. La unidad 9 (documentación y ayudas)
g Se han empaquetado componentes. §8 módulo :ui y su AAR
h Se han programado aplicaciones cuyo interfaz gráfico utiliza los componentes creados. §11, app IsmaelUIKit.demo

1. Introducción y contextualización práctica

Hasta ahora has usado componentes: Button, TextField, Card… Los ponías, les cambiabas propiedades y les conectabas eventos. Este tema da el paso siguiente: fabricar tus propios componentes, los que la librería estándar no trae.

Diagrama de flujo: tres pantallas distintas reutilizan el mismo componente BadgeEstado desde el modulo :ui

Figura 1. El mismo componente, tres contextos. Escribirlo una vez y reutilizarlo diez es todo el sentido del tema.

¿Cuándo se crea un componente y no se copia y pega el código? La regla práctica:

  • Aparece dos veces en la aplicación con el mismo aspecto → componente.
  • Cambia el color, el texto o el tamaño, pero no la estructura → componente con parámetros.
  • Lo necesita otro equipo u otro proyecto → componente en un módulo de librería aparte (§8).

Un componente es código probado y reutilizable que se comunica con el resto a través de su interfaz pública: sus parámetros de entrada y sus eventos de salida. Todo lo que no esté en esa interfaz es interno y puede cambiar sin romper a nadie.

2. Desarrollo de software en componentes

Programar “en componentes” significa ensamblar piezas hechas en vez de escribirlo todo. Las ventajas son siempre las mismas:

Ventaja Qué significa en el día a día
Reutilización Escribes la pieza una vez; la usas en todas las pantallas y proyectos.
Fiabilidad El componente ya se probó una vez; no se vuelve a probar desde cero.
Coste y plazo Montar pantallas pasa de “escribir” a “componer”.
Consistencia Si el botón de “aceptar” es uno solo, se ve igual en toda la app.
Mantenimiento Cambiar el verde de “Completado” es tocar una línea, no veinte pantallas.

3. Concepto de componente y características

Definición de componente de interfaz

Pieza de código que dibuja una parte de la pantalla y se comporta de forma predecible: recibe datos por parámetros, avisa de lo que pasa por eventos y no necesita saber dónde está colocada.

Para que merezca ese nombre, se le piden seis cosas:

  1. Interfaz pública clara: parámetros con tipos y nombres que se entienden sin leer el interior.
  2. Valores por defecto sensatos: quien lo usa puede llamarlo con lo mínimo (BadgeEstado(Estado.OK)).
  3. Sin efectos sorpresa: no guarda datos “en un sitio raro”, no escribe ficheros, no lanza peticiones de red.
  4. Comunicación por eventos: informa de lo que pasa con lambdas (onSeleccion), no rebuscando en la pantalla.
  5. Aislado y portable: no depende de una Activity concreta ni de un paquete de la aplicación.
  6. Documentado y probado: trae explicación, previsualizaciones y al menos una prueba.

En Compose, un componente es una función @Composable. No hay que heredar de ninguna clase base ni registrarla en ninguna paleta: si es @Composable, el editor la entiende, la previsualiza y Layout Inspector la muestra.

4. Propiedades y atributos

En Compose las propiedades son parámetros de la función, y el «valor por defecto» es directamente el valor por defecto del parámetro:

Parte del componente Cómo se escribe Ejemplo real de esta unidad
Propiedad obligatoria Parámetro sin defecto estado: Estado
Propiedad con valor de fábrica Parámetro con defecto texto: String = estado.etiqueta
Propiedad booleana opcional Boolean con defecto conPunto: Boolean = true
Propiedad calculada desde otra Expresión en el defecto relleno = estado.acento.copy(alpha = 0.15f)
Lo que dibuja Cuerpo de la @Composable El Row { ... } que pinta la píldora
Evento Parámetro lambda onSeleccion: (Int) -> Unit

Tres detalles que se preguntan en el examen y que deciden si un componente es bueno:

  • modifier: Modifier = Modifier SIEMPRE como primer parámetro opcional: es lo que permite a quien te llama colocar y dar tamaño a tu componente sin tocarte el código.
  • Un parámetro con valor por defecto es documentación: dice qué es opcional y cuál es el comportamiento normal.
  • Si una propiedad se calcula a partir de otra, calcúlala en el defecto (estado.acento.copy(alpha = 0.15f)) en vez de obligar a quien te llama a repetirlo.

En Compose no existe una instancia viva del componente a la que «ponerle» un valor. Cada vez que cambia un dato, la función se vuelve a ejecutar y produce la nueva pantalla. Por eso las propiedades son parámetros de entrada, y las «modificaciones» se devuelven al llamador con un evento.

5. El proyecto donde vive todo el tema

El tema se trabaja en el proyecto IsmaelUIKit, con dos módulos: el de componentes y la aplicación que los usa.

flowchart TD
    A["modulo :app<br/>com.example.uikit.demo<br/>la aplicacion de ejemplo"] -->|implementation project(:ui)| B["modulo :ui<br/>com.example.uikit<br/>el kit de componentes"]
    B --> C["BadgeEstado<br/>pildora de estado"]
    B --> D["SelectorMes<br/>desplegable con evento"]
    B --> E["LienzoFiguras<br/>dibujo con DrawScope"]
    B --> F["Estado<br/>enum con color y texto"]
    B --> G["Pruebas (UD11): BadgeEstadoTest"]
settings.gradle.kts
rootProject.name = "IsmaelUIKit"
include(":app")   // la aplicacion de demostracion
include(":ui")    // el kit de componentes: aqui viven los componentes creados en clase

La configuración del módulo :ui (el que produce el paquete) se explica en el apartado 8.

6. Creación de un nuevo componente: BadgeEstado

Empezamos por el caso más simple que cumple todas las reglas: una píldora de estado con un punto de color y un texto. Se parte de componentes existentes (Row, Text y Box de Material 3) y se les añade lo que falta.

6.1. El enum que trae las propiedades puestas

ui/src/main/java/com/example/uikit/Estado.kt
package com.example.uikit

/**
 * Los tres estados que sabe representar el kit.
 *
 * Es un `enum class` con datos: cada valor se construye con las **propiedades** que el
 * componente necesita para pintarse. Asi el color y el mensaje viajan *dentro* del estado
 * y no repartidos por las pantallas: cambiar el verde de "Completado" es tocar una linea.
 *
 * @param etiqueta texto que ve el usuario en el componente
 * @param acento color de referencia (punto, texto y borde) del estado
 * @param mensaje frase larga para los sitios donde el estado se explica, no se solo pinta
 */
enum class Estado(
    val etiqueta: String,
    val acento: Color,
    val mensaje: String,
) {
    OK("Completado", Color(0xFF1B5E20L), "Todo en orden"),
    AVISO("Revisa", Color(0xFFB26A00L), "Hay algo que conviene mirar"),
    ERROR("Fallido", Color(0xFFB00020L), "Algo no ha funcionado"),
}

6.2. El componente

Código 1. Fichero de BadgeEstado, incluido su @Preview. Es el código que produjo la Figura 2.

ui/src/main/java/com/example/uikit/BadgeEstado.kt
package com.example.uikit

/**
 * Componente: chivato de estado con punto de color y texto.
 *
 * Cada parametro es una **propiedad** del componente: valores por defecto incluidos,
 * para que quien nos llame pueda quedarse solo con lo obligatorio.
 *
 * @param estado unico dato obligatorio: de el salen color, punto y texto por defecto
 * @param texto permite sustituir la etiqueta del estado sin crear otro componente
 * @param modifier hereda la posicion y el tamano que decida quien nos llama
 * @param conPunto apaga el punto de color para las listas donde ya sobra
 * @param relleno color de fondo; por defecto el acento del estado al 15% de opacidad
 */
@Composable
fun BadgeEstado(
    estado: Estado,
    texto: String = estado.etiqueta,
    modifier: Modifier = Modifier,
    conPunto: Boolean = true,
    relleno: Color = estado.acento.copy(alpha = 0.15f),
) {
    Row(
        modifier = modifier
            .testTag("badge_" + estado.name)          // nombre estable para las pruebas
            .clip(RoundedCornerShape(percent = 50))    // recorte en "pastilla": esquinas al 50%
            .background(relleno)                       // fondo del color del estado, apagado
            .padding(horizontal = 12.dp, vertical = 6.dp),
        verticalAlignment = Alignment.CenterVertically, // punto y texto, centrados en su fila
        horizontalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        if (conPunto) {
            Box(
                Modifier
                    .size(10.dp)                       // diametro del punto
                    .clip(CircleShape)                 // caja cuadrada -> circulo
                    .background(estado.acento),        // el color puro del estado
            )
        }
        Text(
            text = texto,
            color = estado.acento,
            style = MaterialTheme.typography.labelLarge, // la tipografia la decide el tema, no el componente
        )
    }
}

/** Documentacion viva: la propia pantalla de diseno ensena como se ve el componente. */
@Preview(name = "BadgeEstado · tres estados", showBackground = true)
@Composable
private fun VistaPreviaBadge() {
    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        BadgeEstado(estado = Estado.OK)
        BadgeEstado(estado = Estado.AVISO)
        BadgeEstado(estado = Estado.ERROR, conPunto = false)
    }
}

Pantalla Catalogo del kit con tres pildoras: Completado en verde con punto, Caducado en ambar con punto y Fallido en rosa sin punto

Figura 2. El Código 1 en ejecución en la app de demostración. La primera píldora usa todos los valores por defecto; la segunda solo cambia `texto`; la tercera apaga el punto con `conPunto = false`.

Fíjate en lo que no hace el componente: no sabe en qué pantalla está, no sabe qué idioma habla, no crea estado propio. Un componente sin estado propio es más fácil de reutilizar: el estado lo decide quien lo usa, y el componente solo dibuja lo que le cuentan.

6.3. Un componente con evento: SelectorMes

Un desplegable de meses es el mismo tipo de componente, con la diferencia de que devuelve información a la pantalla mediante un evento.

Código 2. Fichero de SelectorMes, con sus dos @Preview. El botón «Elige un mes» de la Figura 5 lo pinta este código.

ui/src/main/java/com/example/uikit/SelectorMes.kt
package com.example.uikit

/** Los doce meses: la lista es una propiedad mas, se puede sustituir por otro calendario. */
val MESES = listOf(
    "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio",
    "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre",
)

/**
 * Componente: desplegable de meses con estado interno.
 *
 * Aqui el componente se guarda solo si esta abierto el menu (estado interno) y **avisa**
 * al exterior por un evento: `onSeleccion`, la pareja moderna de "asociar acciones al evento".
 *
 * @param mesSeleccionado 1..12: el control es "controlado", manda quien nos usa
 * @param onSeleccion evento: se dispara con el numero de mes cuando el usuario elige uno
 * @param modifier posicion y tamano decididos por la pantalla
 * @param textoVacio etiqueta del boton cuando aun no hay eleccion
 */
@Composable
fun SelectorMes(
    mesSeleccionado: Int?,
    onSeleccion: (Int) -> Unit,
    modifier: Modifier = Modifier,
    textoVacio: String = "Elige un mes",
) {
    var abierto by remember { mutableIntStateOf(0) }   // 0 = cerrado, 1 = abierto (estado interno)
    Box(modifier) {
        OutlinedButton(
            onClick = { abierto = 1 },                  // evento de apertura
            modifier = Modifier.testTag("selector_mes"),
        ) {
            Text(mesSeleccionado?.let { MESES[it - 1] } ?: textoVacio)
        }
        DropdownMenu(expanded = abierto == 1, onDismissRequest = { abierto = 0 }) {
            MESES.forEachIndexed { indice, nombre ->
                DropdownMenuItem(
                    text = { Text(nombre) },
                    onClick = {                          // el evento propaga el numero, no el nombre:
                        abierto = 0                      // la pantalla decide que hacer con el mes
                        onSeleccion(indice + 1)
                    },
                    trailingIcon = if (indice + 1 == mesSeleccionado) {
                        { Text("ok") }                   // marca la opcion activa
                    } else {
                        null
                    },
                )
            }
        }
    }
}

@Preview(name = "SelectorMes · sin elegir", showBackground = true)
@Composable
private fun VistaPreviaSelectorVacio() {
    SelectorMes(mesSeleccionado = null, onSeleccion = {})
}

@Preview(name = "SelectorMes · con eleccion", showBackground = true)
@Composable
private fun VistaPreviaSelectorElegido() {
    SelectorMes(mesSeleccionado = 3, onSeleccion = {})
}

Dos estados, dos previsualizaciones. Todo componente con aspecto distinto según su estado trae un @Preview por estado. Cuando los estados dependen de una lista de datos, se usa @PreviewParameter y un proveedor:

Variante con todos los estados a la vez (no requiere emulador)
class ProveedorEstado : PreviewParameterProvider<Estado> {
    override val values: Sequence<Estado> = sequenceOf(Estado.OK, Estado.AVISO, Estado.ERROR)
}

@Preview(name = "BadgeEstado · parametrizado")
@Composable
private fun VistaPreviaParametrizada(@PreviewParameter(ProveedorEstado::class) estado: Estado) {
    BadgeEstado(estado = estado)          // el editor genera una fila por cada valor de la lista
}

7. Herramientas para diseñar y probar componentes (CE a)

Los editores de imágenes (Photoshop, GIMP, Paint.NET, Inkscape) se usan para crear el material gráfico. Para diseñar y probar el componente en sí, las herramientas son estas:

Herramienta Qué hace Cuándo se usa
@Preview y sus variantes Dibuja el componente en el editor, sin arrancar el móvil. Cada vez que cambias una propiedad.
@PreviewParameter Genera una preview por cada valor de prueba. Componentes con estados o listas.
Layout Inspector Árbol real de la interfaz: medidas, colores, orden de composición. Cuando algo no se ve donde debía.
Compose Testing (createComposeRule) Busca nodos por testTag o texto y comprueba lo que se ve. Pruebas automáticas (CE e).
lint / Detekt Avisos de estilo y errores típicos de Compose. En el build y en la CI.
Figma, Inkscape, vector asset studio Material gráfico (iconos, logos) que se convierte a ImageVector. Antes de escribir el componente.

Diagrama de las dos mitades del ciclo de un componente: disenar (Figma, ImageVector, @Preview) y probar (Layout Inspector, Compose Test, lint)

Figura 3. El ciclo de trabajo de un componente: diseñar, previsualizar, ejecutar, medir, probar.

8. Integración y empaquetado del componente (CE g)

Un componente empaquetado es reutilizable; un componente copiado y pegado es el mismo problema en dos sitios. El paquete es un módulo de librería que al compilar produce un .aar (Android Archive): un ZIP con las clases compiladas, los recursos y su propio manifiesto.

ui/build.gradle.kts
// Modulo de libreria :ui: del modulo sale el AAR que se puede reutilizar.
plugins {
    alias(libs.plugins.android.library)
    alias(libs.plugins.kotlin.compose)
}

android {
    namespace = "com.example.uikit"     // paquete raiz del componente; sustituye al package del manifest
    compileSdk { version = release(37) }

    defaultConfig {
        minSdk = 24
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    buildFeatures {
        compose = true
    }
}

dependencies {
    // api, no implementation: quien consuma :ui debe ver Compose sin declararlo el tambien
    api(platform(libs.androidx.compose.bom))
    api(libs.androidx.compose.foundation)
    api(libs.androidx.compose.material3)
    api(libs.androidx.compose.ui)
    api(libs.androidx.compose.ui.graphics)
    implementation(libs.androidx.compose.ui.tooling.preview)
    debugImplementation(libs.androidx.compose.ui.tooling)

    // Pruebas del componente (se trabajan en la UD11)
    androidTestImplementation(platform(libs.androidx.compose.bom))
    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.espresso.core)
    debugImplementation(libs.androidx.compose.ui.test.manifest)
}

Tres cosas que hay que tener claras:

  1. El módulo :ui usa el plugin com.android.library, y por eso compila a .aar en vez de a .apk.
  2. api filtra la dependencia a quien te usa; implementation la esconde. Un kit de UI declara Compose con api, porque quien consuma el componente también compila contra Compose.
  3. Dentro del mismo proyecto no hay que empaquetar nada: implementation(project(":ui")) y listo. El caso que merece la pena es el del apartado 8.1: otro proyecto.

8.1. Llevar el componente a otro proyecto, paso a paso

Todo esto se hace en local, sin subir nada a ningún sitio.

Paso 1. Construir el AAR desde la raíz del proyecto del componente:

Terminal
./gradlew :ui:assembleRelease

La salida queda en ui/build/outputs/aar/ui-release.aar.

Paso 2. Copiar el .aar al proyecto que lo va a usar, en una carpeta app/libs/. Renómbralo con número de versión (uikit-1.0.0.aar) para distinguir una entrega de la siguiente.

Paso 3. Declararlo en app/build.gradle.kts:

app/build.gradle.kts del proyecto que consume el componente
dependencies {
    implementation(files("libs/uikit-1.0.0.aar"))

    // El AAR no arrastra sus dependencias: hay que volver a declararlas aqui.
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.compose.foundation)
    implementation(libs.androidx.compose.material3)
    implementation(libs.androidx.compose.ui)
    implementation(libs.androidx.activity.compose)
}

El fallo que te espera la primera vez

Unresolved reference: MaterialTheme, o Unresolved reference: Modifier. No es que el AAR esté roto: es que un AAR consumido como fichero no trae las dependencias que tenía su módulo, así que Compose hay que declararlo también en el proyecto destino.

Paso 4. Sincronizar Gradle y usar el componente desde una pantalla normal:

app/src/main/java/com/example/otraplicacion/PantallaExtra.kt
import com.example.uikit.BadgeEstado
import com.example.uikit.Estado

@Preview(showBackground = true)
@Composable
fun PantallaExtra() {
    BadgeEstado(Estado.OK)        // el componente ya viene dentro del .aar
}

Paso 5. Compilar. Si ./gradlew :app:assembleDebug termina en BUILD SUCCESSFUL y la @Preview se pinta, el componente está viajando dentro del AAR: no has copiado ni una línea de su código fuente.

Cada vez que cambies el componente se repite el ciclo: assembleRelease, copiar el fichero con una versión nueva y tocar la línea files(...).

9. Dibujar sobre la interfaz: DrawScope (CE b)

Hay piezas que no vienen en Material: una insignia pintada a mano, un medidor, una línea de metro con estaciones. Compose ofrece un lienzo llamado DrawScope, disponible dentro de Canvas { } o de Modifier.drawBehind { }: se le da color, coordenadas y figuras, y el propio Compose se encarga de volver a dibujar cuando cambia el estado.

Lo que hay que dibujar Cómo se escribe en Compose Notas
Un lienzo donde pintar Canvas { ... } o Modifier.drawBehind { ... } Al cambiar el estado se redibuja solo.
Óvalo o rectángulo drawOval(color, topLeft = Offset(x, y), size = Size(w, h)) / drawRect(...) Coordenadas y tamaño en píxeles; el color es un argumento.
Polígono de tres vértices Path().apply { moveTo(); lineTo(); close() } + drawPath(...) La forma se construye con un Path.
Trazo grueso y redondeado style = Stroke(width = 10f, cap = StrokeCap.Round) Degradados con Brush.

Código 3. Fichero del componente de dibujo. Es el código que produjo la Figura 4.

ui/src/main/java/com/example/uikit/LienzoFiguras.kt
package com.example.uikit

/**
 * Componente: las figuras del ejercicio de dibujo, pintadas con `DrawScope`.
 *
 * Dentro de `Canvas` tienes un `DrawScope` con las operaciones de dibujo y coordenadas
 * en pixeles. Las cifras del enunciado: ovalo verde en (150, 70) de 50x70,
 * rectangulo amarillo en (350, 70) de 50x70 y triangulo naranja debajo.
 */
@Composable
fun LienzoFiguras(modifier: Modifier = Modifier) {
    Canvas(modifier.fillMaxSize().background(Color.White)) {
        // 1. Ovalo: caja imaginaria de 50x70 en (150, 70) -> drawOval
        drawOval(
            color = Color(0xFF2E7D32L),
            topLeft = Offset(150f, 70f),
            size = Size(50f, 70f),
        )
        // 2. Rectangulo relleno: mismo tamano, 200 px mas a la derecha
        drawRect(
            color = Color(0xFFF9A825L),
            topLeft = Offset(350f, 70f),
            size = Size(50f, 70f),
        )
        // 3. Triangulo: se construye con un Path de tres vertices
        val triangulo = Path().apply {
            moveTo(250f, 200f)
            lineTo(300f, 270f)
            lineTo(200f, 270f)
            close()                                     // cierra el vertice con el origen
        }
        drawPath(triangulo, color = Color(0xFFEF6C00L))

        // 4. Y una linea de metro: trazo redondeado con degradado y estaciones en blanco
        val via = Path().apply {
            moveTo(60f, 360f)
            lineTo(320f, 360f)
        }
        drawPath(
            path = via,
            brush = Brush.linearGradient(
                colors = listOf(Color(0xFF0277BDL), Color(0xFF4FC3F7L)),
                start = Offset(60f, 360f),
                end = Offset(320f, 360f),
            ),
            style = Stroke(width = 10f, cap = StrokeCap.Round),
        )
        listOf(60f, 190f, 320f).forEach { x ->          // estaciones: circulos con borde
            drawCircle(color = Color.White, radius = 10f, center = Offset(x, 360f))
            drawCircle(
                color = Color(0xFF0277BDL),
                radius = 10f,
                center = Offset(x, 360f),
                style = Stroke(width = 4f),
            )
        }
    }
}

@Preview(name = "LienzoFiguras", showBackground = true, widthDp = 380, heightDp = 420)
@Composable
private fun VistaPreviaLienzo() {
    LienzoFiguras()
}

Pantalla Figuras con DrawScope: ovalo verde, rectangulo amarillo, triangulo naranja y una linea azul con tres estaciones blancas

Figura 4. El Código 3 en ejecución: óvalo, rectángulo y triángulo con las coordenadas del enunciado, más una línea de metro con degradado y estaciones.

10. Imágenes en el componente

Cada imagen tiene su origen y su forma de cargarse:

Caso Cómo se hace Claves
Icono o logotipo vectorial del componente ImageVector (creado desde SVG, tema 3) o vector asset studio Escala sin pixelar y pesa cientos de bytes.
Imagen incluida en el paquete (PNG, WebP) painterResource(R.drawable.nombre) dentro de Image(...) Vive en el módulo: va dentro del .aar.
Imagen remota (por URL) librería de carga asíncrona (Coil AsyncImage) Muestra un hueco mientras carga y un error si falla.

11. Caso práctico 1: “Interfaz del metro” (adaptado)

Enunciado del caso práctico. La Red de Transporte Regional quiere una pantalla para recargar el abono mensual. Hace falta un desplegable con los doce meses y que la interfaz confirme la recarga elegida.

Montaje con el kit. La pantalla no dibuja nada “a mano”: compone piezas del módulo :ui (CE h).

app/src/main/java/com/example/uikit/demo/MainActivity.kt (escena 3)
/** Escena 3: caso practico 1 (recarga de abono). El evento del componente alimenta la pantalla. */
@Composable
private fun EscenaAbono() {
    var mes by remember { mutableStateOf<Int?>(null) }   // estado de la PANTALLA, no del componente
    Column(
        modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(24.dp),
        verticalArrangement = Arrangement.spacedBy(16.dp),
    ) {
        Text("Recarga del abono", style = MaterialTheme.typography.headlineSmall)
        SelectorMes(                                      // componente del kit: no sabe nada de abonos
            mesSeleccionado = mes,
            onSeleccion = { elegido -> mes = elegido },   // el evento sube el numero de mes
        )
        Card(modifier = Modifier.fillMaxWidth()) {
            Column(
                modifier = Modifier.padding(16.dp),
                verticalArrangement = Arrangement.spacedBy(8.dp),
            ) {
                Text(
                    if (mes == null) "Selecciona el mes que quieres recargar"
                    else "Recargado: ${com.example.uikit.MESES[mes!! - 1]} · 20,00 EUR",
                )
                BadgeEstado(
                    estado = if (mes == null) Estado.AVISO else Estado.OK,
                    texto = if (mes == null) "Falta el mes" else Estado.OK.etiqueta,
                )
            }
        }
        Text("ESCENA 3 - abono")
    }
}

Pantalla Recarga del abono con el boton Elige un mes, una tarjeta que pide seleccionar el mes y una pildora de aviso Falta el mes

Figura 5. Estado inicial: `mes == null`, así que la tarjeta pide el mes y el badge se pinta en ámbar. Al elegir uno, el evento `onSeleccion` cambia el estado y la pantalla pasa a “Recargado: Marzo · 20,00 EUR” con el badge verde.

El detalle con nota: el componente no sabe qué es un abono. SelectorMes solo sabe de meses; la lógica del precio y de la confirmación es de la pantalla. Ese reparto es lo que permite reutilizar el desplegable en una cita médica, una reserva o un formulario de matrícula.

12. Caso práctico 2: “Formas básicas con DrawScope” (adaptado)

El ejercicio de siempre: óvalo verde en (150, 70), rectángulo amarillo en (350, 70), ambos de 50 × 70, y un triángulo naranja con Path. El Código 3 lo resuelve con esas mismas cifras (drawOval, drawRect y drawPath); el resultado es la Figura 4.

13. Errores típicos al crear componentes

Error Síntoma Solución
No aceptar modifier El llamador no puede colocar tu componente. Primer parámetro opcional: modifier: Modifier = Modifier, aplicado al contenedor raíz.
Guardar estado que no es tuyo El componente “se acuerda” de cosas y se contradice al girar la pantalla. Estado interno solo para lo interno (si el menú está abierto). Lo demás, parámetro + evento.
implementation donde toca api Quien usa el kit tiene que volver a declarar Compose. api para lo que forma parte de la interfaz pública del componente.
Sin testTag Las pruebas buscan textos que cambian con el idioma. testTag estables y, solo de apoyo, búsqueda por texto.

14. Resumen

  • Componente = pieza de código reutilizable con interfaz pública: parámetros de entrada, eventos de salida. En Compose un componente es una función @Composable: no hay clase base que heredar ni paleta en la que registrarlo.
  • Propiedades = parámetros de la función, con modifier: Modifier = Modifier siempre como primer parámetro opcional, para que decida el llamador.
  • Diseño y prueba visual sin móvil: @Preview, @PreviewParameter, uiMode y Layout Inspector. La prueba automática con createComposeRule se trabaja en la unidad 11.
  • Dibujar a mano: Canvas { } y DrawScope (óvalo, rectángulo, Path, trazos y degradados).
  • Imágenes: ImageVector desde SVG (tema 3), painterResource para lo empaquetado y carga asíncrona para lo remoto.
  • Empaquetar: módulo de librería → .aar → implementation(project(":ui")) dentro del proyecto, o el fichero en libs/ para llevarlo a otro. El .aar consumido como fichero no arrastra sus dependencias: en el destino hay que volver a declararlas.
  • Documentar: el KDoc del Código 1 ya documenta cada propiedad y un @Preview por estado vale más que un párrafo; la documentación publicada se trabaja en la unidad 9.

Bibliografía y fuentes

Documentación oficial de Android y de las herramientas

Normativa del módulo

  • Real Decreto 405/2023, de 29 de mayo (BOE-A-2023-13221). Módulo profesional 0488 Desarrollo de interfaces: RA3 y sus criterios de evaluación a) a h), que son los que ordenan este tema.