Skip to content

4. Capítulo 3 - Introducción a Android y a Jetpack Compose

4.1. Fuentes

Documentación oficial: https://developer.android.com, en particular las páginas “Jetpack Compose” (https://developer.android.com/compose), “Thinking in Compose”, “State and Jetpack Compose”, “Introduction to Activities” y “ViewModel Overview”. Corrutinas de Kotlin: https://kotlinlang.org/docs/coroutines-overview.html

4.2. ¿Qué es una aplicación Android?

Una aplicación Android es un archivo .apk (o .aab para Play Store) que contiene el código compilado, los recursos (íconos, textos, imágenes) y un manifiesto ([AndroidManifest.xml]), su “documento de identidad” ante el sistema: su identificador, los permisos que solicita (acceso a la red, etc.) y la lista de sus pantallas.

Estas pantallas se denominan “activities” ([Activity]). Una activity no la crea el propio programa: la crea el SISTEMA cuando el usuario toca el ícono de la aplicación, y luego llama a sus métodos a lo largo de su ciclo de vida: [onCreate(...)] al crearse, [onPause()] cuando pasa a segundo plano, [onDestroy()] al destruirse... Por lo tanto, en una aplicación Android no existe una función [main()]; esta es la primera diferencia con el [void main()] del cliente Flutter. Este ciclo de vida tiene una consecuencia importante, que se detalla más adelante: una rotación de pantalla DESTRUYE y luego RECREA la activity.

El código Kotlin se compila a bytecode de Java, luego se convierte al formato DEX y lo ejecuta la máquina virtual de Android, [ART] (Android Runtime), que a su vez lo compila a código máquina durante la instalación y durante la ejecución. No hay ningún motor de JavaScript ni de [WebView]: es una aplicación NATIVA, igual que las que vienen preinstaladas en el teléfono. Al igual que Flutter, Jetpack Compose dibuja sus propios componentes (botones, campos de entrada, etc.) en lugar de usar los componentes de interfaz heredados de Android (las [View]), pero lo hace con las propias bibliotecas de interfaz de Android, y no con un motor de renderizado integrado en la aplicación como el de Flutter.

A diferencia de Flutter, este cliente se dirige ÚNICAMENTE a Android: el mismo código no produce una aplicación para iOS, de escritorio ni web. El capítulo 5 explica qué haría falta para lograrlo (Kotlin Multiplatform y Compose Multiplatform).

4.3. El modelo de desarrollo de Compose: todo es una función

Con Jetpack Compose, una interfaz de usuario se describe mediante funciones de Kotlin anotadas con @Composable. Una función @Composable no devuelve nada: EMITE la interfaz llamando a otras funciones @Composable: [Text(...)], [Button(...)], [Column(...)]... La interfaz completa es el árbol de estas llamadas anidadas.

Este es el mismo modelo declarativo de Flutter (“la interfaz es una función del estado”), con una diferencia formal: mientras que Flutter describe cada elemento mediante una CLASE (un [Widget]) cuyo método [build(...)] devuelve un árbol de objetos, Compose usa únicamente funciones. El complemento de compilación de Compose transforma estas funciones para que puedan volver a ejecutarse de forma selectiva cuando cambia el estado que leen: esto se denomina “recomposición”.

Los ajustes de apariencia y de disposición (márgenes, tamaño, alineación, color de fondo, clics, etc.) no son elementos del árbol, como los widgets [Padding] o [Center] de Flutter, sino “modificadores” encadenados y pasados como parámetros: [Modifier.padding(16.dp).fillMaxWidth()]. La unidad [dp] (píxel independiente de la densidad) equivale a los píxeles lógicos de Flutter: 1 dp corresponde a un píxel en una pantalla con una resolución de 160 puntos por pulgada, sin importar la densidad real de la pantalla.

4.4. Estado y recomposición: ni StatefulWidget ni setState

Flutter distingue, desde que se declara la clase, un [StatelessWidget] de un [StatefulWidget] asociado a su clase [State], y exige llamar a [setState(() { ... })] para que un cambio de estado se muestre. Compose no hace nada de esto:

  • una variable local se declara dentro de la propia función: [var clicks by remember { mutableStateOf(0) }];
  • [mutableStateOf(...)] crea un ESTADO OBSERVABLE: Compose registra automáticamente cada función @Composable que lo LEE y vuelve a ejecutar (“recompone”) esas funciones, y solo esas, cuando el valor cambia. No hay nada que llamar después de un cambio: basta con [clicks++] . Así funciona [ref(...)]/[reactive(...)] en Vue.js, y no como funciona [setState(...)];
  • [remember { ... }] almacena un valor de una ejecución de la función a la siguiente. Sin él, el estado se volvería a crear, y se reiniciaría a cero, en cada llamada;
  • [rememberSaveable { ... }] hace lo mismo y, ADEMÁS, conserva el valor cuando la activity se destruye y luego se recrea (rotación de la pantalla; véase más adelante);
  • La palabra clave [by] (delegación de propiedades; véase el curso de Kotlin) permite escribir [clicks] en lugar de [clicks.value].

El mismo mecanismo se aplica a un estado compartido: una clase común cuyas propiedades se declaran como [by mutableStateOf(...)] es observada automáticamente por todas las funciones que leen esas propiedades. Así se escriben los servicios del cliente ([SettingsService], [AuthService], [TranslationsService]; véase el capítulo 4): mientras que la versión Flutter extendía [ChangeNotifier] y llamaba manualmente a [notifyListeners()] después de cada modificación, aquí no hay nada que notificar.

4.5. Compartir el estado: CompositionLocal, el equivalente de provider

Para que un servicio esté disponible en todo un árbol de funciones @Composable sin pasarlo como parámetro de llamada en llamada, Compose ofrece [CompositionLocal]: se declara una “clave” ([val LocalAuth = staticCompositionLocalOf<AuthService> { ... }]), se asigna un valor en la parte superior del árbol ([CompositionLocalProvider(LocalAuth provides auth) { ... }]) y cualquier función descendiente puede LEERLO con [LocalAuth.current]. Este es exactamente el papel del paquete [provider] en la versión Flutter ([MultiProvider] / [context.read<...>()]), de [provide]/[inject] en Vue.js, o de un [Context] de React. Compose no necesita el equivalente de [context.watch<...>()]: la suscripción a los cambios la gestionan los propios estados observables.

4.6. Sin lenguaje de plantillas: condiciones y listas

Como en Flutter, el renderizado condicional y las listas se escriben con construcciones estándar del lenguaje: una expresión [if] de Kotlin para una condición, un bucle [forEach] para una lista. Como una función @Composable es una función como cualquier otra, [if (auth.isLoggedIn) { ... }] EMITE su contenido o no; no existe equivalente a la construcción de listas de widgets ([children: [...]]) ni a la sintaxis “collection if” de Dart.

4.7. Corrutinas: async/await al estilo de Kotlin

Una aplicación Android tiene un único hilo encargado de dibujar la interfaz y responder al usuario: el hilo principal. NUNCA debe esperar; de hecho, Android prohíbe cualquier acceso a la red desde este hilo (excepción [NetworkOnMainThreadException]). Por lo tanto, las llamadas al servidor deben hacerse “en segundo plano”. Kotlin ofrece corrutinas para este fin:

  • una función [suspend] puede pausarse sin bloquear el hilo que la ejecuta; es el equivalente de una función [async] de Dart o de TypeScript. Llamar a una función [suspend] equivale a esperarla: no existe la palabra clave [await]; la espera es implícita;
  • [withContext(Dispatchers.IO) { ... }] ejecuta un bloque en un hilo reservado para E/S y luego vuelve al hilo original con el resultado. Esto es lo que permite usar una biblioteca de red “bloqueante” ([OkHttp]) sin bloquear nunca la interfaz;
  • Una corrutina se lanza con [launch { ... }] DENTRO de un ámbito ([CoroutineScope]) vinculado a un ciclo de vida: [viewModelScope] (las corrutinas de un ViewModel, que se cancelan cuando este se destruye) o [rememberCoroutineScope()] (las de una función @Composable, que se cancelan cuando esta desaparece de la pantalla). Ya no existe el riesgo, como en Flutter, de modificar el estado de una pantalla que ya fue destruida (la prueba [if (mounted)]): la corrutina se cancela junto con ella.

4.8. El ciclo de vida: rotación de la pantalla y ViewModel

De forma predeterminada, cuando el usuario gira su teléfono (o cambia el idioma del sistema, o pasa al modo oscuro), Android DESTRUYE la activity y crea una nueva, adaptada a la nueva configuración. Todo lo que estaba almacenado en la activity anterior, y en los estados de sus funciones @Composable, se pierde. Flutter no tiene este problema: girar la pantalla solo cambia el tamaño de la pantalla.

Android ofrece dos soluciones, y el cliente utiliza ambas:

  • [rememberSaveable { ... }] para los estados pequeños de la interfaz (texto que se está ingresando, médico seleccionado, etc.): Android los guarda antes de la destrucción y los restaura en la nueva activity;
  • un [ViewModel] para el estado y la lógica de una pantalla (listas cargadas desde el servidor, calendario mostrado, etc.): es un objeto que Android CONSERVA entre las recreaciones de la activity y pasa a la nueva. Solo se destruye cuando se sale de la pantalla de forma definitiva. El cliente de este documento coloca en un ViewModel ([AppViewModel]) todo el estado que la versión Flutter guardaba en la clase [_AppRootState].

Los objetos que deben vivir tanto como la aplicación (los servicios) no se crean en la activity ni en un ViewModel, sino en la clase [Application] de la aplicación, que se crea una sola vez al iniciarse el proceso.

4.9. Un primer ejemplo sencillo

A continuación se muestra una pequeña aplicación Compose: un texto, un botón que cuenta los clics y un mensaje que aparece solo después del tercer clic. Para probarla, basta con reemplazar el contenido del archivo [MainActivity.kt] de un proyecto creado con la plantilla [Empty Activity] (véase el capítulo 1), modificando la línea [package].

package fr.rdvmedecins.example

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Counter(name = "RdvMedecins")
            }
        }
    }
}

@Composable
fun Counter(name: String) {
    var clicks by remember { mutableIntStateOf(0) }
    Column(modifier = Modifier.padding(32.dp)) {
        Text("Hello, $name!")
        Button(onClick = { clicks++ }) {
            Text("Clicked $clicks times")
        }
        if (clicks >= 3) {
            Text("Well done!")
        }
    }
}

Analicemos este código:

  • línea 19: [class MainActivity : ComponentActivity()]: la activity, la pantalla que inicia el sistema. [ComponentActivity] es la clase base destinada a Compose;
  • línea 20: [onCreate(...)]: la llama Android cuando se crea la activity. Es el punto de partida del código de la aplicación y reemplaza al [main()] de Flutter;
  • línea 22: [setContent { ... }]: reemplaza el contenido de la pantalla con la interfaz descrita en el bloque; es el equivalente de [runApp(...)] en Flutter;
  • línea 23: [MaterialTheme { ... }]: proporciona el tema Material 3 (colores, tipografía, formas) a todo lo que se invoque dentro del bloque; cumple el papel de [MaterialApp] de Flutter, sin la navegación;
  • líneas 30–31: [@Composable fun Counter(name: String)]: una función `@Composable` con un parámetro. Por convención, su nombre comienza con mayúscula, como el nombre de una clase: representa un elemento de la interfaz;
  • línea 32: [var clicks by remember { mutableIntStateOf(0) }]: un estado local; [mutableIntStateOf] es la variante de [mutableStateOf] optimizada para un entero;
  • línea 33: [Column(modifier = Modifier.padding(32.dp)) { ... }]: dispone a sus hijos uno debajo del otro, con un margen de 32 dp. [Row] los dispondría uno al lado del otro;
  • línea 35: [Button(onClick = { clicks++ })]: el manejador de clic es una simple lambda. [clicks++] modifica el estado: Compose recompone de inmediato [Counter], que LEE este estado, y el texto del botón se actualiza;
  • líneas 38–40: un [if] estándar de Kotlin; el texto “Well done!” solo se emite, y por lo tanto se muestra, a partir del tercer clic.

4.10. Resumen: equivalencias de Flutter a Jetpack Compose

  • [void main()] + [runApp(...)] → activity ([ComponentActivity]) + [setContent { ... }]
  • [StatelessWidget]/[StatefulWidget] (clases) → funciones [@Composable]
  • campos de [State<T>] + [setState(...)] → [remember { mutableStateOf(...) }] (recomposición automática)
  • [ChangeNotifier] + [notifyListeners()] → clase con propiedades [by mutableStateOf(...)] (nada que notificar)
  • paquete [provider] ([MultiProvider], [context.read]/[watch]) → [CompositionLocal] ([CompositionLocalProvider], [LocalXxx.current])
  • parámetros del constructor de un widget (entradas), funciones pasadas como parámetros (salidas) → parámetros de la función @Composable, lambdas
  • [build(BuildContext)] → el cuerpo de la función @Composable
  • widgets [Padding], [Center], [SizedBox]... → modificadores ([Modifier.padding(...)]...)
  • [Future<T>] + [async]/[await] → funciones [suspend] + corrutinas
  • paquete [http] → biblioteca [OkHttp]
  • constructores [fromJson(...)] escritos a mano → clases [@Serializable] ([kotlinx.serialization])
  • paquete [shared_preferences] → el [SharedPreferences] de Android (la API de la que el paquete de Flutter tomó su nombre)
  • [showDialog(...)] → una función [AlertDialog(...)] que se muestra mientras un estado lo requiera
  • [LayoutBuilder] / [MediaQuery] → [BoxWithConstraints] / [LocalConfiguration]
  • [pubspec.yaml] + [flutter pub get] → [build.gradle.kts] + [libs.versions.toml] + Gradle
  • Sin equivalente en Flutter: [ViewModel] y [rememberSaveable], provocados por la recreación de la activity al girar la pantalla