Avisos: la sesión es un dato sensible

git clone https://github.com/rpversontec/practica-6-avisos.git
cd practica-6-avisos

{
  "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhMDEyMzQ1NjciLCJyb2wiOiJhbHVtbm8iLCJpYXQiOjE3OTAwMDgyOTQsImV4cCI6MTc5MDAwODU5NH0.FnxArFPiQyzNMp0HsoEHkyouRuvcE45mdBdmpM-zgzc",
  "refreshToken": "Z_QCTplenFL24LVVToFs2y9iumaETBfSYK_pAKi_rEU",
  "tokenType": "Bearer",
  "expiresIn": 300,
  "usuario": "a01234567",
  "rol": "alumno"
}

interface AvisosApi {

    // ---- sin token: son las llamadas que te dan uno
    @POST("auth/register")
    suspend fun register(@Body body: Credenciales): TokensDto

    @POST("auth/login")
    suspend fun login(@Body body: Credenciales): TokensDto

    @POST("auth/refresh")
    suspend fun refresh(@Body body: RefreshBody): TokensDto

    @POST("auth/logout")
    suspend fun logout(@Body body: RefreshBody)

    // ---- con token: el `Authorization: Bearer …` lo pone el interceptor
    @GET("auth/me")
    suspend fun me(): MeDto

    @GET("avisos")
    suspend fun getAvisos(): List<AvisoDto>

    @POST("avisos")
    suspend fun crearAviso(@Body body: NuevoAvisoBody): AvisoDto

    @DELETE("avisos/{id}")
    suspend fun borrarAviso(@Path("id") id: Int): Response<Unit>
}

data class Sesion(
    val usuario: String,
    val rol: Rol,
    val accessToken: String,
    val refreshToken: String,
    val expiraEn: Long
) {
    fun segundosRestantes(ahora: Long = System.currentTimeMillis() / 1000): Long = expiraEn - ahora
}

package mx.tec.avisos.data

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Credenciales
import mx.tec.avisos.data.remote.toSesion
import mx.tec.avisos.domain.Sesion

/**
 * La única puerta a la sesión. Hacia arriba habla de `Sesion`; hacia abajo,
 * del servidor.
 *
 * Fíjate en que ninguna función devuelve la sesión: la dejan en `_sesion`, y
 * quien quiera saber si hay una se suscribe a `sesion`. Nadie tiene que
 * "avisar" que entró o salió.
 *
 * Por ahora vive SOLO EN MEMORIA: se va con el proceso. Ese es el bug que el
 * Bloque B arregla.
 */
class SesionRepository(private val api: AvisosApi) {

    private val _sesion = MutableStateFlow<Sesion?>(null)

    val sesion: Flow<Sesion?> = _sesion

    suspend fun entrar(usuario: String, password: String) {
        _sesion.value = api.login(Credenciales(usuario.trim().lowercase(), password)).toSesion()
    }

    suspend fun registrar(usuario: String, password: String, codigoProfesor: String) {
        val credenciales = Credenciales(
            usuario = usuario.trim().lowercase(),
            password = password,
            codigoProfesor = codigoProfesor.trim().ifEmpty { null }
        )
        _sesion.value = api.register(credenciales).toSesion()
    }

    suspend fun salir() {
        _sesion.value = null
    }

    /** Para la capa de red, que corre en su propio hilo y no puede suspender. */
    fun tokenActual(): String? = _sesion.value?.accessToken
}

package mx.tec.avisos.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch
import mx.tec.avisos.data.SesionRepository
import mx.tec.avisos.domain.CredencialesValidator
import retrofit2.HttpException
import java.io.IOException

/**
 * Lo que el usuario lleva tecleado en el login. La contraseña vive aquí solo
 * mientras se escribe: al entrar se manda y se olvida. Nunca se guarda.
 */
data class LoginUiState(
    val usuario: String = "",
    val password: String = "",
    val codigoProfesor: String = "",
    val modoRegistro: Boolean = false,
    val enviando: Boolean = false,
    val error: String? = null
) {
    val puedeEnviar: Boolean =
        CredencialesValidator.sonValidas(usuario, password) && !enviando
}

class LoginViewModel(private val repository: SesionRepository) : ViewModel() {

    var uiState by mutableStateOf(LoginUiState())
        private set

    fun onUsuarioChange(texto: String) {
        uiState = uiState.copy(usuario = texto, error = null)
    }

    fun onPasswordChange(texto: String) {
        uiState = uiState.copy(password = texto, error = null)
    }

    fun onCodigoProfesorChange(texto: String) {
        uiState = uiState.copy(codigoProfesor = texto, error = null)
    }

    fun alternarModo() {
        uiState = uiState.copy(modoRegistro = !uiState.modoRegistro, error = null)
    }

    /**
     * No recibe un `alTerminar`: cuando el repositorio guarda la sesión, el
     * `SesionViewModel` la ve y la app cambia de pantalla sola.
     */
    fun enviar() {
        if (!uiState.puedeEnviar) return
        viewModelScope.launch {
            uiState = uiState.copy(enviando = true, error = null)
            try {
                if (uiState.modoRegistro) {
                    repository.registrar(uiState.usuario, uiState.password, uiState.codigoProfesor)
                } else {
                    repository.entrar(uiState.usuario, uiState.password)
                }
                // Se limpia todo: la contraseña no se queda en memoria más de lo necesario.
                uiState = LoginUiState()
            } catch (e: IOException) {
                uiState = uiState.copy(enviando = false, error = "No hay conexión. Revisa tu internet.")
            } catch (e: HttpException) {
                uiState = uiState.copy(enviando = false, error = mensajeDe(e))
            }
        }
    }
}

package mx.tec.avisos.ui.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import mx.tec.avisos.data.SesionRepository
import mx.tec.avisos.domain.Sesion

/**
 * Lo que la app sabe de la sesión en este instante. Son tres casos y no dos:
 * `Cargando` es "todavía no leí el archivo", que no es lo mismo que "nadie ha
 * entrado". Sin él, la app enseñaría el login medio segundo a quien ya tenía
 * sesión, y luego la lista.
 */
sealed interface SesionEstado {
    data object Cargando : SesionEstado
    data object Anonimo : SesionEstado
    data class Activa(val sesion: Sesion) : SesionEstado
}

/**
 * El ViewModel de más arriba: decide qué árbol de pantallas existe. No tiene
 * ninguna función de "entrar": la sesión la escribe el repositorio y este
 * ViewModel solo la observa.
 */
class SesionViewModel(private val repository: SesionRepository) : ViewModel() {

    val estado: StateFlow<SesionEstado> = repository.sesion
        .map { sesion -> if (sesion == null) SesionEstado.Anonimo else SesionEstado.Activa(sesion) }
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(ESPERA_MS),
            initialValue = SesionEstado.Cargando
        )

    fun salir() {
        viewModelScope.launch { repository.salir() }
    }

    private companion object {
        const val ESPERA_MS = 5_000L
    }
}

        initializer { SesionViewModel(avisosApplication().container.sesionRepository) }

        initializer { LoginViewModel(avisosApplication().container.sesionRepository) }

        initializer { AvisosViewModel(avisosApplication().container.avisosRepository) }

        initializer { PublicarViewModel(avisosApplication().container.avisosRepository) }

package mx.tec.avisos.data.remote

import okhttp3.Interceptor
import okhttp3.Response

/**
 * Firma cada petición con el token de acceso, si hay uno.
 *
 * Recibe una función y no el repositorio: la capa de red no necesita saber
 * dónde vive la sesión, solo cómo pedir el token. Corre en un hilo de OkHttp,
 * nunca en el principal, así que la función puede bloquear.
 */
class AuthInterceptor(private val token: () -> String?) : Interceptor {

    override fun intercept(chain: Interceptor.Chain): Response {
        val actual = token() ?: return chain.proceed(chain.request())
        val firmada = chain.request().newBuilder()
            .header("Authorization", "Bearer $actual")
            .build()
        return chain.proceed(firmada)
    }
}

package mx.tec.avisos

import android.app.Application
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.SesionRepository
import mx.tec.avisos.data.remote.AuthInterceptor
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Network

/**
 * El contenedor de dependencias: quién construye a quién, en un solo lugar.
 *
 * Hay un ciclo aparente —la API necesita el token, que está en el repositorio
 * de sesión, que necesita la API— y se rompe con dos cosas: `by lazy`, y que
 * el interceptor recibe una FUNCIÓN que pide el token, no el repositorio.
 * Nadie llama a esa función hasta que sale la primera petición.
 */
class AppContainer {

    private val api: AvisosApi by lazy {
        Network.crearApi(interceptor = AuthInterceptor { sesionRepository.tokenActual() })
    }

    val sesionRepository: SesionRepository by lazy { SesionRepository(api) }

    val avisosRepository: AvisosRepository by lazy { AvisosRepository(api) }
}

/** Vive tanto como el proceso. Declarada en el manifiesto con `android:name`. */
class AvisosApplication : Application() {

    lateinit var container: AppContainer
        private set

    override fun onCreate() {
        super.onCreate()
        container = AppContainer()
    }
}

package mx.tec.avisos.ui.navigation

import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import mx.tec.avisos.ui.components.CargandoView
import mx.tec.avisos.ui.screens.LoginScreen
import mx.tec.avisos.ui.state.AppViewModelProvider
import mx.tec.avisos.ui.state.LoginViewModel
import mx.tec.avisos.ui.state.SesionEstado
import mx.tec.avisos.ui.state.SesionViewModel

/**
 * La raíz de la app. No es un NavHost: es un `when` sobre la sesión.
 *
 * Sin sesión, lo único que existe es el login — ni siquiera hay un NavHost al
 * que navegar. Con sesión, existe el tablón. Y cuando la sesión desaparece
 * (salir, o un refresh que el servidor rechazó), el árbol entero del tablón se
 * va y vuelve el login, sin que nadie llame a `navigate`.
 */
@Composable
fun AvisosApp() {
    val sesionViewModel: SesionViewModel = viewModel(factory = AppViewModelProvider.Factory)
    val estado by sesionViewModel.estado.collectAsStateWithLifecycle()

    when (val actual = estado) {
        SesionEstado.Cargando -> CargandoView()

        SesionEstado.Anonimo -> {
            val loginViewModel: LoginViewModel = viewModel(factory = AppViewModelProvider.Factory)
            LoginScreen(
                uiState = loginViewModel.uiState,
                onUsuarioChange = loginViewModel::onUsuarioChange,
                onPasswordChange = loginViewModel::onPasswordChange,
                onCodigoProfesorChange = loginViewModel::onCodigoProfesorChange,
                onAlternarModo = loginViewModel::alternarModo,
                onEnviar = loginViewModel::enviar
            )
        }

        is SesionEstado.Activa -> AvisosNavHost(
            sesion = actual.sesion,
            onSalir = sesionViewModel::salir
        )
    }
}

[versions]
datastore = "1.2.1"

[libraries]
androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }

    implementation(libs.androidx.datastore.preferences)

package mx.tec.avisos.data.local

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.longPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import mx.tec.avisos.domain.Rol
import mx.tec.avisos.domain.Sesion

// Un solo archivo para toda la app: files/datastore/sesion.preferences_pb.
// La extensión de Context garantiza una única instancia por proceso.
private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "sesion")

/**
 * Dónde vive la sesión cuando la app no está corriendo.
 *
 * DataStore escribe en la carpeta privada de la app: ninguna otra app puede
 * leerla, y el sistema la cifra en disco.
 */
class SesionStore(private val context: Context) {

    private object Llaves {
        val USUARIO = stringPreferencesKey("usuario")
        val ROL = stringPreferencesKey("rol")
        val ACCESS = stringPreferencesKey("access_token")
        val REFRESH = stringPreferencesKey("refresh_token")
        val EXPIRA_EN = longPreferencesKey("expira_en")
    }

    /** Emite la sesión guardada, y vuelve a emitir cada vez que cambia. `null` = nadie ha entrado. */
    val sesion: Flow<Sesion?> = context.dataStore.data.map { prefs ->
        val usuario = prefs[Llaves.USUARIO] ?: return@map null
        val access = prefs[Llaves.ACCESS] ?: return@map null
        val refresh = prefs[Llaves.REFRESH] ?: return@map null
        Sesion(
            usuario = usuario,
            rol = Rol.de(prefs[Llaves.ROL] ?: "alumno"),
            accessToken = access,
            refreshToken = refresh,
            expiraEn = prefs[Llaves.EXPIRA_EN] ?: 0L
        )
    }

    suspend fun guardar(sesion: Sesion) {
        context.dataStore.edit { prefs ->
            prefs[Llaves.USUARIO] = sesion.usuario
            prefs[Llaves.ROL] = sesion.rol.name.lowercase()
            prefs[Llaves.ACCESS] = sesion.accessToken
            prefs[Llaves.REFRESH] = sesion.refreshToken
            prefs[Llaves.EXPIRA_EN] = sesion.expiraEn
        }
    }

    suspend fun borrar() {
        context.dataStore.edit { it.clear() }
    }
}

package mx.tec.avisos.data

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import mx.tec.avisos.data.local.SesionStore
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Credenciales
import mx.tec.avisos.data.remote.toSesion
import mx.tec.avisos.domain.Sesion

/**
 * La única puerta a la sesión. Hacia arriba habla de `Sesion`; hacia abajo,
 * del servidor y del archivo donde se guarda.
 *
 * Fíjate en que ninguna función devuelve la sesión: la escriben en el store, y
 * el store la emite por `sesion`. Quien quiera saber si hay sesión se suscribe;
 * nadie tiene que "avisar" que entró o salió.
 */
class SesionRepository(private val api: AvisosApi, private val store: SesionStore) {

    val sesion: Flow<Sesion?> = store.sesion

    suspend fun entrar(usuario: String, password: String) {
        store.guardar(api.login(Credenciales(usuario.trim().lowercase(), password)).toSesion())
    }

    suspend fun registrar(usuario: String, password: String, codigoProfesor: String) {
        val credenciales = Credenciales(
            usuario = usuario.trim().lowercase(),
            password = password,
            codigoProfesor = codigoProfesor.trim().ifEmpty { null }
        )
        store.guardar(api.register(credenciales).toSesion())
    }

    suspend fun salir() {
        store.borrar()
    }

    /** Para la capa de red, que corre en su propio hilo y no puede suspender. */
    fun tokenActual(): String? = runBlocking { store.sesion.first() }?.accessToken
}

package mx.tec.avisos

import android.app.Application
import android.content.Context
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.SesionRepository
import mx.tec.avisos.data.local.SesionStore
import mx.tec.avisos.data.remote.AuthInterceptor
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Network

/**
 * El contenedor de dependencias: quién construye a quién, en un solo lugar.
 *
 * Hay un ciclo aparente —la API necesita el token, que está en el repositorio
 * de sesión, que necesita la API— y se rompe con dos cosas: `by lazy`, y que
 * el interceptor recibe una FUNCIÓN que pide el token, no el repositorio.
 * Nadie llama a esa función hasta que sale la primera petición.
 */
class AppContainer(context: Context) {

    private val sesionStore = SesionStore(context)

    private val api: AvisosApi by lazy {
        Network.crearApi(interceptor = AuthInterceptor { sesionRepository.tokenActual() })
    }

    val sesionRepository: SesionRepository by lazy { SesionRepository(api, sesionStore) }

    val avisosRepository: AvisosRepository by lazy { AvisosRepository(api) }
}

/** Vive tanto como el proceso. Declarada en el manifiesto con `android:name`. */
class AvisosApplication : Application() {

    lateinit var container: AppContainer
        private set

    override fun onCreate() {
        super.onCreate()
        container = AppContainer(this)
    }
}

adb shell run-as mx.tec.avisos cat files/datastore/sesion.preferences_pb

usuario  a01234567   rol  alumno   access_token  eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhMDEy…
refresh_token  Z_QCTplenFL24LVVToFs2y9iumaETBfSYK_pAKi_rEU   expira_en …

level = HttpLoggingInterceptor.Level.HEADERS

--> GET https://startdroid.com/api/avisos
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhMDEy…

    fun crearApi(interceptor: Interceptor? = null, authenticator: Authenticator? = null): AvisosApi {
        val logging = HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BASIC
            // Con Level.HEADERS o BODY, sin esta línea el token sale en el Logcat.
            redactHeader("Authorization")
        }

    <application
        android:name=".AvisosApplication"
        android:allowBackup="false"
        android:label="Avisos"
        android:supportsRtl="true"
        android:theme="@style/Theme.Avisos">

/**
 * Cifra y descifra texto con una llave que vive en el Android Keystore.
 *
 * Lo importante no es el AES: es DÓNDE está la llave. El Keystore la genera
 * y la guarda en hardware (o en un proceso aparte del sistema), y nunca la
 * entrega: tu app le pide "cifra esto" y recibe el resultado. Ni tu propio
 * código puede leer los bytes de la llave — y por eso tampoco puede leerlos
 * quien se robe el archivo de datos.
 *
 * Es, en 40 líneas, lo que hacía `EncryptedSharedPreferences` antes de que
 * Google la retirara.
 */
class Cifrador(private val alias: String = "sesion") {

    private val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }

    /** La llave se crea una sola vez, la primera vez que hace falta. */
    private fun llave(): SecretKey = synchronized(this) {
        (keyStore.getEntry(alias, null) as? KeyStore.SecretKeyEntry)?.secretKey?.let { return it }

        val spec = KeyGenParameterSpec.Builder(
            alias,
            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
        )
            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
            .setKeySize(256)
            .build()

        KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
            .apply { init(spec) }
            .generateKey()
    }

    /** Texto → base64 de (iv + cifrado). El iv cambia en cada llamada; va pegado al frente. */
    fun cifrar(texto: String): String {
        val cipher = Cipher.getInstance(TRANSFORMACION)
        cipher.init(Cipher.ENCRYPT_MODE, llave())
        val cifrado = cipher.doFinal(texto.toByteArray(Charsets.UTF_8))
        return Base64.encodeToString(cipher.iv + cifrado, Base64.NO_WRAP)
    }

/**
 * Dónde vive la sesión cuando la app no está corriendo.
 *
 * DataStore escribe en la carpeta privada de la app: ninguna otra app puede
 * leerla, y el sistema la cifra en disco. Los dos tokens van además cifrados
 * con una llave del Keystore, para que el archivo por sí solo no sirva de nada.
 */
class SesionStore(private val context: Context, private val cifrador: Cifrador) {

    private object Llaves {
        val USUARIO = stringPreferencesKey("usuario")
        val ROL = stringPreferencesKey("rol")
        val ACCESS = stringPreferencesKey("access_token")
        val REFRESH = stringPreferencesKey("refresh_token")
        val EXPIRA_EN = longPreferencesKey("expira_en")
    }

    /** Emite la sesión guardada, y vuelve a emitir cada vez que cambia. `null` = nadie ha entrado. */
    val sesion: Flow<Sesion?> = context.dataStore.data.map { prefs ->
        val usuario = prefs[Llaves.USUARIO] ?: return@map null
        val access = prefs[Llaves.ACCESS]?.let(cifrador::descifrar) ?: return@map null
        val refresh = prefs[Llaves.REFRESH]?.let(cifrador::descifrar) ?: return@map null
        Sesion(
            usuario = usuario,
            rol = Rol.de(prefs[Llaves.ROL] ?: "alumno"),
            accessToken = access,
            refreshToken = refresh,
            expiraEn = prefs[Llaves.EXPIRA_EN] ?: 0L
        )
    }

    suspend fun guardar(sesion: Sesion) {
        context.dataStore.edit { prefs ->
            prefs[Llaves.USUARIO] = sesion.usuario
            prefs[Llaves.ROL] = sesion.rol.name.lowercase()
            prefs[Llaves.ACCESS] = cifrador.cifrar(sesion.accessToken)
            prefs[Llaves.REFRESH] = cifrador.cifrar(sesion.refreshToken)
            prefs[Llaves.EXPIRA_EN] = sesion.expiraEn
        }
    }

    private val sesionStore = SesionStore(context, Cifrador())

adb shell run-as mx.tec.avisos cat files/datastore/sesion.preferences_pb

usuario  a01234567   rol  alumno
access_token  rYORg7+98OjL56LCLJHyfB/n1zpIS/N/O9u5XXOnHPb9eM1uDfo2R9Lk5Hhfo9rKJoAwP+…
refresh_token  vPR+18whpxe5XV4PnLZlV5mZeyTbHapWj7+FeU2s4pvPQxh6CzBPgep5ttpIvM15Czbft3vCx5adYrE3upCaO2i/Ej3igiM=

    /** La regla de autorización, vista desde el cliente. El servidor la repite. */
    val puedePublicar: Boolean get() = rol == Rol.PROFESOR

        floatingActionButton = {
            if (sesion.puedePublicar) {
                FloatingActionButton(onClick = onPublicar) {
                    Icon(Icons.Default.Add, contentDescription = "Publicar aviso")
                }
            }
        }

git switch -c experimento-c2

    // EXPERIMENTO C2: la app "decide" que todos pueden publicar. ¿Y el servidor?
    val puedePublicar: Boolean get() = true

git add -A ; git commit -m "experimento-c2: lo que observé"
git switch main

package mx.tec.avisos.data.remote

import okhttp3.Authenticator
import okhttp3.Request
import okhttp3.Response
import okhttp3.Route

/**
 * OkHttp lo llama SOLO cuando una respuesta trae 401. Su trabajo: conseguir
 * un token nuevo y devolver la misma petición firmada otra vez — o `null`,
 * que significa "ríndete y entrega el 401 tal cual".
 *
 * Tres guardas, y las tres evitan un ciclo infinito:
 *   1. Si la petición no llevaba token, el 401 no es por el token (un login
 *      con la contraseña mal, por ejemplo). No hay nada que refrescar.
 *   2. Si la petición era el propio refresh, ya no hay a quién pedirle.
 *   3. Si ya se reintentó una vez, no se insiste.
 */
class TokenAuthenticator(
    private val tokenActual: () -> String?,
    private val refrescar: () -> String?
) : Authenticator {

    override fun authenticate(route: Route?, response: Response): Request? {
        val enviado = response.request.header("Authorization")?.removePrefix("Bearer ") ?: return null
        if (response.request.url.encodedPath.endsWith("/auth/refresh")) return null
        if (response.priorResponse != null) return null

        // Una sola renovación a la vez: si dos peticiones fallan juntas, la
        // segunda espera aquí y al salir encuentra el token que trajo la primera.
        val nuevo = synchronized(this) {
            val vigente = tokenActual()
            if (vigente != null && vigente != enviado) vigente else refrescar()
        } ?: return null

        return response.request.newBuilder()
            .header("Authorization", "Bearer $nuevo")
            .build()
    }
}

    fun refrescarToken(): String? = runBlocking { refrescar() }

    /**
     * Cambia el refresh token por un par nuevo. Si el servidor dice que ese
     * refresh ya no sirve, la sesión se acabó: se borra, y la UI vuelve sola
     * al login porque el Flow emite null.
     */
    private suspend fun refrescar(): String? {
        val actual = store.sesion.first() ?: return null
        return try {
            val nueva = api.refresh(RefreshBody(actual.refreshToken)).toSesion()
            store.guardar(nueva)
            nueva.accessToken
        } catch (e: HttpException) {
            if (e.code() == 401) store.borrar()
            null
        } catch (e: IOException) {
            // Sin red: la sesión sigue guardada, solo falló este intento.
            null
        }
    }

import mx.tec.avisos.data.remote.RefreshBody
import retrofit2.HttpException
import java.io.IOException

package mx.tec.avisos

import android.app.Application
import android.content.Context
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.SesionRepository
import mx.tec.avisos.data.local.Cifrador
import mx.tec.avisos.data.local.SesionStore
import mx.tec.avisos.data.remote.AuthInterceptor
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Network
import mx.tec.avisos.data.remote.TokenAuthenticator

/**
 * El contenedor de dependencias: quién construye a quién, en un solo lugar.
 *
 * Hay un ciclo aparente —la API necesita el token, que está en el repositorio
 * de sesión, que necesita la API— y se rompe con dos cosas: `by lazy`, y que
 * el interceptor recibe una FUNCIÓN que pide el token, no el repositorio.
 * Nadie llama a esa función hasta que sale la primera petición.
 */
class AppContainer(context: Context) {

    private val sesionStore = SesionStore(context, Cifrador())

    private val api: AvisosApi by lazy {
        Network.crearApi(
            interceptor = AuthInterceptor { sesionRepository.tokenActual() },
            authenticator = TokenAuthenticator(
                tokenActual = { sesionRepository.tokenActual() },
                refrescar = { sesionRepository.refrescarToken() }
            )
        )
    }

    val sesionRepository: SesionRepository by lazy { SesionRepository(api, sesionStore) }

    val avisosRepository: AvisosRepository by lazy { AvisosRepository(api) }
}

/** Vive tanto como el proceso. Declarada en el manifiesto con `android:name`. */
class AvisosApplication : Application() {

    lateinit var container: AppContainer
        private set

    override fun onCreate() {
        super.onCreate()
        container = AppContainer(this)
    }
}

--> GET https://startdroid.com/api/avisos
--> POST https://startdroid.com/api/auth/refresh (62-byte body)
<-- 200 https://startdroid.com/api/auth/refresh (301ms)
<-- 200 https://startdroid.com/api/avisos (761ms)

--> GET https://startdroid.com/api/avisos
--> POST https://startdroid.com/api/auth/refresh (62-byte body)
<-- 401 https://startdroid.com/api/auth/refresh (481ms, 154-byte body)
<-- 401 https://startdroid.com/api/avisos (808ms, 122-byte body)

adb shell run-as mx.tec.avisos wc -c files/datastore/sesion.preferences_pb

    /** Primero se borra lo local: aunque no haya red, salir siempre funciona. */
    suspend fun salir() {
        val actual = store.sesion.first()
        store.borrar()
        if (actual != null) {
            try {
                api.logout(RefreshBody(actual.refreshToken))
            } catch (e: IOException) {
                // Sin red no se avisa al servidor; el refresh token expira solo en 7 días.
            } catch (e: HttpException) {
                // Ya estaba revocado, o nunca existió. Salir igual se logró.
            }
        }
    }

git commit -m "checkpoint d1: el token se renueva solo" -m "Co-Authored-By: Claude <noreply@anthropic.com>"

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 . eyJzdWIiOiJhMDEyMzQ1NjciLCJyb2wiOi… . FnxArFPiQyzNMp0Hso…
        header                             payload                            firma