Avisos en vivo: el servidor te avisa, con la app abierta o cerrada

git clone https://github.com/rpversontec/practica-8-avisos-en-vivo.git
cd practica-8-avisos-en-vivo

: conectado como a01234567, desde el aviso 0

id: 1
event: aviso
data: {"id":1,"titulo":"Bienvenidos al tablón","cuerpo":"…","autor":"profesor","createdAt":"2026-09-21 16:51:55"}

id: 2
event: aviso
data: {…}

: ping

adb shell dumpsys deviceidle

package mx.tec.avisos.data.remote

import kotlinx.serialization.json.Json
import okhttp3.Authenticator
import okhttp3.Interceptor
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.kotlinx.serialization.asConverterFactory

object Network {

    const val BASE_URL = "https://startdroid.com/api/"

    private val json = Json {
        ignoreUnknownKeys = true
        explicitNulls = false
    }

    /**
     * El cliente HTTP. El interceptor firma cada petición con el token; el
     * authenticator reacciona cuando el servidor responde 401.
     *
     * Es UNO para toda la app: Retrofit lo usa para las peticiones normales y
     * `AvisosStream` para la conexión larga. Así el stream también va firmado
     * y también se renueva solo.
     */
    fun crearCliente(interceptor: Interceptor? = null, authenticator: Authenticator? = null): OkHttpClient {
        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")
        }

        return OkHttpClient.Builder().apply {
            if (interceptor != null) addInterceptor(interceptor)
            if (authenticator != null) authenticator(authenticator)
            // El de log va al final, para que vea la petición ya firmada.
            addInterceptor(logging)
        }.build()
    }

    /** Retrofit: petición y respuesta. Para lo que se queda abierto está `AvisosStream`. */
    fun crearApi(cliente: OkHttpClient): AvisosApi =
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(cliente)
            .addConverterFactory(json.asConverterFactory("application/json".toMediaType()))
            .build()
            .create(AvisosApi::class.java)
}

    // Un solo cliente: lo comparten Retrofit y el stream, para que los dos
    // vayan firmados y los dos se renueven solos.
    private val cliente: OkHttpClient by lazy {
        Network.crearCliente(
            interceptor = AuthInterceptor { sesionRepository.tokenActual() },
            authenticator = TokenAuthenticator(
                tokenActual = { sesionRepository.tokenActual() },
                refrescar = { sesionRepository.refrescarToken() }
            )
        )
    }

    private val api: AvisosApi by lazy { Network.crearApi(cliente) }

    /** `desde`: solo los avisos con id mayor. Con 0, todos. Lo usa el worker para no bajar el tablón entero. */
    @GET("avisos")
    suspend fun getAvisos(@Query("desde") desde: Int = 0): List<AvisoDto>

okhttp-sse = { group = "com.squareup.okhttp3", name = "okhttp-sse", version.ref = "okhttp" }

    implementation(libs.okhttp.sse)

package mx.tec.avisos.data.remote

import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.emitAll
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.onEach
import kotlinx.serialization.json.Json
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.sse.EventSource
import okhttp3.sse.EventSourceListener
import okhttp3.sse.EventSources
import java.util.concurrent.TimeUnit

/**
 * La conexión que se queda abierta: `GET /avisos/stream`, Server-Sent Events.
 *
 * Retrofit no sirve aquí. Retrofit es "una petición, una respuesta"; esto es
 * una respuesta que nunca termina y va soltando eventos. Por eso se habla
 * directo con OkHttp, con el MISMO cliente: el interceptor firma la petición
 * y el authenticator la renueva si el token venció.
 */
class AvisosStream(cliente: OkHttpClient) {

    private val json = Json { ignoreUnknownKeys = true }

    // El mismo cliente (interceptor, authenticator), pero con más paciencia:
    // el readTimeout por omisión es de 10 s, y una conexión SSE puede pasar
    // 15 s sin decir nada entre un `: ping` y el siguiente. Con 10 s, OkHttp
    // la daría por muerta y reconectaría en bucle.
    private val clienteLargo: OkHttpClient = cliente.newBuilder()
        .readTimeout(ESPERA_SIN_DATOS_S, TimeUnit.SECONDS)
        .build()

    /**
     * Un Flow de avisos nuevos, a partir de `desde`.
     *
     * Se conecta cuando alguien lo recolecta y se cierra cuando lo cancelan:
     * no existe una conexión sin nadie escuchando. Si el servidor cuelga —lo
     * hace a propósito cuando el token expira— espera unos segundos y vuelve
     * a conectar desde el último aviso que sí llegó.
     */
    fun observar(desde: Int): Flow<AvisoDto> = flow {
        var ultimo = desde
        while (true) {
            emitAll(conectar(ultimo).onEach { ultimo = it.id })
            delay(ESPERA_MS)
        }
    }

    /** Una conexión. Termina —sin error— cuando el servidor la cierra o la red se cae. */
    private fun conectar(desde: Int): Flow<AvisoDto> = callbackFlow {
        val request = Request.Builder()
            .url("${Network.BASE_URL}avisos/stream")
            // El estándar de SSE: "mándame lo que pasó después de este id".
            .header("Last-Event-ID", desde.toString())
            .build()

        val listener = object : EventSourceListener() {
            override fun onEvent(eventSource: EventSource, id: String?, type: String?, data: String) {
                if (type == "aviso") trySend(json.decodeFromString<AvisoDto>(data))
            }

            override fun onClosed(eventSource: EventSource) {
                close()
            }

            override fun onFailure(eventSource: EventSource, t: Throwable?, response: Response?) {
                // Sin red, o el servidor colgó. No es fatal: el Flow de arriba reconecta.
                close()
            }
        }

        val fuente = EventSources.createFactory(clienteLargo).newEventSource(request, listener)
        awaitClose { fuente.cancel() }
    }

    private companion object {
        const val ESPERA_MS = 5_000L
        const val ESPERA_SIN_DATOS_S = 30L
    }
}

package mx.tec.avisos.data

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.AvisosStream
import mx.tec.avisos.data.remote.NuevoAvisoBody
import mx.tec.avisos.data.remote.toDomain
import mx.tec.avisos.domain.Aviso

/**
 * El tablón. No sabe nada de tokens: el interceptor firma las peticiones por
 * debajo, y si el servidor dice 401 o 403, la excepción sube tal cual.
 *
 * Dos formas de leer, y no compiten: `obtener()` es una foto; `observar()`
 * es quedarse mirando.
 */
class AvisosRepository(private val api: AvisosApi, private val stream: AvisosStream) {

    suspend fun obtener(desde: Int = 0): List<Aviso> = api.getAvisos(desde).map { it.toDomain() }

    /** Cada aviso nuevo, conforme llega. Se cierra cuando quien lo recolecta se va. */
    fun observar(desde: Int): Flow<Aviso> = stream.observar(desde).map { it.toDomain() }

    suspend fun publicar(titulo: String, cuerpo: String): Aviso =
        api.crearAviso(NuevoAvisoBody(titulo.trim(), cuerpo.trim())).toDomain()
}

    val avisosRepository: AvisosRepository by lazy { AvisosRepository(api, AvisosStream(cliente)) }

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.Job
import kotlinx.coroutines.launch
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.domain.Aviso
import retrofit2.HttpException
import java.io.IOException

/**
 * La lista del tablón. Carga una vez y después se queda escuchando: cada
 * aviso nuevo que empuja el servidor entra a la lista sin que nadie recargue.
 *
 * Escuchar cuesta una conexión abierta, y una conexión abierta sin nadie
 * mirando es batería tirada. Por eso `cargar()` la abre y `dejarDeEscuchar()`
 * la cierra, y quien llama a las dos es la pantalla, según su ciclo de vida.
 */
class AvisosViewModel(private val repository: AvisosRepository) : ViewModel() {

    var avisos by mutableStateOf<UiState<List<Aviso>>>(UiState.Cargando)
        private set

    private var escucha: Job? = null

    /** Carga el tablón y, si cargó, se queda escuchando avisos nuevos hasta que lo cancelen. */
    fun cargar() {
        escucha?.cancel()
        escucha = viewModelScope.launch {
            avisos = UiState.Cargando
            val lista = try {
                repository.obtener()
            } catch (e: IOException) {
                avisos = UiState.Error("No hay conexión. Revisa tu internet.")
                return@launch
            } catch (e: HttpException) {
                avisos = UiState.Error(mensajeDe(e))
                return@launch
            }
            avisos = UiState.Exito(lista)

            repository.observar(desde = lista.maxOfOrNull { it.id } ?: 0).collect { nuevo ->
                val actual = (avisos as? UiState.Exito)?.datos ?: emptyList()
                if (actual.none { it.id == nuevo.id }) avisos = UiState.Exito(listOf(nuevo) + actual)
            }
        }
    }

    fun dejarDeEscuchar() {
        escucha?.cancel()
        escucha = null
    }
}

            // Al pasar a START (la pantalla se ve) carga y se queda escuchando;
            // al pasar a STOP (la app se fue al fondo) cierra la conexión.
            // Es el mismo "cuándo escuchar" del stateIn de la Práctica 5, hecho a mano.
            LifecycleStartEffect(Unit) {
                viewModel.cargar()
                onStopOrDispose { viewModel.dejarDeEscuchar() }
            }

adb shell "netstat -tn | grep :443"

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

    <uses-permission android:name="android.permission.INTERNET" />
    <!-- Desde Android 13 mostrar notificaciones es un permiso que el usuario concede en tiempo de ejecución. -->
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

<?xml version="1.0" encoding="utf-8"?>
<!-- El ícono chico de la notificación: solo alfa, el sistema le pone el color. -->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path
        android:fillColor="#FFFFFFFF"
        android:pathData="M12,22c1.1,0 2,-0.9 2,-2h-4c0,1.1 0.9,2 2,2zM18,16v-5c0,-3.07 -1.63,-5.64 -4.5,-6.32V4c0,-0.83 -0.67,-1.5 -1.5,-1.5S10.5,3.17 10.5,4v0.68C7.64,5.36 6,7.92 6,11v5l-2,2v1h16v-1l-2,-2z" />
</vector>

package mx.tec.avisos.notificaciones

import android.Manifest
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import mx.tec.avisos.MainActivity
import mx.tec.avisos.R
import mx.tec.avisos.domain.Aviso

/**
 * Lo único que sabe pintar una notificación. No sabe de dónde vino el aviso:
 * lo mismo lo llama el stream que el worker.
 *
 * Una notificación son tres cosas que suelen olvidarse por separado:
 *   - un CANAL, que existe desde Android 8 y es lo que el usuario apaga o
 *     silencia en Ajustes — por app, por canal;
 *   - el PERMISO, que desde Android 13 se pide en tiempo de ejecución y el
 *     usuario puede negar;
 *   - un PendingIntent, que es lo que pasa al tocarla.
 */
class Notificador(private val context: Context) {

    /** Idempotente: crear un canal que ya existe no hace nada. Se llama al arrancar la app. */
    fun crearCanal() {
        val canal = NotificationChannel(CANAL, "Avisos del tablón", NotificationManager.IMPORTANCE_HIGH).apply {
            description = "Un aviso nuevo publicado por un profesor"
        }
        context.getSystemService(NotificationManager::class.java).createNotificationChannel(canal)
    }

    fun tienePermiso(): Boolean =
        Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
            PackageManager.PERMISSION_GRANTED

    fun mostrar(aviso: Aviso) {
        // Sin permiso, `notify` no truena: simplemente no se ve. Mejor no llamarlo.
        if (!tienePermiso()) return

        // Al tocarla se abre la app. FLAG_IMMUTABLE: nadie más puede modificar este intent.
        val abrir = PendingIntent.getActivity(
            context,
            0,
            Intent(context, MainActivity::class.java),
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
        )

        val notificacion = NotificationCompat.Builder(context, CANAL)
            .setSmallIcon(R.drawable.ic_aviso)
            .setContentTitle(aviso.titulo)
            .setContentText(aviso.cuerpo)
            .setStyle(NotificationCompat.BigTextStyle().bigText(aviso.cuerpo))
            .setSubText(aviso.autor)
            .setContentIntent(abrir)
            .setAutoCancel(true)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .build()

        // El id es el del aviso: el mismo aviso dos veces reemplaza, no duplica.
        NotificationManagerCompat.from(context).notify(aviso.id, notificacion)
    }

    private companion object {
        const val CANAL = "avisos"
    }
}

    val notificador = Notificador(context)

        container.notificador.crearCanal()

package mx.tec.avisos.notificaciones

import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.platform.LocalContext
import androidx.core.content.ContextCompat

/**
 * Pide el permiso de notificaciones una vez, al entrar al tablón.
 *
 * No pinta nada. Se pide DESPUÉS de que el usuario entró y ya vio para qué
 * sirve la app —no en el arranque, cuando todavía no sabe qué le van a
 * notificar—. Si dice que no, la app sigue funcionando: solo no avisa.
 */
@Composable
fun PedirPermisoDeNotificaciones() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return

    val context = LocalContext.current
    val pedir = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { }

    LaunchedEffect(Unit) {
        val concedido = ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
            PackageManager.PERMISSION_GRANTED
        if (!concedido) pedir.launch(Manifest.permission.POST_NOTIFICATIONS)
    }
}

    // Ya entró y ya sabe qué es la app: ahora sí tiene sentido pedirle permiso para avisarle.
    PedirPermisoDeNotificaciones()

class AvisosViewModel(
    private val repository: AvisosRepository,
    private val notificador: Notificador
) : ViewModel() {

            repository.observar(desde = lista.maxOfOrNull { it.id } ?: 0).collect { nuevo ->
                val actual = (avisos as? UiState.Exito)?.datos ?: emptyList()
                if (actual.none { it.id == nuevo.id }) avisos = UiState.Exito(listOf(nuevo) + actual)
                // TEMPORAL, para ver la notificación: en el Bloque C esto se va.
                // Notificar lo que el usuario está viendo es ruido; lo que no ve, lo avisa el worker.
                notificador.mostrar(nuevo)
            }

        initializer {
            AvisosViewModel(
                repository = avisosApplication().container.avisosRepository,
                notificador = avisosApplication().container.notificador
            )
        }

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.intPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "avisos_vistos")

/**
 * Hasta qué aviso ya vio el usuario. Es un solo número, y de él depende que
 * el worker no notifique dos veces lo mismo — ni lo que la pantalla ya mostró.
 *
 * Va en su propio archivo, no en el de la sesión: no es un secreto y no tiene
 * por qué pasar por el Keystore.
 */
class AvisosVistosStore(private val context: Context) {

    private val ULTIMO_ID = intPreferencesKey("ultimo_id")

    /** 0 = nunca se ha visto el tablón. */
    val ultimoId: Flow<Int> = context.dataStore.data.map { it[ULTIMO_ID] ?: 0 }

    /** Solo avanza: un id menor al guardado no cambia nada. */
    suspend fun marcar(id: Int) {
        context.dataStore.edit { prefs ->
            if (id > (prefs[ULTIMO_ID] ?: 0)) prefs[ULTIMO_ID] = id
        }
    }
}

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.Job
import kotlinx.coroutines.launch
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.local.AvisosVistosStore
import mx.tec.avisos.domain.Aviso
import retrofit2.HttpException
import java.io.IOException

/**
 * La lista del tablón. Carga una vez y después se queda escuchando: cada
 * aviso nuevo que empuja el servidor entra a la lista sin que nadie recargue.
 *
 * Escuchar cuesta una conexión abierta, y una conexión abierta sin nadie
 * mirando es batería tirada. Por eso `cargar()` la abre y `dejarDeEscuchar()`
 * la cierra, y quien llama a las dos es la pantalla, según su ciclo de vida.
 */
class AvisosViewModel(
    private val repository: AvisosRepository,
    private val vistos: AvisosVistosStore
) : ViewModel() {

    var avisos by mutableStateOf<UiState<List<Aviso>>>(UiState.Cargando)
        private set

    private var escucha: Job? = null

    /** Carga el tablón y, si cargó, se queda escuchando avisos nuevos hasta que lo cancelen. */
    fun cargar() {
        escucha?.cancel()
        escucha = viewModelScope.launch {
            avisos = UiState.Cargando
            val lista = try {
                repository.obtener()
            } catch (e: IOException) {
                avisos = UiState.Error("No hay conexión. Revisa tu internet.")
                return@launch
            } catch (e: HttpException) {
                avisos = UiState.Error(mensajeDe(e))
                return@launch
            }
            mostrar(lista)

            repository.observar(desde = lista.maxOfOrNull { it.id } ?: 0).collect { nuevo ->
                val actual = (avisos as? UiState.Exito)?.datos ?: emptyList()
                if (actual.none { it.id == nuevo.id }) mostrar(listOf(nuevo) + actual)
            }
        }
    }

    fun dejarDeEscuchar() {
        escucha?.cancel()
        escucha = null
    }

    /** Lo que está en pantalla ya se vio: el worker no tiene por qué notificarlo después. */
    private suspend fun mostrar(lista: List<Aviso>) {
        avisos = UiState.Exito(lista)
        lista.maxOfOrNull { it.id }?.let { vistos.marcar(it) }
    }
}

    val avisosVistos = AvisosVistosStore(context)

        initializer {
            AvisosViewModel(
                repository = avisosApplication().container.avisosRepository,
                vistos = avisosApplication().container.avisosVistos
            )
        }

[versions]
work = "2.11.2"

[libraries]
androidx-work-runtime = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }

    implementation(libs.androidx.work.runtime)

package mx.tec.avisos.trabajo

import android.content.Context
import androidx.work.Constraints
import androidx.work.CoroutineWorker
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.NetworkType
import androidx.work.PeriodicWorkRequestBuilder
import androidx.work.WorkManager
import androidx.work.WorkerParameters
import kotlinx.coroutines.flow.first
import mx.tec.avisos.AvisosApplication
import retrofit2.HttpException
import java.io.IOException
import java.util.concurrent.TimeUnit

/**
 * Lo que corre cuando la app está cerrada: pregunta si hay avisos nuevos desde
 * el último que el usuario vio, y los notifica.
 *
 * No lo lanza la app: lo lanza el SISTEMA, cuando le conviene — con red, con
 * batería, agrupado con el trabajo de otras apps. A cambio, la app no necesita
 * quedarse viva ni tener una conexión abierta. Es el trato de WorkManager.
 *
 * Cada `return` dice algo distinto:
 *   - success: ya está, hasta la próxima vez.
 *   - retry:   no se pudo (sin red); vuelve a intentar con espera creciente.
 *   - failure: no tiene caso reintentar (el servidor dijo que no).
 */
class RevisarAvisosWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        val container = (applicationContext as AvisosApplication).container

        // Sin sesión no hay a quién avisarle. No es un error: es que nadie ha entrado.
        container.sesionRepository.sesion.first() ?: return Result.success()

        val desde = container.avisosVistos.ultimoId.first()

        val nuevos = try {
            container.avisosRepository.obtener(desde)
        } catch (e: IOException) {
            return Result.retry()
        } catch (e: HttpException) {
            return Result.failure()
        }
        if (nuevos.isEmpty()) return Result.success()

        // La primera vez no se notifica nada: marcar y ya. Si no, un usuario
        // recién instalado recibiría cien notificaciones de golpe.
        if (desde > 0) nuevos.forEach { container.notificador.mostrar(it) }
        container.avisosVistos.marcar(nuevos.maxOf { it.id })
        return Result.success()
    }

    companion object {

        private const val NOMBRE = "revisar-avisos"

        /** Solo con red. Sin esto, el worker correría en modo avión, fallaría y reintentaría a ciegas. */
        fun restricciones(): Constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .build()

        /**
         * Cada 15 minutos —el mínimo que Android permite— y solo con red.
         * `KEEP`: si ya está programado, no se duplica. Se llama al arrancar la app.
         */
        fun programar(context: Context) {
            val peticion = PeriodicWorkRequestBuilder<RevisarAvisosWorker>(15, TimeUnit.MINUTES)
                .setConstraints(restricciones())
                .build()

            WorkManager.getInstance(context)
                .enqueueUniquePeriodicWork(NOMBRE, ExistingPeriodicWorkPolicy.KEEP, peticion)
        }
    }
}

        // El worker se programa una vez y queda programado aunque la app muera.
        RevisarAvisosWorker.programar(this)

package mx.tec.avisos.trabajo

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import androidx.work.OneTimeWorkRequestBuilder
import androidx.work.WorkManager

/**
 * Solo existe en builds de debug. Encola UNA ejecución del mismo worker que
 * el sistema corre cada 15 minutos, para no esperar 15 minutos en clase:
 *
 *   adb shell am broadcast -n mx.tec.avisos/.trabajo.RevisarAhoraReceiver
 *
 * En producción nadie lo dispara: lo dispara el sistema, cuando le toca.
 */
class RevisarAhoraReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        val peticion = OneTimeWorkRequestBuilder<RevisarAvisosWorker>()
            .setConstraints(RevisarAvisosWorker.restricciones())
            .build()
        WorkManager.getInstance(context).enqueue(peticion)
    }
}

<?xml version="1.0" encoding="utf-8"?>
<!-- Se fusiona con el manifiesto principal solo en builds de debug. -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
        <receiver
            android:name=".trabajo.RevisarAhoraReceiver"
            android:exported="true" />
    </application>
</manifest>

adb shell am broadcast -n mx.tec.avisos/.trabajo.RevisarAhoraReceiver

adb shell "dumpsys jobscheduler | grep -A3 mx.tec.avisos/androidx.work"

Required constraints: CONNECTIVITY FLEXIBILITY

adb shell pidof mx.tec.avisos

git commit -m "checkpoint c4: el worker avisa con la app cerrada" -m "Co-Authored-By: Claude <noreply@anthropic.com>"

id: 7
event: aviso
data: {"id":7,"titulo":"Examen parcial","cuerpo":"…"}

: ping

callbackFlow {
    val fuente = abrirConexion(onEvento = { trySend(it) }, onCierre = { close() })
    awaitClose { fuente.cancel() }
}