Charla: un chat que vive en tu computadora

git clone https://github.com/rpversontec/practica-12-charla-servidor.git
git clone https://github.com/rpversontec/practica-12-charla.git

cp .env.example .env

# La imagen del servidor: Python 3.12 y las versiones exactas de uv.lock.
FROM python:3.12-slim-bookworm
COPY --from=ghcr.io/astral-sh/uv:0.12.9 /uv /bin/uv

WORKDIR /code
ENV UV_LINK_MODE=copy \
    UV_COMPILE_BYTECODE=1 \
    PYTHONUNBUFFERED=1

# Primero las dependencias: si solo cambia tu código, Docker reutiliza esta capa
# y reconstruir tarda segundos, no minutos. Incluye pytest: las pruebas corren aquí dentro.
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-install-project

COPY app ./app

EXPOSE 8000
CMD ["uv", "run", "--no-sync", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# La sala completa:
#   docker compose up -d --build     el servidor (http://localhost:8000) y el túnel
#   docker compose logs -f api       lo que va pasando en la sala
services:
  api:
    build: .
    env_file: .env
    # --reload + los volúmenes: editas app/ en tu máquina y el servidor se reinicia solo.
    command: ["uv", "run", "--no-sync", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]
    volumes:
      - ./app:/code/app
      - ./tests:/code/tests
      - ./herramientas:/code/herramientas
      - datos:/datos
    # Solo en 127.0.0.1: tu máquina y el emulador (10.0.2.2) llegan; el resto del wifi, no.
    # Tus compañeros entran por el túnel.
    ports:
      - "127.0.0.1:8000:8000"

  tunel:
    image: cloudflare/cloudflared:2026.9.3
    # Una dirección https://….trycloudflare.com que llega a `api` desde cualquier red.
    # http2 porque muchas redes bloquean QUIC (UDP). --metrics publica /quicktunnel,
    # donde la API lee esa dirección para el QR.
    command: ["tunnel", "--no-autoupdate", "--protocol", "http2", "--metrics", "0.0.0.0:2000", "--url", "http://api:8000"]
    depends_on:
      - api

volumes:
  # La base de la sala. Sobrevive a `docker compose down`; `down -v` la borra.
  datos:

"""Charla: el servidor de UNA sala de chat, la tuya. Corre en tu computadora."""
from fastapi import FastAPI

app = FastAPI(title="Charla")


@app.get("/salud")
def salud():
    return {"ok": True}

docker compose up -d --build

"""Lo que la sala recuerda, en un archivo SQLite.

SQLite viene dentro de Python: no hay otro contenedor ni contraseña. El archivo
vive en /datos, un volumen de Docker, así que sobrevive a `docker compose down`
y a cada recarga de --reload. Sin él, cada vez que guardas un .py se borraría
la sala entera: mensajes, invitados y sus tokens.
"""
import os
import secrets
import sqlite3
import time


class Datos:
    def __init__(self, ruta: str):
        # Un solo hilo atiende todo (el del servidor), pero las pruebas lo usan
        # desde otro: check_same_thread=False lo permite.
        self.con = sqlite3.connect(ruta, check_same_thread=False)
        self.con.row_factory = sqlite3.Row
        self.con.executescript(
            """
            CREATE TABLE IF NOT EXISTS solicitudes (
                id       TEXT PRIMARY KEY,
                nickname TEXT NOT NULL,
                estado   TEXT NOT NULL,   -- pendiente | aprobada | rechazada
                token    TEXT UNIQUE      -- solo cuando se aprueba
            );
            CREATE TABLE IF NOT EXISTS mensajes (
                id    INTEGER PRIMARY KEY AUTOINCREMENT,
                de    TEXT NOT NULL,
                texto TEXT NOT NULL,
                en    REAL NOT NULL       -- segundos desde 1970, como time.time()
            );
            """
        )

    # ---------- solicitudes ----------

    def nickname_ocupado(self, nickname: str) -> bool:
        """Ocupado = alguien lo pidió y no lo rechazaron."""
        fila = self.con.execute(
            "SELECT 1 FROM solicitudes WHERE lower(nickname) = lower(?) AND estado != 'rechazada'",
            (nickname,),
        ).fetchone()
        return fila is not None

    def crear_solicitud(self, nickname: str) -> dict:
        sid = secrets.token_urlsafe(8)
        with self.con:
            self.con.execute(
                "INSERT INTO solicitudes (id, nickname, estado) VALUES (?, ?, 'pendiente')",
                (sid, nickname),
            )
        return self.solicitud(sid)

    def solicitud(self, sid: str) -> dict | None:
        fila = self.con.execute("SELECT * FROM solicitudes WHERE id = ?", (sid,)).fetchone()
        return dict(fila) if fila else None

    def pendientes(self) -> list[dict]:
        filas = self.con.execute(
            "SELECT id, nickname FROM solicitudes WHERE estado = 'pendiente' ORDER BY rowid"
        ).fetchall()
        return [dict(f) for f in filas]

    def resolver(self, sid: str, aprobar: bool) -> dict | None:
        """Aprueba (y genera el token) o rechaza. Solo una vez: lo resuelto no cambia."""
        s = self.solicitud(sid)
        if s is None or s["estado"] != "pendiente":
            return None
        with self.con:
            if aprobar:
                self.con.execute(
                    "UPDATE solicitudes SET estado = 'aprobada', token = ? WHERE id = ?",
                    (secrets.token_urlsafe(24), sid),
                )
            else:
                self.con.execute("UPDATE solicitudes SET estado = 'rechazada' WHERE id = ?", (sid,))
        return self.solicitud(sid)

    def nickname_de(self, token: str) -> str | None:
        fila = self.con.execute(
            "SELECT nickname FROM solicitudes WHERE token = ? AND estado = 'aprobada'", (token,)
        ).fetchone()
        return fila["nickname"] if fila else None

    # ---------- mensajes ----------

    def guardar_mensaje(self, de: str, texto: str) -> dict:
        with self.con:
            cursor = self.con.execute(
                "INSERT INTO mensajes (de, texto, en) VALUES (?, ?, ?)", (de, texto, time.time())
            )
        fila = self.con.execute("SELECT * FROM mensajes WHERE id = ?", (cursor.lastrowid,)).fetchone()
        return dict(fila)

    def ultimos_mensajes(self, cuantos: int = 50) -> list[dict]:
        filas = self.con.execute(
            "SELECT * FROM mensajes ORDER BY id DESC LIMIT ?", (cuantos,)
        ).fetchall()
        return [dict(f) for f in reversed(filas)]


# La base de toda la app. Las pruebas la cambian por una en memoria.
db = Datos(os.environ.get("RUTA_DB", "/datos/charla.db"))

"""La sala: un WebSocket por persona conectada, y lo que dice uno le llega a todos.

HTTP es «pregunto y me contestan». Un WebSocket se queda abierto en los dos
sentidos: el servidor puede hablar sin que nadie le pregunte. Eso es lo que
necesita un chat.
"""
import os
import secrets

from fastapi import APIRouter, WebSocket, WebSocketDisconnect

from app import datos

router = APIRouter()

# Quien se conecta con esta clave es el dueño de la sala. Viene del .env.
CLAVE_ANFITRION = os.environ["CLAVE_ANFITRION"]
ANFITRION = "anfitrión"

# Quién está conectado ahora mismo. Vive en memoria: una conexión no se puede guardar en disco.
conectados: dict[WebSocket, str] = {}


def quien_es(ws: WebSocket) -> str | None:
    """El nickname de quien abre la conexión, por su token. None = no tiene permiso."""
    token = ws.headers.get("authorization", "").removeprefix("Bearer ").strip()
    if not token:
        return None
    # compare_digest tarda lo mismo aunque falle en la primera letra: no regala pistas.
    if secrets.compare_digest(token, CLAVE_ANFITRION):
        return ANFITRION
    return datos.db.nickname_de(token)


async def difundir(evento: dict) -> None:
    """A todos los conectados. Si uno ya se fue, se le quita de la lista."""
    for ws in list(conectados):
        try:
            await ws.send_json(evento)
        except Exception:
            conectados.pop(ws, None)


async def avisar_al_anfitrion(evento: dict) -> None:
    for ws, quien in list(conectados.items()):
        if quien == ANFITRION:
            await ws.send_json(evento)


@router.websocket("/chat")
async def chat(ws: WebSocket):
    yo = quien_es(ws)
    if yo is None:
        # Cerrar ANTES de aceptar: el cliente recibe un 403 y no llega a entrar.
        await ws.close(code=1008)
        return
    await ws.accept()
    conectados[ws] = yo
    await ws.send_json({
        "tipo": "bienvenida",
        "yo": yo,
        "mensajes": datos.db.ultimos_mensajes(),
        "solicitudes": datos.db.pendientes() if yo == ANFITRION else [],
    })
    try:
        while True:
            orden = await ws.receive_json()
            await atender(yo, orden)
    except WebSocketDisconnect:
        pass
    finally:
        conectados.pop(ws, None)


async def atender(yo: str, orden: dict) -> None:
    tipo = orden.get("tipo")
    if tipo == "mensaje":
        texto = str(orden.get("texto", "")).strip()[:500]
        if texto:
            await difundir({"tipo": "mensaje", **datos.db.guardar_mensaje(yo, texto)})
    elif tipo in ("aprobar", "rechazar") and yo == ANFITRION:
        s = datos.db.resolver(str(orden.get("id", "")), aprobar=tipo == "aprobar")
        if s and s["estado"] == "aprobada":
            aviso = datos.db.guardar_mensaje("sala", f"{s['nickname']} entró a la sala")
            await difundir({"tipo": "mensaje", **aviso})

"""Charla: el servidor de UNA sala de chat, la tuya. Corre en tu computadora."""
from fastapi import FastAPI

from app import sala

app = FastAPI(title="Charla")
app.include_router(sala.router)


@app.get("/salud")
def salud():
    return {"ok": True}

docker compose exec api uv run --no-sync python herramientas/consola.py anfitrion

"""Pedir entrar a la sala. Es HTTP normal: quien pide todavía no tiene token para el WebSocket."""
from typing import Annotated

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel, StringConstraints

from app import datos, sala

router = APIRouter(prefix="/solicitudes", tags=["solicitudes"])

Nickname = Annotated[str, StringConstraints(strip_whitespace=True, min_length=2, max_length=20)]
RESERVADOS = {"anfitrión", "anfitrion", "sala"}


class NuevaSolicitud(BaseModel):
    nickname: Nickname


@router.post("", status_code=201)
async def solicitar(nueva: NuevaSolicitud):
    if nueva.nickname.lower() in RESERVADOS or datos.db.nickname_ocupado(nueva.nickname):
        raise HTTPException(409, "Ese nickname ya está en la sala")
    s = datos.db.crear_solicitud(nueva.nickname)
    # Al anfitrión le llega en vivo, por su WebSocket. Si no está conectado, la
    # verá en la bienvenida la próxima vez que entre.
    await sala.avisar_al_anfitrion({"tipo": "solicitud", "id": s["id"], "nickname": s["nickname"]})
    return s


@router.get("/{sid}")
def consultar(sid: str):
    """Quien pidió entrar pregunta aquí cada par de segundos. Cuando lo aprueban, recibe su token."""
    s = datos.db.solicitud(sid)
    if s is None:
        raise HTTPException(404, "No existe esa solicitud")
    return s

"""Charla: el servidor de UNA sala de chat, la tuya. Corre en tu computadora."""
from fastapi import FastAPI

from app import sala, solicitudes

app = FastAPI(title="Charla")
app.include_router(sala.router)
app.include_router(solicitudes.router)


@app.get("/salud")
def salud():
    return {"ok": True}

docker compose exec api uv run --no-sync python herramientas/consola.py anfitrion

docker compose exec api uv run --no-sync python herramientas/consola.py invitado dani

"""La dirección pública de la sala: la que va en el QR.

cloudflared inventa una dirección nueva cada vez que arranca y la anuncia en
su puerto de métricas (/quicktunnel). El servidor se la pregunta, así nadie
tiene que copiarla a mano de los logs.
"""
import asyncio
import json
import os
import urllib.request

from fastapi import APIRouter, HTTPException

router = APIRouter()

# `tunel` es el nombre del servicio en docker-compose.yml: dentro de la red de Docker, es su dirección.
METRICAS_TUNEL = os.environ.get("METRICAS_TUNEL", "http://tunel:2000/quicktunnel")


def leer(url: str) -> bytes:
    with urllib.request.urlopen(url, timeout=3) as respuesta:
        return respuesta.read()


@router.get("/invitacion")
async def invitacion():
    try:
        # urllib bloquea: se corre en otro hilo para no detener la sala mientras tanto.
        cuerpo = await asyncio.to_thread(leer, METRICAS_TUNEL)
    except OSError:
        raise HTTPException(503, "El túnel no está corriendo")
    host = json.loads(cuerpo).get("hostname")
    if not host:
        raise HTTPException(503, "El túnel todavía no tiene dirección: espera unos segundos")
    return {"url": f"https://{host}"}

"""Charla: el servidor de UNA sala de chat, la tuya. Corre en tu computadora."""
from fastapi import FastAPI

from app import invitacion, sala, solicitudes

app = FastAPI(title="Charla")
app.include_router(sala.router)
app.include_router(solicitudes.router)
app.include_router(invitacion.router)


@app.get("/salud")
def salud():
    return {"ok": True}

import os

# Antes de importar la app: la clave y una base en memoria, no la del volumen.
os.environ.setdefault("CLAVE_ANFITRION", "clave-de-prueba")
os.environ["RUTA_DB"] = ":memory:"

import pytest
from fastapi.testclient import TestClient

from app import datos
from app.main import app


@pytest.fixture
def cliente(monkeypatch):
    # Una base nueva para cada prueba: ninguna depende de lo que dejó la anterior.
    monkeypatch.setattr(datos, "db", datos.Datos(":memory:"))
    with TestClient(app) as c:
        yield c


@pytest.fixture
def clave():
    from app.sala import CLAVE_ANFITRION
    return {"Authorization": f"Bearer {CLAVE_ANFITRION}"}

import pytest
from starlette.websockets import WebSocketDisconnect

from app import invitacion


def pedir(cliente, nickname):
    return cliente.post("/solicitudes", json={"nickname": nickname})


def test_la_sala_responde(cliente):
    assert cliente.get("/salud").json() == {"ok": True}


def test_un_nickname_de_una_letra_no_se_acepta(cliente):
    assert pedir(cliente, "a").status_code == 422


def test_dos_personas_no_pueden_llamarse_igual(cliente):
    assert pedir(cliente, "dani").status_code == 201
    assert pedir(cliente, "Dani").status_code == 409
    assert pedir(cliente, "anfitrión").status_code == 409


def test_sin_token_no_se_entra_al_chat(cliente):
    with pytest.raises(WebSocketDisconnect) as e:
        with cliente.websocket_connect("/chat") as ws:
            ws.receive_json()
    assert e.value.code == 1008


def test_el_anfitrion_aprueba_y_el_invitado_chatea(cliente, clave):
    with cliente.websocket_connect("/chat", headers=clave) as anfitrion:
        assert anfitrion.receive_json()["yo"] == "anfitrión"

        s = pedir(cliente, "dani").json()
        assert s["estado"] == "pendiente" and s["token"] is None
        assert anfitrion.receive_json() == {"tipo": "solicitud", "id": s["id"], "nickname": "dani"}

        anfitrion.send_json({"tipo": "aprobar", "id": s["id"]})
        assert anfitrion.receive_json()["texto"] == "dani entró a la sala"
        token = cliente.get(f"/solicitudes/{s['id']}").json()["token"]

        with cliente.websocket_connect("/chat", headers={"Authorization": f"Bearer {token}"}) as dani:
            bienvenida = dani.receive_json()
            assert bienvenida["yo"] == "dani"
            assert bienvenida["solicitudes"] == []  # las solicitudes solo las ve el anfitrión
            dani.send_json({"tipo": "mensaje", "texto": "  hola  "})
            recibido = anfitrion.receive_json()
            assert (recibido["de"], recibido["texto"]) == ("dani", "hola")


def test_un_invitado_no_puede_aprobar_a_otro(cliente, clave):
    with cliente.websocket_connect("/chat", headers=clave) as anfitrion:
        anfitrion.receive_json()
        dani = pedir(cliente, "dani").json()
        anfitrion.receive_json()
        anfitrion.send_json({"tipo": "aprobar", "id": dani["id"]})
        anfitrion.receive_json()
        token = cliente.get(f"/solicitudes/{dani['id']}").json()["token"]

        eli = pedir(cliente, "eli").json()
        anfitrion.receive_json()
        with cliente.websocket_connect("/chat", headers={"Authorization": f"Bearer {token}"}) as ws:
            ws.receive_json()
            ws.send_json({"tipo": "aprobar", "id": eli["id"]})
            ws.send_json({"tipo": "mensaje", "texto": "listo"})
            ws.receive_json()  # cuando llega su mensaje, la orden anterior ya se atendió
        assert cliente.get(f"/solicitudes/{eli['id']}").json()["estado"] == "pendiente"


def test_el_historial_llega_al_entrar(cliente, clave):
    with cliente.websocket_connect("/chat", headers=clave) as ws:
        ws.receive_json()
        ws.send_json({"tipo": "mensaje", "texto": "primero"})
        ws.receive_json()
    with cliente.websocket_connect("/chat", headers=clave) as ws:
        assert [m["texto"] for m in ws.receive_json()["mensajes"]] == ["primero"]


def test_sin_tunel_la_invitacion_dice_por_que(cliente, monkeypatch):
    monkeypatch.setattr(invitacion, "METRICAS_TUNEL", "http://127.0.0.1:9/quicktunnel")
    r = cliente.get("/invitacion")
    assert r.status_code == 503
    assert r.json()["detail"] == "El túnel no está corriendo"

docker compose exec api uv run --no-sync pytest

charla.clave=la-misma-de-tu-.env

package mx.tec.charla.data.remote

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import mx.tec.charla.domain.Mensaje
import mx.tec.charla.domain.Solicitud

/**
 * Lo que viaja por el WebSocket. Cada mensaje es un JSON con un campo `tipo`
 * que dice qué es; el resto de los campos depende del tipo.
 *
 * Una interfaz sellada es exactamente eso: un conjunto cerrado de variantes.
 * kotlinx.serialization lee `tipo` y elige la clase por su `@SerialName`.
 */
@Serializable
sealed interface EventoServidor {

    /** Lo primero que llega al conectarse: quién eres, la historia, y (si eres el anfitrión) quién espera. */
    @Serializable
    @SerialName("bienvenida")
    data class Bienvenida(
        val yo: String,
        val mensajes: List<Mensaje>,
        val solicitudes: List<Solicitud>
    ) : EventoServidor

    @Serializable
    @SerialName("mensaje")
    data class Nuevo(val id: Long, val de: String, val texto: String, val en: Double) : EventoServidor {
        fun aMensaje() = Mensaje(id, de, texto, en)
    }

    @Serializable
    @SerialName("solicitud")
    data class NuevaSolicitud(val id: String, val nickname: String) : EventoServidor {
        fun aSolicitud() = Solicitud(id, nickname)
    }
}

/** Lo que la app le manda al servidor. */
@Serializable
sealed interface Orden {
    @Serializable
    @SerialName("mensaje")
    data class Enviar(val texto: String) : Orden

    @Serializable
    @SerialName("aprobar")
    data class Aprobar(val id: String) : Orden

    @Serializable
    @SerialName("rechazar")
    data class Rechazar(val id: String) : Orden
}

object Protocolo {
    private val json = Json {
        classDiscriminator = "tipo"
        ignoreUnknownKeys = true
    }

    /** null si el servidor manda algo que esta versión de la app no conoce: se ignora, no truena. */
    fun leer(texto: String): EventoServidor? =
        runCatching { json.decodeFromString<EventoServidor>(texto) }.getOrNull()

    fun escribir(orden: Orden): String = json.encodeToString(orden)
}

package mx.tec.charla.data.remote

import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import mx.tec.charla.domain.EstadoConexion
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.WebSocket
import okhttp3.WebSocketListener

/**
 * El WebSocket de la sala. Una sola conexión a la vez para toda la app.
 *
 * Hacia afuera son dos Flows: `estado` (cómo está la conexión) y `eventos`
 * (lo que dice el servidor). Hacia adentro, OkHttp avisa con callbacks en su
 * propio hilo; aquí se traducen a esos Flows.
 */
@Singleton
class ChatConexion @Inject constructor(private val cliente: OkHttpClient) {

    private val _estado = MutableStateFlow<EstadoConexion>(EstadoConexion.Desconectado)
    val estado: StateFlow<EstadoConexion> = _estado.asStateFlow()

    private val _eventos = MutableSharedFlow<EventoServidor>(extraBufferCapacity = 64)
    val eventos: SharedFlow<EventoServidor> = _eventos.asSharedFlow()

    // @Volatile: OkHttp llama a los callbacks desde su propio hilo, y tienen que ver el valor más reciente.
    @Volatile private var actual: WebSocket? = null

    fun conectar(servidor: String, token: String) {
        desconectar()
        // OkHttp acepta la dirección http(s): un WebSocket empieza como una
        // petición HTTP normal que pide «Upgrade: websocket».
        val peticion = Request.Builder()
            .url("$servidor/chat")
            .header("Authorization", "Bearer $token")
            .build()
        _estado.value = EstadoConexion.Conectando
        actual = cliente.newWebSocket(peticion, Escucha())
    }

    fun desconectar() {
        actual?.close(1000, null)
        actual = null
        _estado.value = EstadoConexion.Desconectado
    }

    /** false si no hay conexión: el mensaje no salió. */
    fun enviar(orden: Orden): Boolean = actual?.send(Protocolo.escribir(orden)) ?: false

    private inner class Escucha : WebSocketListener() {

        override fun onOpen(webSocket: WebSocket, response: Response) {
            _estado.value = EstadoConexion.Conectado
        }

        override fun onMessage(webSocket: WebSocket, text: String) {
            Protocolo.leer(text)?.let { _eventos.tryEmit(it) }
        }

        override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
            // El servidor se despide (por ejemplo, porque se reinicia): se le contesta igual.
            webSocket.close(1000, null)
        }

        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
            _estado.value = EstadoConexion.Desconectado
        }

        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
            // 403: el servidor no reconoce el token. Cualquier otra cosa: se cayó la red o el servidor.
            _estado.value = if (response?.code == 403) EstadoConexion.Rechazado else EstadoConexion.Desconectado
        }
    }
}

package mx.tec.charla.ui.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import mx.tec.charla.BuildConfig
import mx.tec.charla.data.remote.ChatConexion
import mx.tec.charla.data.remote.EventoServidor
import mx.tec.charla.data.remote.Orden
import mx.tec.charla.domain.ANFITRION
import mx.tec.charla.domain.Destino
import mx.tec.charla.domain.Solicitud

@HiltViewModel
class SalaViewModel @Inject constructor(private val conexion: ChatConexion) : ViewModel() {

    // Por ahora solo existe tu sala, y su dirección sale de local.properties. En el C2 la guarda SalaStore.
    private val destino = Destino(BuildConfig.SERVIDOR_PROPIO, BuildConfig.CLAVE_ANFITRION, ANFITRION, esPropio = true)

    private val _ui = MutableStateFlow(SalaUiState(destino = destino))
    val ui: StateFlow<SalaUiState> = _ui.asStateFlow()

    init {
        viewModelScope.launch {
            conexion.estado.collect { estado -> _ui.update { it.copy(conexion = estado) } }
        }
        viewModelScope.launch {
            conexion.eventos.collect(::recibir)
        }
    }

    /** La pantalla se ve: a conectarse. Lo llama LifecycleStartEffect. */
    fun alAparecer() = conexion.conectar(destino.servidor, destino.token)

    /** La app se fue al fondo: se cierra. Un socket abierto sin nadie viendo gasta batería. */
    fun alDesaparecer() = conexion.desconectar()

    private fun recibir(evento: EventoServidor) {
        when (evento) {
            // Al conectar (y al reconectar) llega la historia completa: reemplaza, no suma.
            is EventoServidor.Bienvenida -> _ui.update {
                it.copy(mensajes = evento.mensajes, solicitudes = evento.solicitudes)
            }
            is EventoServidor.Nuevo -> _ui.update { it.copy(mensajes = it.mensajes + evento.aMensaje()) }
            is EventoServidor.NuevaSolicitud -> _ui.update { it.copy(solicitudes = it.solicitudes + evento.aSolicitud()) }
        }
    }

    /** true si salió. El mensaje no se pinta aquí: se pinta cuando el servidor lo reparte, a todos igual. */
    fun enviar(texto: String): Boolean = texto.isNotBlank() && conexion.enviar(Orden.Enviar(texto.trim()))

    fun aprobar(solicitud: Solicitud) = responder(solicitud, Orden.Aprobar(solicitud.id))

    fun rechazar(solicitud: Solicitud) = responder(solicitud, Orden.Rechazar(solicitud.id))

    private fun responder(solicitud: Solicitud, orden: Orden) {
        if (conexion.enviar(orden)) _ui.update { it.copy(solicitudes = it.solicitudes - solicitud) }
    }

    // La invitación y Reiniciar necesitan la API de la sala y SalaStore: llegan en el C2.
    fun invitar() {}

    fun cerrarInvitacion() {}

    fun reiniciar() {}

    override fun onCleared() = conexion.desconectar()
}

docker compose exec api uv run --no-sync python herramientas/consola.py invitado eli

[versions]
zxing = "3.5.4"
codeScanner = "16.1.0"
barcodeScanning = "17.3.0"
coroutinesPlayServices = "1.10.2"

[libraries]
zxing-core = { group = "com.google.zxing", name = "core", version.ref = "zxing" }
play-services-code-scanner = { group = "com.google.android.gms", name = "play-services-code-scanner", version.ref = "codeScanner" }
mlkit-barcode-scanning = { group = "com.google.mlkit", name = "barcode-scanning", version.ref = "barcodeScanning" }
kotlinx-coroutines-play-services = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-play-services", version.ref = "coroutinesPlayServices" }

    // El QR: ZXing lo dibuja; el escáner de Google lo lee con la cámara;
    // ML Kit lo lee de una imagen (viene dentro de la app: funciona sin descargar nada)
    implementation(libs.zxing.core)
    implementation(libs.play.services.code.scanner)
    implementation(libs.mlkit.barcode.scanning)
    implementation(libs.kotlinx.coroutines.play.services)

package mx.tec.charla.data.remote

import kotlinx.serialization.Serializable
import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Url

/**
 * Lo que NO va por el WebSocket: preguntar la invitación y pedir entrar.
 *
 * Cada sala tiene su dirección, así que no hay una `baseUrl` fija: con `@Url`
 * cada llamada recibe la dirección completa. Retrofit ignora su `baseUrl`
 * cuando la de la llamada ya trae `http://`.
 */
interface SalaApi {
    @GET
    suspend fun invitacion(@Url url: String): Invitacion

    @POST
    suspend fun solicitar(@Url url: String, @Body cuerpo: NuevaSolicitud): EstadoSolicitud

    @GET
    suspend fun consultar(@Url url: String): EstadoSolicitud
}

@Serializable
data class Invitacion(val url: String)

@Serializable
data class NuevaSolicitud(val nickname: String)

/** `estado` es pendiente, aprobada o rechazada. El token solo llega cuando la aprueban. */
@Serializable
data class EstadoSolicitud(val id: String, val nickname: String, val estado: String, val token: String? = null)

package mx.tec.charla.di

import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
import kotlinx.serialization.json.Json
import mx.tec.charla.data.remote.SalaApi
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.kotlinx.serialization.asConverterFactory

@Module
@InstallIn(SingletonComponent::class)
object RedModule {

    /**
     * Un solo cliente para el WebSocket y para Retrofit.
     *
     * `pingInterval`: cada 20 s OkHttp manda un ping por el WebSocket. Si no
     * vuelve el pong, da la conexión por muerta y avisa con `onFailure`.
     * Sin pings, una conexión que se cayó en silencio —el wifi cambió, el
     * túnel la cerró por inactiva— parecería viva para siempre.
     */
    @Provides
    @Singleton
    fun cliente(): OkHttpClient = OkHttpClient.Builder()
        .pingInterval(20, TimeUnit.SECONDS)
        .build()

    @Provides
    @Singleton
    fun salaApi(cliente: OkHttpClient): SalaApi = Retrofit.Builder()
        // Obligatoria para Retrofit, pero no se usa: cada llamada trae su @Url completa.
        .baseUrl("http://localhost/")
        .client(cliente)
        .addConverterFactory(Json { ignoreUnknownKeys = true }.asConverterFactory("application/json".toMediaType()))
        .build()
        .create(SalaApi::class.java)
}

package mx.tec.charla.data.qr

import android.graphics.Bitmap
import android.graphics.Color
import com.google.zxing.BarcodeFormat
import com.google.zxing.EncodeHintType
import com.google.zxing.qrcode.QRCodeWriter

/**
 * Dibuja un QR con ZXing: primero una matriz de sí/no (módulo negro o
 * blanco), y después un Bitmap con un pixel por casilla.
 *
 * Se pasa el arreglo completo de una vez (`setPixels`): pixel por pixel con
 * `setPixel` serían 600 000 llamadas.
 */
object GeneradorQr {
    fun bitmap(texto: String, lado: Int = 768): Bitmap {
        val matriz = QRCodeWriter().encode(texto, BarcodeFormat.QR_CODE, lado, lado, mapOf(EncodeHintType.MARGIN to 1))
        val pixeles = IntArray(lado * lado) { i ->
            if (matriz[i % lado, i / lado]) Color.BLACK else Color.WHITE
        }
        return Bitmap.createBitmap(lado, lado, Bitmap.Config.RGB_565).apply {
            setPixels(pixeles, 0, lado, 0, 0, lado, lado)
        }
    }
}

package mx.tec.charla.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.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import dagger.hilt.android.qualifiers.ApplicationContext
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import mx.tec.charla.BuildConfig
import mx.tec.charla.domain.ANFITRION
import mx.tec.charla.domain.Destino

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

/**
 * A qué sala va la app. Vacío = a la tuya.
 *
 * Se guarda para que, si cierras la app, vuelvas a la misma sala sin pedir
 * entrar otra vez: el token sigue valiendo mientras el anfitrión no borre su
 * base.
 */
@Singleton
class SalaStore @Inject constructor(@ApplicationContext private val context: Context) {

    private val SERVIDOR = stringPreferencesKey("servidor")
    private val TOKEN = stringPreferencesKey("token")
    private val YO = stringPreferencesKey("yo")

    val destino: Flow<Destino> = context.dataStore.data.map { prefs ->
        val servidor = prefs[SERVIDOR]
        val token = prefs[TOKEN]
        val yo = prefs[YO]
        if (servidor != null && token != null && yo != null) {
            Destino(servidor, token, yo, esPropio = false)
        } else {
            propio
        }
    }

    suspend fun entrar(servidor: String, token: String, yo: String) {
        context.dataStore.edit {
            it[SERVIDOR] = servidor
            it[TOKEN] = token
            it[YO] = yo
        }
    }

    /** El botón Reiniciar: olvida la sala ajena y vuelve a la tuya. */
    suspend fun reiniciar() {
        context.dataStore.edit { it.clear() }
    }

    companion object {
        val propio = Destino(BuildConfig.SERVIDOR_PROPIO, BuildConfig.CLAVE_ANFITRION, ANFITRION, esPropio = true)
    }
}

package mx.tec.charla.ui.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import java.io.IOException
import javax.inject.Inject
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import mx.tec.charla.data.local.SalaStore
import mx.tec.charla.data.qr.GeneradorQr
import mx.tec.charla.data.remote.ChatConexion
import mx.tec.charla.data.remote.EventoServidor
import mx.tec.charla.data.remote.Orden
import mx.tec.charla.data.remote.SalaApi
import mx.tec.charla.domain.Solicitud
import retrofit2.HttpException

@HiltViewModel
class SalaViewModel @Inject constructor(
    private val store: SalaStore,
    private val conexion: ChatConexion,
    private val api: SalaApi
) : ViewModel() {

    private val _ui = MutableStateFlow(SalaUiState())
    val ui: StateFlow<SalaUiState> = _ui.asStateFlow()

    private var visible = false

    init {
        viewModelScope.launch {
            // Cada vez que cambia la sala (entraste a otra, o Reiniciar), se conecta a la nueva.
            store.destino.distinctUntilChanged().collect { destino ->
                // Sala nueva, pantalla en blanco: la historia llega con la bienvenida.
                _ui.update { SalaUiState(destino = destino, conexion = it.conexion) }
                if (visible) conexion.conectar(destino.servidor, destino.token)
            }
        }
        viewModelScope.launch {
            conexion.estado.collect { estado -> _ui.update { it.copy(conexion = estado) } }
        }
        viewModelScope.launch {
            conexion.eventos.collect(::recibir)
        }
    }

    /** La pantalla se ve: a conectarse. Lo llama LifecycleStartEffect. */
    fun alAparecer() {
        visible = true
        _ui.value.destino?.let { conexion.conectar(it.servidor, it.token) }
    }

    /** La app se fue al fondo: se cierra. Un socket abierto sin nadie viendo gasta batería. */
    fun alDesaparecer() {
        visible = false
        conexion.desconectar()
    }

    private fun recibir(evento: EventoServidor) {
        when (evento) {
            // Al conectar (y al reconectar) llega la historia completa: reemplaza, no suma.
            is EventoServidor.Bienvenida -> _ui.update {
                it.copy(mensajes = evento.mensajes, solicitudes = evento.solicitudes)
            }
            is EventoServidor.Nuevo -> _ui.update { it.copy(mensajes = it.mensajes + evento.aMensaje()) }
            is EventoServidor.NuevaSolicitud -> _ui.update { it.copy(solicitudes = it.solicitudes + evento.aSolicitud()) }
        }
    }

    /** true si salió. El mensaje no se pinta aquí: se pinta cuando el servidor lo reparte, a todos igual. */
    fun enviar(texto: String): Boolean = texto.isNotBlank() && conexion.enviar(Orden.Enviar(texto.trim()))

    fun aprobar(solicitud: Solicitud) = responder(solicitud, Orden.Aprobar(solicitud.id))

    fun rechazar(solicitud: Solicitud) = responder(solicitud, Orden.Rechazar(solicitud.id))

    private fun responder(solicitud: Solicitud, orden: Orden) {
        if (conexion.enviar(orden)) _ui.update { it.copy(solicitudes = it.solicitudes - solicitud) }
    }

    /** Pregunta a TU servidor su dirección pública y la convierte en QR. */
    fun invitar() {
        _ui.update { it.copy(invitacion = InvitacionUi.Cargando) }
        viewModelScope.launch {
            val invitacion = try {
                val url = api.invitacion("${SalaStore.propio.servidor}/invitacion").url
                // Dibujar el QR son medio millón de pixeles: fuera del hilo principal.
                InvitacionUi.Lista(url, withContext(Dispatchers.Default) { GeneradorQr.bitmap(url) })
            } catch (e: IOException) {
                InvitacionUi.Error(mensajeDe(e))
            } catch (e: HttpException) {
                InvitacionUi.Error(mensajeDe(e))
            }
            _ui.update { it.copy(invitacion = invitacion) }
        }
    }

    fun cerrarInvitacion() = _ui.update { it.copy(invitacion = InvitacionUi.Cerrada) }

    /** Olvida la sala ajena. `store.destino` cambia, y el `collect` de arriba reconecta solo. */
    fun reiniciar() {
        viewModelScope.launch { store.reiniciar() }
    }

    override fun onCleared() = conexion.desconectar()
}

package mx.tec.charla.domain

/**
 * La dirección de una sala, venga de donde venga: un QR, una captura, o un
 * texto que alguien pegó («Entra a mi sala de Charla: https://…»).
 *
 * Se queda con lo primero que parezca `http(s)://host[:puerto]` y tira el
 * resto (una ruta, una diagonal al final, el texto alrededor). Si no hay nada
 * así, regresa null: mejor decir «eso no es un enlace» que conectarse a basura.
 */
object Enlace {
    private val DIRECCION = Regex("""https?://[A-Za-z0-9.-]+(:\d{1,5})?""")

    fun servidorDesde(texto: String): String? = DIRECCION.find(texto)?.value
}

package mx.tec.charla.data.qr

import android.content.Context
import android.net.Uri
import com.google.mlkit.vision.barcode.BarcodeScannerOptions
import com.google.mlkit.vision.barcode.BarcodeScanning
import com.google.mlkit.vision.barcode.common.Barcode
import com.google.mlkit.vision.codescanner.GmsBarcodeScannerOptions
import com.google.mlkit.vision.codescanner.GmsBarcodeScanning
import com.google.mlkit.vision.common.InputImage
import dagger.hilt.android.qualifiers.ApplicationContext
import javax.inject.Inject
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.tasks.await

/**
 * Dos formas de leer un QR, las dos de Google:
 *
 *  - con la cámara: el escáner de Play Services abre SU pantalla, lee el
 *    código y regresa el texto. La app no pide permiso de cámara: la cámara
 *    la usa Google, no tú.
 *  - de una imagen: ML Kit busca códigos en una foto o captura que ya existe.
 */
class LectorQr @Inject constructor(@ApplicationContext private val context: Context) {

    private val soloQr = BarcodeScannerOptions.Builder().setBarcodeFormats(Barcode.FORMAT_QR_CODE).build()

    /**
     * null si el usuario cerró el escáner sin leer nada. Se escribe con los tres
     * callbacks y no con `await()`: cerrar el escáner CANCELA la tarea, y `await()`
     * lo convertiría en una excepción que cancela también a quien llamó.
     */
    suspend fun escanear(): String? = suspendCancellableCoroutine { continuacion ->
        val opciones = GmsBarcodeScannerOptions.Builder().setBarcodeFormats(Barcode.FORMAT_QR_CODE).build()
        GmsBarcodeScanning.getClient(context, opciones).startScan()
            .addOnSuccessListener { continuacion.resume(it.rawValue) }
            .addOnCanceledListener { continuacion.resume(null) }
            .addOnFailureListener { continuacion.resumeWithException(it) }
    }

    /** El texto del primer QR de la imagen, o null si no tiene ninguno. */
    suspend fun leerDeImagen(imagen: Uri): String? {
        val entrada = InputImage.fromFilePath(context, imagen)
        val codigos = BarcodeScanning.getClient(soloQr).process(entrada).await()
        return codigos.firstNotNullOfOrNull { it.rawValue }
    }
}

package mx.tec.charla.ui.state

import android.net.Uri
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import java.io.IOException
import javax.inject.Inject
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import mx.tec.charla.data.local.SalaStore
import mx.tec.charla.data.qr.LectorQr
import mx.tec.charla.data.remote.NuevaSolicitud
import mx.tec.charla.data.remote.SalaApi
import mx.tec.charla.domain.Enlace
import retrofit2.HttpException

@HiltViewModel
class UnirseViewModel @Inject constructor(
    private val api: SalaApi,
    private val store: SalaStore,
    private val lector: LectorQr
) : ViewModel() {

    private val _ui = MutableStateFlow(UnirseUiState())
    val ui: StateFlow<UnirseUiState> = _ui.asStateFlow()

    private var pidiendo: Job? = null

    /** Las tres vías terminan aquí: un texto que debería traer la dirección de una sala. */
    fun usarEnlace(texto: String) {
        val servidor = Enlace.servidorDesde(texto)
        _ui.update {
            if (servidor == null) it.copy(etapa = Etapa.Error("Eso no parece el enlace de una sala"))
            else it.copy(servidor = servidor, etapa = Etapa.Eligiendo)
        }
    }

    fun escanear() {
        viewModelScope.launch {
            try {
                lector.escanear()?.let(::usarEnlace)
            } catch (e: Exception) {
                _ui.update { it.copy(etapa = Etapa.Error("No se pudo abrir el escáner: ${e.message}")) }
            }
        }
    }

    fun leerImagen(imagen: Uri) {
        viewModelScope.launch {
            val texto = try {
                lector.leerDeImagen(imagen)
            } catch (e: IOException) {
                null
            }
            if (texto == null) _ui.update { it.copy(etapa = Etapa.Error("No encontré un QR en esa imagen")) }
            else usarEnlace(texto)
        }
    }

    fun cambiarNickname(nickname: String) = _ui.update { it.copy(nickname = nickname) }

    fun pedirEntrar() {
        val servidor = _ui.value.servidor ?: return
        val nickname = _ui.value.nickname.trim()
        pidiendo = viewModelScope.launch {
            _ui.update { it.copy(etapa = Etapa.Enviando) }
            try {
                var solicitud = api.solicitar("$servidor/solicitudes", NuevaSolicitud(nickname))
                _ui.update { it.copy(etapa = Etapa.Esperando) }
                // Todavía no hay token para el WebSocket: se pregunta por HTTP cada 2 s.
                // Si sales de la pantalla, viewModelScope cancela este ciclo.
                while (solicitud.estado == "pendiente") {
                    delay(2_000)
                    solicitud = api.consultar("$servidor/solicitudes/${solicitud.id}")
                }
                val token = solicitud.token
                if (solicitud.estado == "aprobada" && token != null) {
                    store.entrar(servidor, token, solicitud.nickname)
                    _ui.update { it.copy(etapa = Etapa.Dentro) }
                } else {
                    _ui.update { it.copy(etapa = Etapa.Error("El anfitrión no te dejó entrar")) }
                }
            } catch (e: IOException) {
                _ui.update { it.copy(etapa = Etapa.Error(mensajeDe(e))) }
            } catch (e: HttpException) {
                _ui.update { it.copy(etapa = Etapa.Error(mensajeDe(e))) }
            }
        }
    }

    fun cancelar() {
        pidiendo?.cancel()
        _ui.update { it.copy(etapa = Etapa.Eligiendo) }
    }

    /** Elegir otra sala: se olvida la que estaba elegida. */
    fun otraSala() {
        pidiendo?.cancel()
        _ui.update { UnirseUiState(nickname = it.nickname) }
    }
}

package mx.tec.charla.domain

/**
 * Cuánto esperar antes del intento número `intento` de reconectar:
 * 1 s, 2 s, 4 s, 8 s, 16 s, y de ahí 30 s siempre.
 *
 * Duplicar la espera (backoff exponencial) es cortesía con el servidor: si se
 * cayó, treinta teléfonos tocándole la puerta cada segundo no lo ayudan a
 * levantarse. El tope evita que, tras una caída larga, la app tarde minutos en
 * darse cuenta de que ya volvió.
 */
fun esperaAntesDeReintentar(intento: Int): Long =
    (1_000L shl (intento - 1).coerceIn(0, 5)).coerceAtMost(30_000L)

package mx.tec.charla.data.remote

import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import mx.tec.charla.domain.EstadoConexion
import mx.tec.charla.domain.esperaAntesDeReintentar
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.WebSocket
import okhttp3.WebSocketListener

/**
 * El WebSocket de la sala. Una sola conexión a la vez para toda la app.
 *
 * Hacia afuera son dos Flows: `estado` (cómo está la conexión) y `eventos`
 * (lo que dice el servidor). Hacia adentro, OkHttp avisa con callbacks en su
 * propio hilo; aquí se traducen a esos Flows.
 */
@Singleton
class ChatConexion(
    private val cliente: OkHttpClient,
    private val alcance: CoroutineScope
) {
    @Inject
    constructor(cliente: OkHttpClient) : this(cliente, CoroutineScope(SupervisorJob() + Dispatchers.Default))

    private val _estado = MutableStateFlow<EstadoConexion>(EstadoConexion.Desconectado)
    val estado: StateFlow<EstadoConexion> = _estado.asStateFlow()

    private val _eventos = MutableSharedFlow<EventoServidor>(extraBufferCapacity = 64)
    val eventos: SharedFlow<EventoServidor> = _eventos.asSharedFlow()

    // @Volatile: OkHttp llama a los callbacks desde su propio hilo, y tienen que ver el valor más reciente.
    @Volatile private var actual: WebSocket? = null
    private var peticion: Request? = null
    private var reintento: Job? = null
    private var intentos = 0

    fun conectar(servidor: String, token: String) {
        desconectar()
        // OkHttp acepta la dirección http(s): un WebSocket empieza como una
        // petición HTTP normal que pide «Upgrade: websocket».
        peticion = Request.Builder()
            .url("$servidor/chat")
            .header("Authorization", "Bearer $token")
            .build()
        abrir()
    }

    fun desconectar() {
        reintento?.cancel()
        peticion = null
        intentos = 0
        actual?.close(1000, null)
        actual = null
        _estado.value = EstadoConexion.Desconectado
    }

    /** false si no hay conexión: el mensaje no salió. */
    fun enviar(orden: Orden): Boolean = actual?.send(Protocolo.escribir(orden)) ?: false

    private fun abrir() {
        val p = peticion ?: return
        _estado.value = EstadoConexion.Conectando
        actual = cliente.newWebSocket(p, Escucha())
    }

    private fun reintentar() {
        intentos++
        val espera = esperaAntesDeReintentar(intentos)
        _estado.value = EstadoConexion.Reconectando(espera / 1_000)
        reintento = alcance.launch {
            delay(espera)
            abrir()
        }
    }

    private inner class Escucha : WebSocketListener() {
        // Cada callback empieza igual: si este socket ya no es el actual, lo
        // que diga ya no importa. Sin esa línea, el cierre de una conexión
        // vieja llega DESPUÉS de que abrió la nueva y la marca «desconectada».

        override fun onOpen(webSocket: WebSocket, response: Response) {
            if (webSocket !== actual) return
            intentos = 0
            _estado.value = EstadoConexion.Conectado
        }

        override fun onMessage(webSocket: WebSocket, text: String) {
            if (webSocket !== actual) return
            Protocolo.leer(text)?.let { _eventos.tryEmit(it) }
        }

        override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
            // El servidor se despide (por ejemplo, porque se reinicia): se le contesta igual.
            webSocket.close(1000, null)
        }

        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
            if (webSocket !== actual) return
            reintentar()
        }

        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
            if (webSocket !== actual) return
            if (response?.code == 403) {
                // El servidor no reconoce el token. Reintentar no lo va a cambiar.
                actual = null
                _estado.value = EstadoConexion.Rechazado
            } else {
                reintentar()
            }
        }
    }
}

docker compose stop api

docker compose start api

[versions]
junit = "4.13.2"

[libraries]
junit = { group = "junit", name = "junit", version.ref = "junit" }
okhttp-mockwebserver = { group = "com.squareup.okhttp3", name = "mockwebserver", version.ref = "okhttp" }

    // Pruebas locales (src/test): corren en la JVM de tu computadora, sin emulador.
    testImplementation(libs.junit)
    testImplementation(libs.okhttp.mockwebserver)

package mx.tec.charla.domain

import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test

class EnlaceTest {

    @Test
    fun la_direccion_sola_queda_igual() {
        assertEquals("https://abc.trycloudflare.com", Enlace.servidorDesde("https://abc.trycloudflare.com"))
    }

    @Test
    fun se_quitan_la_diagonal_final_y_la_ruta() {
        assertEquals("https://abc.trycloudflare.com", Enlace.servidorDesde("https://abc.trycloudflare.com/"))
        assertEquals("https://abc.trycloudflare.com", Enlace.servidorDesde("https://abc.trycloudflare.com/chat"))
    }

    @Test
    fun se_encuentra_dentro_de_un_mensaje_compartido() {
        assertEquals(
            "https://abc.trycloudflare.com",
            Enlace.servidorDesde("Entra a mi sala de Charla: https://abc.trycloudflare.com")
        )
    }

    @Test
    fun el_puerto_se_conserva() {
        assertEquals("http://10.0.2.2:8000", Enlace.servidorDesde("http://10.0.2.2:8000"))
    }

    @Test
    fun lo_que_no_es_un_enlace_es_null() {
        assertNull(Enlace.servidorDesde("hola"))
        assertNull(Enlace.servidorDesde("ftp://abc.com"))
        assertNull(Enlace.servidorDesde(""))
    }
}

package mx.tec.charla.domain

import org.junit.Assert.assertEquals
import org.junit.Test

class EsperaTest {

    @Test
    fun la_espera_se_duplica_en_cada_intento() {
        assertEquals(listOf(1_000L, 2_000L, 4_000L, 8_000L, 16_000L), (1..5).map(::esperaAntesDeReintentar))
    }

    @Test
    fun nunca_pasa_de_30_segundos() {
        assertEquals(30_000L, esperaAntesDeReintentar(6))
        assertEquals(30_000L, esperaAntesDeReintentar(500))
    }
}

package mx.tec.charla.data.remote

import mx.tec.charla.domain.Mensaje
import mx.tec.charla.domain.Solicitud
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test

/** Los JSON de estas pruebas son copia de lo que manda el servidor de la Parte A. */
class ProtocoloTest {

    @Test
    fun la_bienvenida_trae_historia_y_solicitudes() {
        val evento = Protocolo.leer(
            """{"tipo":"bienvenida","yo":"anfitrión",
               "mensajes":[{"id":1,"de":"sala","texto":"dani entró a la sala","en":1791427512.5}],
               "solicitudes":[{"id":"IS_cy","nickname":"eli"}]}"""
        )
        assertEquals(
            EventoServidor.Bienvenida(
                yo = "anfitrión",
                mensajes = listOf(Mensaje(1, "sala", "dani entró a la sala", 1791427512.5)),
                solicitudes = listOf(Solicitud("IS_cy", "eli"))
            ),
            evento
        )
    }

    @Test
    fun un_mensaje_nuevo_se_convierte_en_mensaje() {
        val evento = Protocolo.leer("""{"tipo":"mensaje","id":7,"de":"dani","texto":"hola","en":1.0}""")
        assertEquals(Mensaje(7, "dani", "hola", 1.0), (evento as EventoServidor.Nuevo).aMensaje())
    }

    @Test
    fun lo_que_esta_version_no_conoce_se_ignora() {
        assertNull(Protocolo.leer("""{"tipo":"escribiendo","de":"dani"}"""))
        assertNull(Protocolo.leer("no soy json"))
    }

    @Test
    fun cada_orden_lleva_su_tipo() {
        assertEquals("""{"tipo":"mensaje","texto":"hola"}""", Protocolo.escribir(Orden.Enviar("hola")))
        assertEquals("""{"tipo":"aprobar","id":"IS_cy"}""", Protocolo.escribir(Orden.Aprobar("IS_cy")))
    }
}

package mx.tec.charla.data.remote

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.async
import kotlinx.coroutines.cancel
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import mx.tec.charla.domain.EstadoConexion
import okhttp3.OkHttpClient
import okhttp3.Response
import okhttp3.WebSocket
import okhttp3.WebSocketListener
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Test

/**
 * ChatConexion contra salas de mentira que corren en la JVM: MockWebServer
 * habla WebSocket de verdad. Sin emulador y sin Docker.
 */
class ChatConexionTest {

    private val salaA = MockWebServer()
    private val salaB = MockWebServer()
    private val alcance = CoroutineScope(SupervisorJob() + Dispatchers.Default)
    private val conexion = ChatConexion(OkHttpClient(), alcance)

    @After
    fun cerrar() {
        conexion.desconectar()
        alcance.cancel()
        salaA.shutdown()
        salaB.shutdown()
    }

    /**
     * Encola una sala que acepta el WebSocket. `alAbrir` decide qué hace el servidor
     * cuando alguien entra; `tardaEnDespedirse`, cuánto tarda en contestar un cierre
     * (en localhost es casi nada; por el túnel, no).
     */
    private fun MockWebServer.sala(tardaEnDespedirse: Long = 0, alAbrir: (WebSocket) -> Unit = {}): String {
        enqueue(MockResponse().withWebSocketUpgrade(object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) = alAbrir(webSocket)
            override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
                Thread.sleep(tardaEnDespedirse)
                webSocket.close(1000, null)
            }
        }))
        return url("/").toString().removeSuffix("/")
    }

    private fun esperar(estado: EstadoConexion) {
        runBlocking { withTimeout(5_000) { conexion.estado.first { it == estado } } }
    }

    @Test
    fun manda_el_token_y_recibe_la_bienvenida() {
        val url = salaA.sala { it.send("""{"tipo":"bienvenida","yo":"dani","mensajes":[],"solicitudes":[]}""") }
        // UNDISPATCHED: empieza a escuchar YA, antes de conectar. Si no, la bienvenida podría llegar sin nadie oyendo.
        val bienvenida = runBlocking {
            val primero = async(start = CoroutineStart.UNDISPATCHED) { withTimeout(5_000) { conexion.eventos.first() } }
            conexion.conectar(url, "token-de-dani")
            primero.await()
        }

        assertEquals("dani", (bienvenida as EventoServidor.Bienvenida).yo)
        assertEquals("Bearer token-de-dani", salaA.takeRequest().getHeader("Authorization"))
        esperar(EstadoConexion.Conectado)
    }

    @Test
    fun el_cierre_de_la_conexion_vieja_no_apaga_la_nueva() {
        conexion.conectar(salaA.sala(tardaEnDespedirse = 300), "uno")
        esperar(EstadoConexion.Conectado)
        conexion.conectar(salaB.sala(), "dos")
        esperar(EstadoConexion.Conectado)

        // El cierre de la sala A llega 300 ms DESPUÉS de que abrió la B. Que no cambie nada.
        Thread.sleep(1_000)
        assertEquals(EstadoConexion.Conectado, conexion.estado.value)
    }

    @Test
    fun si_la_sala_no_reconoce_el_token_no_reintenta() {
        salaA.enqueue(MockResponse().setResponseCode(403))
        conexion.conectar(salaA.url("/").toString().removeSuffix("/"), "viejo")
        esperar(EstadoConexion.Rechazado)

        Thread.sleep(1_500)
        assertEquals(EstadoConexion.Rechazado, conexion.estado.value)
        assertEquals(1, salaA.requestCount)
    }

    @Test
    fun si_la_sala_se_cae_reintenta_y_vuelve() {
        // La primera conexión el servidor la corta en cuanto abre (como al reiniciarse); la segunda, no.
        val url = salaA.sala { it.close(1012, "me reinicio") }
        salaA.sala()
        conexion.conectar(url, "t")

        esperar(EstadoConexion.Reconectando(1))
        esperar(EstadoConexion.Conectado)
        assertEquals(2, salaA.requestCount)
    }
}

        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
            reintentar()
        }

el_cierre_de_la_conexion_vieja_no_apaga_la_nueva
java.lang.AssertionError: expected:<Conectado> but was:<Reconectando(enSegundos=1)>

git commit -m "checkpoint d3: reconexion y pruebas" -m "Co-Authored-By: Claude <noreply@anthropic.com>"