3.1 — Generación de interfaces a partir de documentos de descripción¶
El trabajo de ingeniería: describir una interfaz en un documento de texto y generar la pantalla a partir de él. Veremos el XML que describe interfaces y su equivalente moderno en Compose, donde la descripción de la interfaz es código Kotlin.
Cada
Código Nes el código real del proyectoDIU3Escenasque produjo su captura (se omiten losimport).
1. Introducción¶
1.1. Resultado de aprendizaje y criterios¶
RA1. Genera interfaces gráficos de usuario mediante editores visuales utilizando las funcionalidades del editor y adaptando el código generado (RD 405/2023, módulo 0488).
| CE | Criterio de evaluación | Dónde se trabaja |
|---|---|---|
| a | Se ha creado un interfaz gráfico utilizando las herramientas de un editor visual. | §5 (@Preview) |
| b | Se han utilizado las funciones del editor para ubicar los componentes del interfaz. | §2 y §5 |
| c | Se han modificado las propiedades de los componentes para adecuarlas a las necesidades de la aplicación. | §3 |
| d | Se ha analizado el código generado por el editor visual. | §3 y §5 (Layout Inspector) |
| e | Se ha modificado el código generado por el editor visual. | §3.3 y §8 |
| f | Se han asociado a los eventos las acciones correspondientes. | §4 |
| g | Se ha desarrollado una aplicación que incluye el interfaz gráfico obtenido. | §7 y §8 |
La comparativa de herramientas del §5 trabaja además el RA3 a).
1.2. Describir o programar la interfaz¶
Antes, una pantalla Android se escribía en dos lenguajes: un layout XML describía la interfaz y Java o Kotlin programaba la lógica.
Unas herramientas traducían el XML a código. Con Jetpack Compose la interfaz se programa
directamente en Kotlin declarativo, sin documento intermedio: cada elemento es una función
@Composable (un Column hace el papel del antiguo LinearLayout vertical).
El XML sigue importando: es el formato de intercambio de datos (feeds, mapas, configuraciones), describe interfaces en otras plataformas (XHTML, SVG) y está en todas las apps Android heredadas.
💡 Idea central del tema
Las dos vías tienen las mismas piezas: etiquetas ↔ composables, atributos ↔ parámetros, eventos ↔ lambdas.
2. Lenguajes de descripción basados en XML¶
XML es un metalenguaje: no describe nada por sí mismo, sino que sirve para definir otros lenguajes de marcas. El tema estudia seis.
2.1. XHTML¶
El lenguaje de las páginas web, en versión estricta. En Android se muestra con un WebView, y es el
navegador quien genera la interfaz a partir del documento.
Código 1. Un documento XHTML dentro de una pantalla Compose (Figura 2).
@Composable
fun AvisoXhtml() {
val aviso = """
<html><body>
<h3>Aviso legal</h3>
<p>Esta app usa datos <b>públicos</b>.</p>
</body></html>
""".trimIndent()
AndroidView(
factory = { ctx -> WebView(ctx).apply { loadData(aviso, "text/html", "utf-8") } },
modifier = Modifier.fillMaxWidth().height(200.dp),
)
}

2.2. GML¶
GML describe datos geográficos (puntos, rutas, zonas). La ficha de un mirador es un documento GML, y la pantalla que lo muestra se genera a partir de sus datos.
Código 2. La tarjeta se construye leyendo las etiquetas del documento (Figura 3).
fun etiqueta(xml: String, tag: String) = Regex("<$tag>(.*)</$tag>").find(xml)!!.groupValues[1]
@Composable
fun FichaGml() {
val gml = """
<mirador>
<title>Mirador del Castillo</title>
<coord>36.7447, -6.4427</coord>
</mirador>
""".trimIndent()
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text(gml, fontFamily = FontFamily.Monospace, fontSize = 13.sp) // el documento
Card { // la interfaz generada
Column(Modifier.padding(16.dp)) {
Text(etiqueta(gml, "title"), fontWeight = FontWeight.Bold)
Text(etiqueta(gml, "coord"), color = Color.Gray)
}
}
}
}

2.3. MathML¶
MathML describe fórmulas matemáticas con etiquetas (<mfrac> es una fracción, <msup> un exponente).
Android no lo entiende de forma nativa: se muestra dentro de un WebView, igual que el XHTML del Código 1.
2.4. RSS¶
RSS es el XML de las noticias: un <channel> con varios <item>, cada uno con title, link, description y pubDate.
Un lector de noticias lee el RSS y compone una interfaz: recorrer el canal es generar la interfaz.
Código 3. Una tarjeta por cada ítem del canal (Figura 4).
data class Noticia(val titulo: String, val fecha: String)
val noticias = listOf(
Noticia("Calendario de prácticas", "18 oct"),
Noticia("Nueva versión de Compose", "17 oct"),
Noticia("Taller de SVG el jueves", "16 oct"),
)
@Composable
fun LectorRss() {
Column {
for (n in noticias) { // recorrer el canal = generar la interfaz
Card(Modifier.fillMaxWidth().padding(vertical = 4.dp)) {
Column(Modifier.padding(12.dp)) {
Text(n.titulo, fontWeight = FontWeight.Bold)
Text(n.fecha, color = Color.Gray)
}
}
}
}
}

2.5. XSLT¶
XSLT es un lenguaje basado en XML que sirve para transformar un documento XML en otro (por ejemplo, en HTML) mediante reglas,
del tipo "cada vez que veas <titulo>, saca un <h2> con su contenido".
2.6. SVG¶
SVG describe gráficos vectoriales en XML: la imagen no es una cuadrícula de píxeles, sino una lista de trazados (el atributo d de <path>).
Por eso escala sin pixelarse y ocupa muy poco. En Compose se convierte en un ImageVector: se
copia el atributo d, se parsea con addPathNodes y se pinta con Image.
Código 4. La estrella del logo, del SVG al ImageVector (Figura 5).
@Composable
fun LogoVectorial() {
val estrella = ImageVector.Builder(
defaultWidth = 24.dp, defaultHeight = 24.dp,
viewportWidth = 24f, viewportHeight = 24f, // el viewBox del SVG
).addPath(
pathData = addPathNodes("M12,2 L15,9 L22,9 L16.5,13.5 L18.5,21 L12,16.5 L5.5,21 L7.5,13.5 L2,9 L9,9 Z"),
fill = SolidColor(Color(0xFFFFD600)), // el fill del SVG
).build()
Image(
estrella,
contentDescription = "Logo estrella",
modifier = Modifier.size(200.dp)
.background(Color(0xFF1A237E), RoundedCornerShape(24.dp)).padding(24.dp),
)
}

3. El documento XML: análisis y edición¶
Un documento XML se lee con etiquetas, atributos, valores y anidamiento, y cada concepto tiene su equivalente en Compose:
3.1. Etiquetas¶
Etiqueta → composable. En XML la etiqueta define el control; en Compose es una llamada a una función
@Composable: <Button/> pasa a ser Button(...).
3.2. Atributos, valores y anidamiento¶
- Atributo → parámetro:
android:textSize="14sp"pasa a serfontSize = 14.sp. Un parámetro admite expresiones, no solo literales. - Valor → argumento: el dato concreto; el
"Enviar"del atributo pasa a ser"Enviar"como argumento. - Anidamiento → slots de contenido: las etiquetas hijas van dentro de las llaves.
3.3. Literales y recursos¶
Un literal escribe el dato en el código; una referencia a recurso apunta a un valor definido aparte (el tema, strings.xml).
La ventaja del recurso: si lo cambias, el cambio se aplica a toda la app desde un solo sitio.
Código 5. El mismo fondo con un literal y con un recurso del tema (Figura 7).
@Composable
fun LiteralYRecurso() {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text("Color literal", Modifier.fillMaxWidth().background(Color(0xFF00695C)).padding(16.dp),
color = Color.White)
Text("Color del tema (recurso)",
Modifier.fillMaxWidth().background(MaterialTheme.colorScheme.primary).padding(16.dp),
color = MaterialTheme.colorScheme.onPrimary)
}
}

4. Eventos¶
En XML el evento se enlaza por el nombre de un método: android:onClick="enviar". Si el nombre está mal escrito, el compilador no lo detecta y el fallo aparece al ejecutar.
En Compose el evento es una lambda que se pasa como parámetro: Button(onClick = { enviar() }).
El estado que cambia vive junto a él:
mutableStateOfcrea un estado observable: cuando cambia, Compose recompone (vuelve a dibujar) la parte que lo usa.rememberconserva ese estado entre recomposiciones; sin él, el valor volvería a su inicio en cada redibujado.
Código 6. Cada pulsación muta el estado y la pantalla se repinta sola (Figura 8, tras tres pulsaciones).
@Composable
fun Contador() {
var pulsaciones by remember { mutableStateOf(0) } // estado observable que se conserva
Button(onClick = { pulsaciones++ }) { // el evento es una lambda
Text("Pulsaciones: $pulsaciones")
}
}

5. Herramientas para crear interfaces¶
| Herramienta | Para qué sirve |
|---|---|
| Notepad++ | Editor de texto con resaltado y validación de XML. |
| Visual Studio Code | Editor con extensiones para XML, vista previa y Git. |
| Adobe Dreamweaver | Edición visual (WYSIWYG) de XHTML y CSS. |
| Android Studio | Edita el código y genera la interfaz a la vez con @Preview. |
@Preview dibuja un composable en el panel de diseño sin lanzar el emulador,
con variantes para tema oscuro, tamaños de fuente o dispositivos:
El Layout Inspector muestra en vivo el árbol de composición de la app en ejecución, con medidas, colores y jerarquía: es el análisis del documento XML, pero del documento "vivo".
6. Generación de código para diferentes plataformas¶
Antes, de un documento XML se generaba código para cada plataforma. Hoy tiene dos lecturas:
- La interfaz se genera sola desde el código: escribes composables y Compose los materializa en cada pantalla, configuración y tema.
- Con Kotlin Multiplatform el mismo código Compose se ejecuta en Android, iOS y escritorio: la descripción ya no se traduce a cada plataforma, se ejecuta en cada una.
7. Caso práctico 1: logo con gráficos vectoriales¶
Enunciado: construir el logo de la app a partir del trazado SVG de una estrella.
Solución: se copia el atributo d como pathData, se parsea con addPathNodes, se monta el
ImageVector con el fill del SVG y se pinta con Image (Código 4). Al ser trazados, el logo se ve
nítido a cualquier tamaño (Figura 5).
8. Caso práctico 2: estructura de documento XML¶
Enunciado: simular la entrada de un documento con su <title> y construir una ficha que se actualiza
mientras se edita.
Código 7. Editar el documento y ver la interfaz cambiar en el mismo sitio (Figura 9).
@Composable
fun FichaEditable() {
var titulo by remember { mutableStateOf("Estación de Chipiona") }
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
OutlinedTextField(value = titulo, onValueChange = { titulo = it }, label = { Text("<title>") })
Card { Text(titulo, Modifier.padding(16.dp), fontWeight = FontWeight.Bold) } // se repinta al escribir
}
}

9. Resumen¶
- XML es un metalenguaje: XHTML, GML, MathML, RSS, XSLT y SVG son lenguajes definidos con él.
- Documento XML = etiquetas + atributos + valores + anidamiento; composable = función + parámetros + argumentos + slots.
- Eventos: de la conexión por nombre (
android:onClick) a la lambda con estadoremember. - Herramientas: editores de XML y Android Studio con
@Previewy Layout Inspector. - Plataformas: la descripción se ejecuta en cada plataforma (Compose + Kotlin Multiplatform) en vez de traducirse.
Bibliografía y fuentes¶
- W3C. XML, SVG 2, MathML 3.0 y XSLT 3.0. https://www.w3.org/TR/
- IETF RFC 4287 (Atom) y OGC GML. https://datatracker.ietf.org/doc/html/rfc4287 · https://www.ogc.org/standards/gml/
- Android Developers. Jetpack Compose,
@Previewy Layout Inspector. https://developer.android.com/develop/ui/compose - Real Decreto 405/2023 (BOE-A-2023-13221). Módulo 0488 Desarrollo de interfaces: RA1 y RA3 a).