Tema 2 · Callbacks, listeners, handlers y despacho

class PantallaMapa : AppCompatActivity() {

    private val alMoverse: Listener = { pos ->
        pintar(pos)                         // captura this
    }

    override fun onStart() {                // alta
        super.onStart()
        Gps.addListener(alMoverse)
    }

    override fun onStop() {                 // baja
        super.onStop()
        Gps.removeListener(alMoverse)
    }
}

class PantallaMapa {
  alMoverse = (pos) => {          // captura this
    this.pintar(pos);
  };
  montar()    { gps.addListener(this.alMoverse); }     // alta
  desmontar() { gps.removeListener(this.alMoverse); }  // baja
}

// Pantalla 1
class P1 : AppCompatActivity() {
    private val alMoverse: Listener = { pos -> pintar(pos) }
    override fun onCreate(b: Bundle?)  { super.onCreate(b); Gps.addListener(alMoverse) }
    override fun onDestroy()           { super.onDestroy(); Gps.removeListener(alMoverse) }
}

// Pantalla 2
class P2 : AppCompatActivity() {
    private val alMoverse: Listener = { pos -> pintar(pos) }
    override fun onStart() { super.onStart(); Gps.addListener(alMoverse) }
    override fun onPause() { super.onPause(); Gps.removeListener(alMoverse) }
}

// Pantalla 3
class P3 : AppCompatActivity() {
    override fun onStart() { super.onStart(); Gps.addListener { pos -> pintar(pos) } }
    override fun onStop()  { super.onStop();  Gps.removeListener { pos -> pintar(pos) } }
}

fun interface Suscripcion { fun cancelar() }

class Sensor {
    private val listeners = mutableListOf<Listener>()
    fun addListener(l: Listener): Suscripcion {
        listeners += l
        return Suscripcion { listeners -= l }
    }
}

val s = sensor.addListener { println(it) }
// …
s.cancelar()            // baja sin guardar la lambda

class Sensor {
  #listeners = [];
  addListener(l) {
    this.#listeners.push(l);
    return () => this.removeListener(l);   // el alta devuelve la baja
  }
}
const cancelar = sensor.addListener(console.log);
cancelar();

const control = new AbortController();
boton.addEventListener("click", alPulsar, { signal: control.signal });
// …
control.abort();   // da de baja todo lo ligado a esa señal

typedef enum { EV_BOTON, EV_TIMER, EV_UART, EV_COUNT } ev_tipo_t;

typedef struct {
    ev_tipo_t tipo;
    int       dato;
} evento_t;

/* El «tipo función» de C */
typedef void (*handler_t)(const evento_t *ev, void *ctx);

static void al_pulsar(const evento_t *ev, void *ctx) {
    printf("Botón %d\n", ev->dato);
}

handler_t h = al_pulsar;   /* guardar */
h(&ev, NULL);              /* invocar */

void despachar(const evento_t *ev) {
    switch (ev->tipo) {
    case EV_BOTON: al_pulsar(ev, NULL);  break;
    case EV_TIMER: al_vencer(ev, NULL);  break;
    case EV_UART:  al_recibir(ev, NULL); break;
    default: break;
    }
}

static const handler_t tabla[EV_COUNT] = {
    [EV_BOTON] = al_pulsar,
    [EV_TIMER] = al_vencer,
    [EV_UART]  = al_recibir,
};

void despachar(const evento_t *ev) {
    if (ev->tipo < EV_COUNT && tabla[ev->tipo])
        tabla[ev->tipo](ev, NULL);
}

static void al_pulsar(const evento_t *ev, void *ctx) { printf("Botón %d\n", ev->dato); }
static void al_vencer(const evento_t *ev, void *ctx) { printf("Timer\n"); }

static const handler_t tabla[EV_COUNT] = {
    [EV_BOTON] = al_pulsar,
    [EV_TIMER] = al_vencer,
};

void despachar(const evento_t *ev) {
    if (ev->tipo < EV_COUNT && tabla[ev->tipo])
        tabla[ev->tipo](ev, NULL);
}

enum class Tipo { ANADIR, LISTAR, ELIMINAR, SALIR }
data class Evento(val tipo: Tipo, val dato: String = "")
typealias Handler = (Evento) -> Unit

class Despachador {
    private val tabla = mutableMapOf<Tipo, MutableList<Handler>>()

    fun on(tipo: Tipo, h: Handler) {
        tabla.getOrPut(tipo) { mutableListOf() } += h
    }
    fun despachar(ev: Evento) {
        tabla[ev.tipo]?.toList()?.forEach { it(ev) }
    }
}

d.on(Tipo.ANADIR) { tareas += it.dato }
d.on(Tipo.ANADIR, ::registrarEnLog)        // 2º suscriptor
d.despachar(Evento(Tipo.ANADIR, "Estudiar U2"))

class Despachador {
  #tabla = new Map();                       // tipo -> [handlers]
  on(tipo, h) {
    if (!this.#tabla.has(tipo)) this.#tabla.set(tipo, []);
    this.#tabla.get(tipo).push(h);
  }
  despachar(ev) {
    const lista = this.#tabla.get(ev.tipo) ?? [];
    [...lista].forEach((h) => h(ev));
  }
}
d.on("ANADIR", (ev) => tareas.push(ev.dato));
d.on("ANADIR", registrarEnLog);
d.despachar({ tipo: "ANADIR", dato: "Estudiar U2" });

val tareas = mutableListOf<String>()

fun registrarEnLog(ev: Evento) = println("log: ${ev.tipo} ${ev.dato}")

fun main() {
    val d = Despachador()
    d.on(Tipo.ANADIR) { tareas += it.dato }
    d.on(Tipo.ANADIR, ::registrarEnLog)
    d.on(Tipo.LISTAR) { println("tareas: $tareas") }

    d.despachar(Evento(Tipo.ANADIR, "Estudiar U2"))
    d.despachar(Evento(Tipo.ELIMINAR, "x"))
    d.despachar(Evento(Tipo.ANADIR, "Repasar C"))
    d.despachar(Evento(Tipo.LISTAR))
}

typedef struct {
    void (*al_conectar)(void *ctx);
    void (*al_recibir)(const uint8_t *buf, size_t n, void *ctx);
    void (*al_cerrar)(void *ctx);
} red_callbacks_t;

red_iniciar(&mis_callbacks, &mi_ctx);

static const handler_t tabla[EV_COUNT] = {
    [EV_BOTON] = al_pulsar,
    [EV_TIMER] = al_vencer,
    [EV_UART]  = al_recibir,
};
tabla[ev->tipo](ev, ctx);

typedef struct { handler_t fn; void *ctx; } entrada_t;
static entrada_t tabla[EV_COUNT];

void registrar(ev_tipo_t t, handler_t fn, void *ctx) {
    tabla[t] = (entrada_t){ fn, ctx };
}

typedef struct { int pin; bool encendido; } led_t;

static void conmutar(const evento_t *ev, void *ctx) {
    led_t *led = ctx;                 /* recuperar contexto */
    led->encendido = !led->encendido;
    gpio_set_level(led->pin, led->encendido);
}

static led_t rojo = { .pin = 2 }, verde = { .pin = 3 };
registrar(EV_BOTON, conmutar, &rojo);
registrar(EV_TIMER, conmutar, &verde);

using Handler = std::function<void(int)>;
std::unordered_map<int, Handler> t;
t[1] = [](int x) { log(x); };
t.at(tipo)(dato);

interface Observador {                        // update(): lo llama el sujeto
    fun actualizar(temperatura: Double)
}

class Termometro {                            // Subject / Observable
    private val observadores = mutableListOf<Observador>()

    var temperatura = 20.0
        private set                           // solo el sujeto lo cambia

    fun suscribir(o: Observador)   { observadores += o }   // attach
    fun desuscribir(o: Observador) { observadores -= o }   // detach

    fun medir(nueva: Double) {
        if (nueva == temperatura) return      // sin cambio -> sin aviso
        temperatura = nueva
        notificar()
    }

    private fun notificar() {
        for (o in observadores.toList()) o.actualizar(temperatura)
    }
}

class Pantalla : Observador {
    override fun actualizar(temperatura: Double) =
        println("Pantalla: %.1f ºC".format(temperatura))
}

class Alarma(private val umbral: Double) : Observador {
    override fun actualizar(temperatura: Double) {
        if (temperatura > umbral) println("ALARMA: $temperatura > $umbral")
    }
}

class Registro : Observador {
    val historial = mutableListOf<Double>()
    override fun actualizar(temperatura: Double) { historial += temperatura }
}

fun main() {
    val termometro = Termometro()
    termometro.suscribir(Pantalla())
    termometro.suscribir(Alarma(umbral = 30.0))
    termometro.suscribir(Registro())

    termometro.medir(22.5)
    termometro.medir(22.5)   // igual: no notifica
    termometro.medir(31.0)   // salta la alarma
}

class Termometro {                         // sujeto
  #observadores = [];
  #temperatura = 20.0;                     // privado: solo lo cambia el sujeto

  suscribir(o)   { this.#observadores.push(o); }
  desuscribir(o) { this.#observadores = this.#observadores.filter(x => x !== o); }

  medir(nueva) {
    if (nueva === this.#temperatura) return;   // sin cambio -> sin aviso
    this.#temperatura = nueva;
    this.#notificar();
  }

  #notificar() {
    for (const o of [...this.#observadores]) o.actualizar(this.#temperatura);
  }
}

class Pantalla { actualizar(t) { console.log(`Pantalla: ${t.toFixed(1)} ºC`); } }

class Alarma {
  constructor(umbral) { this.umbral = umbral; }
  actualizar(t) { if (t > this.umbral) console.log(`ALARMA: ${t} > ${this.umbral}`); }
}

typealias Suscriptor = (Any) -> Unit

object Bus {                                  // uno para toda la aplicación
    private val topics = mutableMapOf<String, MutableList<Suscriptor>>()

    fun suscribir(topic: String, s: Suscriptor): () -> Unit {
        topics.getOrPut(topic) { mutableListOf() } += s
        return { topics[topic]?.remove(s) }  // función de baja (Clase 2)
    }

    fun publicar(topic: String, dato: Any) {
        val lista = topics[topic] ?: return   // nadie escucha: se pierde sin error
        for (s in lista.toList()) s(dato)
    }
}

const Bus = {
  topics: new Map(),
  suscribir(topic, s) {                                   // on()
    if (!this.topics.has(topic)) this.topics.set(topic, []);
    this.topics.get(topic).push(s);
    return () => this.topics.set(topic,                   // off()
      this.topics.get(topic).filter(x => x !== s));
  },
  publicar(topic, dato) {                                 // emit()
    const lista = this.topics.get(topic);
    if (!lista) return;                                   // nadie escucha: silencio
    for (const s of [...lista]) s(dato);
  },
};

const bajaLog = Bus.suscribir("sensor/temperatura", d => console.log(`log: ${d}`));
Bus.suscribir("sensor/temperatura", d => { if (d > 30) console.log(`alarma: ${d}`); });
Bus.suscribir("usuario/login", u => console.log(`bienvenida a ${u}`));

Bus.publicar("sensor/temperatura", 28.0);
Bus.publicar("sensor/humedad", 55);          // nadie suscrito
Bus.publicar("usuario/login", "ana");
bajaLog();
Bus.publicar("sensor/temperatura", 35.0);

botonPulsa.setOnClickListener {
    pulsaciones++            // 1. cambia el estado (regla de negocio)
    actualizarInterfaz()     // 2. repinta a mano
}

private fun actualizarInterfaz() {
    textPulsaciones.text = "Pulsaciones: $pulsaciones"
}

class Observable<T>(valorInicial: T) {     // LiveData en miniatura
    private val observadores = mutableListOf<(T) -> Unit>()

    var valor: T = valorInicial
        set(nuevo) {
            field = nuevo
            for (o in observadores.toList()) o(nuevo)
        }

    fun observar(o: (T) -> Unit) {
        observadores += o
        o(valor)                            // valor actual al suscribirse
    }
}

class ContadorViewModel {                  // estado y reglas; sin pantallas
    val pulsaciones = Observable(0)
    val activo = Observable(true)

    fun onPulsar() { if (activo.valor) pulsaciones.valor++ }
    fun onCambiarActivo(v: Boolean) { activo.valor = v }
}

fun main() {
    val vm = ContadorViewModel()

    vm.pulsaciones.observar { println("[TextView] Pulsaciones: $it") }
    vm.pulsaciones.observar { if (it >= 3) println("[Toast] ¡tres ya!") }
    vm.activo.observar      { println("[Button] enabled = $it") }

    vm.onPulsar(); vm.onPulsar(); vm.onPulsar()
    vm.onCambiarActivo(false)
    vm.onPulsar()            // no cuenta: la regla vive en el ViewModel
}

class Observable {                              // LiveData en miniatura
  #observadores = []; #valor;
  constructor(inicial) { this.#valor = inicial; }
  get valor() { return this.#valor; }
  set valor(nuevo) { this.#valor = nuevo; for (const o of [...this.#observadores]) o(nuevo); }
  observar(o) { this.#observadores.push(o); o(this.#valor); }
}

class ContadorViewModel {                       // nada de DOM aquí
  pulsaciones = new Observable(0);
  activo = new Observable(true);
  onPulsar() { if (this.activo.valor) this.pulsaciones.valor++; }
  onCambiarActivo(v) { this.activo.valor = v; }
}

const vm = new ContadorViewModel();
vm.pulsaciones.observar(n => span.textContent = `Pulsaciones: ${n}`);   // vista 1
vm.pulsaciones.observar(n => { if (n >= 3) mostrarToast("¡tres ya!"); }); // vista 2
vm.activo.observar(a => boton.disabled = !a);                             // vista 3
boton.addEventListener("click", () => vm.onPulsar());                    // el listener solo avisa

val temp = Observable(20)
temp.observar { if (it > 40) temp.valor = 40 }   // A: «corrige» desde dentro
temp.observar { println("Pantalla: $it") }        // B
temp.valor = 45
println("valor final: ${temp.valor}")

// banner.js (se carga primero)
bus.suscribir("carrito/anadido", (item) => {
  if (resumen.total >= 50) banner.mostrar("¡Envío gratis!");
});

// resumen.js (se carga después)
bus.suscribir("carrito/anadido", (item) => {
  resumen.total += item.precio;
});

// El carrito lleva 45 €; se añaden unas zapatillas de 10 €
bus.publicar("carrito/anadido", { nombre: "Zapatillas", precio: 10 });

// carrito.js
class Carrito {
  #total = 0;
  anadir(item) {
    this.#total += item.precio;            // primero el estado
    bus.publicar("carrito/cambiado",
      { item, total: this.#total });       // después el aviso
  }
}

bus.suscribir("carrito/cambiado", ({ total }) => {
  if (total >= 50) banner.mostrar("¡Envío gratis!");
});

class Pedido {
  #oyentes = [];
  suscribir(f) {
    this.#oyentes.push(f);
    return () => this.#oyentes.splice(this.#oyentes.indexOf(f), 1);
  }
  cambiarEstado(estado) {
    this.#oyentes.forEach((f) => f(estado)); // lista VIVA
  }
}

const pedido = new Pedido();

const bajaMapa = pedido.suscribir((e) => {
  console.log(`Mapa: ${e}`);
  if (e === "entregado") bajaMapa();       // un solo uso
});

pedido.suscribir((e) => {
  if (e === "entregado") console.log("¿Qué tal tu pedido?");
});

pedido.suscribir((e) => console.log(`Historial: ${e}`));

pedido.cambiarEstado("entregado");

cambiarEstado(estado) {
  [...this.#oyentes].forEach((f) => f(estado)); // copia
} // Mapa · ¿Qué tal tu pedido? · Historial

// suscritos en este orden: controlRuta, voz
val controlRuta = gps.suscribir { pos ->
    if (pos == destino) {
        println("Ha llegado a su destino")
        gps.cancelar(voz)                    // se apaga la voz…
    }
}

val voz = gps.suscribir { pos ->
    println(ruta.instruccionPara(pos))       // …pero estaba en la foto
}

class Suscripcion(val f: (Posicion) -> Unit) { var activa = true }

class Gps {
    private val subs = mutableListOf<Suscripcion>()

    fun suscribir(f: (Posicion) -> Unit) =
        Suscripcion(f).also { subs += it }

    fun cancelar(s: Suscripcion) { s.activa = false; subs -= s }

    fun publicar(p: Posicion) {
        for (s in subs.toList())   // foto: nadie rompe el bucle
            if (s.activa) s.f(p)   // una baja cuenta desde ya
    }
}

class Observable<T>(inicial: T) {
    private val observadores = mutableListOf<(T) -> Unit>()
    var valor: T = inicial
        set(nuevo) {
            if (nuevo == field) return
            field = nuevo
            for (o in observadores.toList()) o(nuevo)
        }
    fun observar(o: (T) -> Unit) { observadores += o }
}

fun main() {
    val stock = 10
    val cantidad = Observable(1)
    cantidad.observar { if (it > stock) cantidad.valor = stock } // limitar
    cantidad.observar { println("  [Carrito] cantidad: $it") }   // pintar
    cantidad.valor = 12                                          // el usuario escribe 12
    println("  valor real: ${cantidad.valor}")
}

class CarritoViewModel(private val stock: Int) {
    val cantidad = Observable(1)
    fun onCambiarCantidad(n: Int) {
        cantidad.valor = n.coerceIn(1, stock)
    }
}
// Los observadores solo pintan
// SALIDA A:  [Carrito] cantidad: 10

class Observable<T>(inicial: T) {
    private val observadores = mutableListOf<(T) -> Unit>()
    private val pendientes = ArrayDeque<T>()       // cola de avisos
    private var notificando = false
    var valor: T = inicial
        set(nuevo) {
            if (nuevo == field) return
            field = nuevo
            pendientes.addLast(nuevo)
            if (notificando) return                  // reentrada: encola y vuelve
            notificando = true
            try {
                while (pendientes.isNotEmpty()) {
                    val v = pendientes.removeFirst()
                    for (o in observadores.toList()) o(v)
                }
            } finally { notificando = false }
        }
    fun observar(o: (T) -> Unit) { observadores += o }
}
// SALIDA B:  [Carrito] cantidad: 12
//            [Carrito] cantidad: 10   ← valor real
//            valor real: 10

// Módulo Reloj
bus.suscribir("ajustes/tema", (tema) => {
  reloj.aplicarTema(tema);
  bus.publicar("ajustes/tema", tema); // reenvía por el mismo topic
});

// Módulo Móvil
bus.suscribir("ajustes/tema", (tema) => {
  movil.aplicarTema(tema);
  bus.publicar("ajustes/tema", tema);
});

bus.publicar("ajustes/tema", "oscuro");

// Solo el dueño escucha ÓRDENES y publica HECHOS
bus.suscribir("ajustes/cambiar-tema", (tema) => {
  if (tema === ajustes.tema) return;      // sin cambio, sin aviso
  ajustes.tema = tema;
  bus.publicar("ajustes/tema-cambiado", tema);
});

// Los demás reaccionan a hechos y nunca los reenvían
bus.suscribir("ajustes/tema-cambiado", (t) => reloj.aplicarTema(t));
bus.suscribir("ajustes/tema-cambiado", (t) => movil.aplicarTema(t));

bus.publicar("ajustes/cambiar-tema", "oscuro");

function abrirModalPago() {
  modal.hidden = false;
  // alta en CADA apertura
  botonConfirmar.addEventListener("click", () => {
    enviarPedido(carrito);
    modal.hidden = true;
  });
}

// cerrar no da de baja
function cancelarModal() { modal.hidden = true; }

// Se registra UNA vez, al cargar la página, con una función con nombre
botonConfirmar.addEventListener("click", confirmar);

function confirmar() {
  enviarPedido(carrito);
  modal.hidden = true;
}

function abrirModalPago() { modal.hidden = false; }

class FeedInfinito {
  montar() {
    window.addEventListener("scroll", this.cargarMas.bind(this));
  }
  desmontar() {
    window.removeEventListener("scroll", this.cargarMas.bind(this));
  }
  cargarMas() { if (cercaDelFinal()) this.pedirPagina(); }
}

class FeedInfinito {
  cargarMas = () => {                 // campo: una sola función, fija this
    if (cercaDelFinal()) this.pedirPagina();
  };
  montar()     { window.addEventListener("scroll", this.cargarMas); }
  desmontar()  { window.removeEventListener("scroll", this.cargarMas); }
}