Tema 3.5 - Taller integrador¶
La app ya navega, valida, guarda en Room y habla con un servidor. Falta recordar la sesión entre arranques y demostrar que funciona con pruebas.
| Código | Descripción |
|---|---|
| RA 2 | Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas. |
| CE f) | Se han utilizado las clases necesarias para establecer conexiones con almacenes de datos garantizando la persistencia. |
| CE g) | Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas a partir de emuladores. |
| CE i) | Se han documentado los procesos necesarios para el desarrollo de las aplicaciones. |
1. DataStore: la sesión que sobrevive¶
DataStore es la forma recomendada de guardar preferencias (sustituye a SharedPreferences): asíncrona, con Flow y sin bloqueos. Se declara un almacén por nombre y se accede por claves.
val Context.almacenSesion: DataStore<Preferences> by preferencesDataStore(name = "sesion") // un archivo por nombre
val CLAVE_TOKEN = stringPreferencesKey("token") // clave del token dentro del archivo
class SesionRepositorio(private val contexto: Context) { // acceso a la sesión
suspend fun guardar(token: String) { // guarda el token en disco
contexto.almacenSesion.edit { it[CLAVE_TOKEN] = token }
}
fun observar(): Flow<String?> = // lee el token y avisa de cambios
contexto.almacenSesion.data.map { it[CLAVE_TOKEN] }
suspend fun borrar() { // cierra sesión
contexto.almacenSesion.edit { it.remove(CLAVE_TOKEN) }
}
}
preferencesDataStore(name = "sesion") crea un archivo en la app. La clave se declara una sola vez y se usa para leer, escribir y borrar.
fun EscenaSesion() { // 3.5: la sesión sobrevive a cerrar la app
val contexto = LocalContext.current
val repositorio = remember { SesionRepositorio(contexto) } // una sola instancia
val token by repositorio.observar().collectAsState(initial = null) // token vivo
val alcance = rememberCoroutineScope()
Scaffold(topBar = { TopAppBar(title = { Text("IsmaelAgenda · sesión") }) }) { relleno ->
Column(
Modifier.fillMaxSize().padding(relleno).padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Text(
if (token == null) "Sin sesión iniciada" else "Sesión activa",
style = MaterialTheme.typography.headlineSmall
)
Text("Token: ${token ?: "—"}", style = MaterialTheme.typography.bodyMedium)
Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
Button(onClick = {
alcance.launch { repositorio.guardar("token-demo-2026") } // escribe en disco
}) { Text("Iniciar sesión") }
Button(onClick = { alcance.launch { repositorio.borrar() } }) { Text("Cerrar sesión") }
}
Text(
"Cierra la app y vuelve a abrirla: si sigue activa, el token está en disco.",
style = MaterialTheme.typography.bodyMedium
)
}
}
}
observar() devuelve un Flow: si el token cambia desde otra pantalla, esta se entera sola. No hay que refrescar ni preguntar.

Figura 1. Sin sesión: «Sin sesión iniciada» y el token a «—».

Figura 2. Tras pulsar «Iniciar sesión»: el token se escribe en disco y la pantalla lo refleja.

Figura 3. Tras cerrar la app con am force-stop y reabrirla, la sesión sigue activa: el token está en disco (CE f).
2. Pruebas: demostrar que la validación funciona¶
Una prueba unitaria comprueba la lógica sin emulador, en milisegundos. Se ejecuta con gradlew test. Aquí probamos las cuatro reglas del formulario del tema 3.2:
@Test
fun `nombre vacio produce error y no guarda`() { // regla 1
val vm = FormularioViewModel()
vm.cambiarTelefono("956123456") // teléfono correcto
val guardado = vm.guardar() // nombre vacío
assertFalse("no debe guardar sin nombre", guardado)
assertEquals("El nombre no puede estar vacío", vm.estado.value.errorNombre)
}
@Test
fun `telefono de ocho digitos produce error`() { // regla 2
val vm = FormularioViewModel()
vm.cambiarNombre("Nerea Ruiz")
vm.cambiarTelefono("95612345") // 8 dígitos
val guardado = vm.guardar()
assertFalse("no debe guardar con 8 dígitos", guardado)
assertEquals("El teléfono debe tener 9 dígitos", vm.estado.value.errorTelefono)
}
@Test
fun `datos correctos guardan y limpian errores`() { // regla 3
val vm = FormularioViewModel()
vm.cambiarNombre("Nerea Ruiz")
vm.cambiarTelefono("956123456")
val guardado = vm.guardar()
assertTrue("debe guardar con datos correctos", guardado)
assertNull(vm.estado.value.errorNombre)
assertNull(vm.estado.value.errorTelefono)
}
@Test
fun `el telefono filtra lo que no son digitos`() { // regla 4
val vm = FormularioViewModel()
vm.cambiarTelefono("956-12-34-56")
assertEquals("956123456", vm.estado.value.telefono)
}
Resultado real de la ejecución en el proyecto:
<testsuite name="com.example.ismaelagenda.ValidacionTest"
tests="4" skipped="0" failures="0" errors="0" time="0.017">
Una prueba unitaria no necesita emulador ni servidor: si la lógica está en el ViewModel, se prueba en la JVM en 17 milisegundos. Si está dentro del onClick, no se puede probar.
3. Inyección de dependencias¶
En esta unidad el DAO y el repositorio se obtienen con singletons (AgendaDatabase.obtener(contexto)), suficiente para una app de un módulo. En proyectos con varias capas se usa Hilt, que inyecta esas dependencias (@Inject, @HiltViewModel); no se exige en este módulo.
4. Checklist de la práctica de la unidad¶
La entrega documenta con capturas propias (CE g, i):
- Navegación a un detalle con argumento y vuelta atrás (3.1).
- Un formulario que valida y muestra el error bajo el campo (3.2).
- Los datos siguen tras girar el móvil (3.2).
- Una lista leída de Room que sobrevive a cerrar la app (3.3).
- Una petición HTTPS con su estado de carga y su estado de error (3.4).
- La sesión sigue activa tras cerrar y abrir la app (3.5).
- Al menos una prueba unitaria de la validación, con
gradlew testen verde (3.5).
5. Resumen de la unidad¶
| Apartado | Idea que hay que llevarse |
|---|---|
| 3.1 | La ruta es el contrato; el argumento se lee con valor por defecto |
| 3.2 | El estado va en el ViewModel; la validación es lógica de negocio |
| 3.3 | Room: entidad, DAO, base única, Flow y migraciones |
| 3.4 | Retrofit: DTO, suspend, ignoreUnknownKeys y tres estados |
| 3.5 | DataStore para la sesión; las pruebas demuestran la lógica |
Con esto la unidad cubre los criterios a, e, f, g, i y j del RA2.
Lo que tienes que llevarte de este apartado¶
- DataStore se maneja con corrutinas:
editessuspendy no bloquea el hilo de la interfaz. - El token de sesión se guarda en disco, nunca en una variable en memoria: las variables mueren al cerrar la app y la sesión con ellas.
- Si una regla de negocio no se puede probar sin tocar la pantalla, está en la capa equivocada.
- En este módulo todo lo que entregues se demuestra con una captura o con una prueba: las dos son evidencia, la intención no.