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 Nes código real del proyectoIsmaelUIKit, compilado y ejecutado, comentado línea a línea (se omiten solo losimport).
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.
¿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:
- Interfaz pública clara: parámetros con tipos y nombres que se entienden sin leer el interior.
- Valores por defecto sensatos: quien lo usa puede llamarlo con lo mínimo (
BadgeEstado(Estado.OK)). - Sin efectos sorpresa: no guarda datos “en un sitio raro”, no escribe ficheros, no lanza peticiones de red.
- Comunicación por eventos: informa de lo que pasa con lambdas (
onSeleccion), no rebuscando en la pantalla. - Aislado y portable: no depende de una Activity concreta ni de un paquete de la aplicación.
- 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 = ModifierSIEMPRE 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"]
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¶
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.
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)
}
}

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.
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:
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. |
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.
// 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:
- El módulo
:uiusa el plugincom.android.library, y por eso compila a.aaren vez de a.apk. apifiltra la dependencia a quien te usa;implementationla esconde. Un kit de UI declara Compose conapi, porque quien consuma el componente también compila contra Compose.- 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:
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:
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:
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.
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()
}

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).
/** 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")
}
}

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 = Modifiersiempre como primer parámetro opcional, para que decida el llamador. - Diseño y prueba visual sin móvil:
@Preview,@PreviewParameter,uiModey Layout Inspector. La prueba automática concreateComposeRulese trabaja en la unidad 11. - Dibujar a mano:
Canvas { }yDrawScope(óvalo, rectángulo,Path, trazos y degradados). - Imágenes:
ImageVectordesde SVG (tema 3),painterResourcepara 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 enlibs/para llevarlo a otro. El.aarconsumido 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
@Previewpor 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
- Android Developers. Jetpack Compose — documentación principal. https://developer.android.com/develop/ui/compose
- Android Developers.
@Previewhttps://developer.android.com/develop/ui/compose/tooling/previews y Layout Inspector https://developer.android.com/studio/debug/layout-inspector - Android Developers. Pruebas de interfaz con Compose Testing. https://developer.android.com/develop/ui/compose/testing
- Android Developers. Dibujo con
DrawScopeyModifier.drawBehind. https://developer.android.com/develop/ui/compose/graphics/draw - Android Developers. Módulos de librería y formatos AAR. https://developer.android.com/studio/projects/android-library
- Android Developers. Dependencias de construcción: ficheros locales y dependencias transitivas. https://developer.android.com/studio/build/dependencies
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.