Saltar a contenido

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.

🟢 Leyenda de repaso obligatorio: los textos con este fondo verde son imprescindibles y entran en todas las evaluaciones del módulo.
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.

Pantalla de sesión sin sesión iniciada y token vacío

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

Pantalla de sesión con la sesión activa y el token token-demo-2026

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

La misma pantalla con la sesión activa después de cerrar y volver a abrir la aplicación

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:

BUILD SUCCESSFUL in 22s
<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 test en 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: edit es suspend y 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.

Presentación