Saltar a contenido

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 N es el código real del proyecto DIU3Escenas que produjo su captura (se omiten los import).

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.

Esquema con los seis lenguajes basados en XML alrededor de un documento XML central.

Figura 1. Los seis lenguajes de descripción basados en XML del tema.

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),
    )
}

Pantalla con el aviso legal en XHTML: título Aviso legal y un párrafo con la palabra públicos en negrita.

Figura 2. El Código 1 en el emulador: el navegador genera la interfaz a partir del documento XHTML.
⚠️ Importante: XHTML obliga a documentos well-formed: toda etiqueta cerrada, atributos entre comillas y un único nodo raíz.

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)
            }
        }
    }
}

Pantalla con el documento GML del mirador en monoespaciada y debajo la tarjeta con el título y las coordenadas.

Figura 3. El documento GML (arriba) y la interfaz generada a partir de él (abajo).

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)
                }
            }
        }
    }
}

Tres tarjetas de noticias con su título en negrita y la fecha en gris.

Figura 4. Los tres ítems del canal RSS convertidos en tarjetas.

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),
    )
}

Estrella amarilla sobre un cuadrado azul oscuro con esquinas redondeadas.

Figura 5. El logo vectorial en el emulador.

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:

Tabla comparativa: etiqueta ↔ composable, atributo ↔ parámetro, valor ↔ argumento, anidamiento ↔ slots de contenido.

Figura 6. Cada concepto del XML tiene su gemelo 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 ser fontSize = 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.
<Button android:text="Enviar" android:textSize="14sp" />
Button(onClick = { enviar() }) { Text("Enviar", fontSize = 14.sp) }

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)
    }
}

Dos franjas de color: arriba una verde con el texto Color literal y abajo otra con el color del tema.

Figura 7. Literal frente a recurso del tema.

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:

  • mutableStateOf crea un estado observable: cuando cambia, Compose recompone (vuelve a dibujar) la parte que lo usa.
  • remember conserva 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")
    }
}

Botón con el texto Pulsaciones: 3.

Figura 8. El contador después de tres 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:

@Preview(showBackground = true)
@Composable
fun VistaPrevia() { FichaGml() }

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:

  1. La interfaz se genera sola desde el código: escribes composables y Compose los materializa en cada pantalla, configuración y tema.
  2. 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
    }
}

Campo de texto con la etiqueta title y debajo una tarjeta con el mismo texto en negrita.

Figura 9. La tarjeta refleja al instante lo que se escribe en el campo.

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 estado remember.
  • Herramientas: editores de XML y Android Studio con @Preview y Layout Inspector.
  • Plataformas: la descripción se ejecuta en cada plataforma (Compose + Kotlin Multiplatform) en vez de traducirse.

Bibliografía y fuentes