@ing.jorgeu/wargaming-overlay 2.3.0 → 2.4.0

package/README.md

@@ -625,3 +625,11 @@ npm run facts:coverage -- --require-four-hours
 ```
 
 Al ampliar `data/faction-facts.json`, usa el nombre exacto del registro, conserva los IDs existentes para respetar el historial y asigna un ID estable a cada nueva curiosidad. Incluye un enlace específico, título de fuente y fecha de revisión. No añadas reformulaciones del mismo dato para aumentar artificialmente la duración.
+
+### Continuidad entre USB y Wi-Fi
+
+El lector recuerda el teléfono por su identificador físico en `phone-connection.json`, dentro de la carpeta de datos. Si ADB presenta USB y Wi-Fi para ese mismo teléfono, el overlay prefiere USB. Al retirar el cable, utiliza la conexión inalámbrica autorizada; al reconectarlo, vuelve a USB. Nunca elige otro teléfono por compartir el modelo o una dirección IP anterior.
+
+Activa la depuración inalámbrica y empareja el computador con el teléfono en Android. Tener activada la opción no equivale a estar emparejado. ADB debe poder descubrir el teléfono en la red. Si el descubrimiento no funciona, conecta previamente con `adb connect IP:PUERTO` usando la dirección que Android muestra en Depuración inalámbrica. El overlay puede recuperar direcciones conocidas y servicios inalámbricos que anuncien el identificador del teléfono guardado; no activa puertos de depuración ni empareja dispositivos desconocidos automáticamente.
+
+Para elegir otro teléfono, inicia con `--serial SERIAL` usando su identificador de `adb devices -l`. Si hay varios teléfonos diferentes y ninguno seleccionado, el lector pide seleccionar uno. El panel distingue conexión USB, Wi-Fi y espera de una ronda legible. Al enviar Tabletop Battles al fondo se conserva el último marcador; al volver a la ronda, la lectura se reanuda. Durante una reconexión puede haber una pausa de unos segundos.

package/device_connection.py

@@ -0,0 +1,113 @@
+"""Track one physical Android device across authorized ADB transports."""
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+
+
+def run_adb(*args):
+    return subprocess.run([os.environ.get('OVERLAY_ADB', 'adb'), *args],
+                          capture_output=True, text=True, encoding='utf-8',
+                          errors='replace', check=True, timeout=5).stdout
+
+
+def devices(output):
+    rows = []
+    for line in output.splitlines():
+        fields = line.split()
+        if len(fields) >= 2 and not line.startswith(('List of', '*')):
+            serial = fields[0]
+            wireless = ':' in serial or '._adb-tls-connect._tcp' in serial
+            rows.append({'serial': serial, 'state': fields[1],
+                         'transport': 'wifi' if wireless else 'usb'})
+    return rows
+
+
+class DeviceConnection:
+    def __init__(self, serial='', path=None, run=run_adb, now=time.monotonic):
+        self.run, self.now, self.explicit = run, now, serial
+        self.path = Path(path) if path else None
+        self.identity, self.aliases = None, set()
+        self.retry_at = 0
+        if self.path:
+            try:
+                saved = json.loads(self.path.read_text())
+                if not serial or serial in saved.get('aliases', []):
+                    self.identity = saved.get('identity')
+                    self.aliases = set(saved.get('aliases', []))
+            except (OSError, ValueError, TypeError):
+                pass
+
+    def identify(self, serial):
+        for prop in ('ro.serialno', 'ro.boot.serialno'):
+            try:
+                value = self.run('-s', serial, 'shell', 'getprop', prop).strip()
+                if value and value.lower() not in ('unknown', 'null'):
+                    return value
+            except (OSError, subprocess.SubprocessError):
+                pass
+        return None
+
+    def remember(self, matching):
+        self.aliases.update(d['serial'] for d in matching)
+        if self.path:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            temp = self.path.with_suffix('.tmp')
+            temp.write_text(json.dumps({'identity': self.identity, 'aliases': sorted(self.aliases)}))
+            temp.replace(self.path)
+
+    def reconnect(self):
+        if not self.identity or self.now() < self.retry_at:
+            return
+        self.retry_at = self.now() + 15
+        targets = {a for a in self.aliases if ':' in a and not a.startswith('adb-')}
+        # Only discover services advertising the remembered device, never arbitrary LAN phones.
+        try:
+            for line in self.run('mdns', 'services').splitlines():
+                fields = line.split()
+                if (len(fields) >= 3 and fields[0].startswith('adb-' + self.identity + '-')
+                        and '_adb-tls-connect._tcp' in fields[1]):
+                    targets.add(fields[2])
+        except (OSError, subprocess.SubprocessError):
+            pass
+        for target in sorted(targets)[:4]:
+            if re.fullmatch(r'[A-Za-z0-9.\-\[\]:]+:\d+', target):
+                try:
+                    self.run('connect', target)
+                except (OSError, subprocess.SubprocessError):
+                    pass
+
+    def select(self):
+        rows = devices(self.run('devices', '-l'))
+        ready = [d for d in rows if d['state'] == 'device']
+        # Verify the physical identity even for remembered IP addresses: DHCP can reuse them.
+        for d in ready:
+            d['identity'] = self.identify(d['serial'])
+        if self.identity:
+            matching = [d for d in ready if d['identity'] == self.identity]
+        elif self.explicit:
+            matching = [d for d in ready if d['serial'] == self.explicit]
+            if matching:
+                self.identity = matching[0]['identity']
+                if self.identity:
+                    matching = [d for d in ready if d['identity'] == self.identity]
+        else:
+            identities = {d['identity'] or d['serial'] for d in ready}
+            if len(identities) > 1:
+                raise ValueError('Hay varios teléfonos diferentes. Selecciona uno con --serial SERIAL.')
+            matching = ready
+            if matching:
+                self.identity = matching[0]['identity']
+        if not matching:
+            self.reconnect()
+            if any(d['state'] == 'unauthorized' for d in rows):
+                raise ValueError('Autoriza este computador en el teléfono; para Wi-Fi completa el emparejamiento de depuración inalámbrica.')
+            raise ValueError('Reconectando al teléfono seleccionado por USB o Wi-Fi. Comprueba la conexión y la depuración inalámbrica.')
+        # If identity is unavailable, stick to the chosen transport, never guess another phone.
+        chosen = sorted(matching, key=lambda d: d['transport'] != 'usb')[0]
+        if not self.identity:
+            self.explicit = chosen['serial']
+        self.remember(matching)
+        return chosen

package/diagnostics.js

@@ -33,6 +33,12 @@ function check(options={}){
  if(py.status!==0)return {ok:false,code:'PYTHON_VERSION',message:'Se necesita Python 3.8 o posterior. Usa --python /ruta/a/python3.',adb,python};
  const result=spawnSync(adb,['devices','-l'],{encoding:'utf8',timeout:15000});
  if(result.error||result.status!==0)return {ok:false,code:'ADB_ERROR',message:'ADB no pudo consultar el teléfono: '+(result.error?.message||(result.stderr||'').trim()).slice(0,600),adb,python};
- return {...deviceStatus(result.stdout,options.serial),adb,python};
+ let status=deviceStatus(result.stdout,options.serial);
+ // USB and wireless transports can be the same physical phone.
+ if(status.code==='MULTIPLE_DEVICES'){
+  const probe=spawnSync(python,['-c', 'import json; from device_connection import DeviceConnection; print(json.dumps(DeviceConnection().select()))'],{cwd:__dirname,env:{...process.env,OVERLAY_ADB:adb},encoding:'utf8',timeout:20000,windowsHide:true});
+  if(probe.status===0){try{const d=JSON.parse(probe.stdout);status={ok:true,code:'READY',message:'Teléfono conectado por '+(d.transport==='wifi'?'Wi-Fi.':'USB.'),serial:d.serial};}catch{}}
+ }
+ return {...status,adb,python};
 }
 module.exports={locate,deviceStatus,check,findPython};

package/game-store.js

@@ -2,7 +2,7 @@ const {inferTurn}=require('./turn-tracker');
 const emptyGame=()=>({players:[],connected:false,updatedAt:null,error:null});
 function mergeGame(previous,incoming){
  if(!incoming.connected || !Array.isArray(incoming.players) || incoming.players.length!==2)
-  return {...previous,connected:false,error:incoming.error||'Sin lectura válida'};
+  return {...previous,connected:false,phoneConnected:incoming.phoneConnected===true,transport:incoming.transport||null,error:incoming.error||'Sin lectura válida'};
  const same=previous.round===incoming.round && previous.players?.length===2 && incoming.players.every(p=>previous.players.some(old=>old.name===p.name));
  const players=incoming.players.map(p=>{
   const old=same?previous.players.find(old=>old.name===p.name):null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ing.jorgeu/wargaming-overlay",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Overlay local para OBS con lectura Android por ADB",
   "bin": {
     "wargaming-overlay": "cli.js"
@@ -32,7 +32,8 @@
     "announcements.js",
     "data/faction-facts.json",
     "factions.js",
-    "scripts/fact-coverage.js"
+    "scripts/fact-coverage.js",
+    "device_connection.py"
   ],
   "license": "0BSD",
   "publishConfig": {

package/public/control.js

@@ -47,7 +47,7 @@ document.querySelector('#reset-game').addEventListener('click',async()=>{
  catch {document.querySelector('#reset-status').textContent='No se pudo restablecer. Comprueba que el servidor esté actualizado y funcionando.';}
  finally{button.disabled=false}
 });
-async function phoneStatus(){try{const r=await fetch('/game-state.json',{cache:'no-store'});const g=await r.json();document.querySelector('#turn-status').textContent=(g.half==='top'?'TOP · Primer turno. ':g.half==='bottom'?'BOTTOM · Segundo turno. ':'Turno automático: ')+(g.turn?.reason||'Esperando actividad de puntuación.');document.querySelector('#phone-status').textContent=g.connected?'Teléfono conectado.':(g.error||'Sin conexión.')+(g.players?.length?' Se conserva la última lectura.':'');}catch{document.querySelector('#phone-status').textContent='Servidor no disponible.'}finally{setTimeout(phoneStatus,3000)}}phoneStatus();
+async function phoneStatus(){try{const r=await fetch('/game-state.json',{cache:'no-store'});const g=await r.json();document.querySelector('#turn-status').textContent=(g.half==='top'?'TOP · Primer turno. ':g.half==='bottom'?'BOTTOM · Segundo turno. ':'Turno automático: ')+(g.turn?.reason||'Esperando actividad de puntuación.');document.querySelector('#phone-status').textContent=g.connected?`Teléfono conectado por ${g.transport==='wifi'?'Wi-Fi':'USB'}.`:(g.phoneConnected?`Teléfono conectado por ${g.transport==='wifi'?'Wi-Fi':'USB'}. `:'')+(g.error||'Reconectando…')+(g.players?.length?' Se conserva la última lectura.':'');}catch{document.querySelector('#phone-status').textContent='Servidor no disponible.'}finally{setTimeout(phoneStatus,3000)}}phoneStatus();
 
 document.querySelector('#obs-url').textContent=location.origin+'/overlay-art.html';
 

package/reader.py

@@ -5,32 +5,23 @@ from battle_reader import parse, capture
 ADB = os.environ.get('OVERLAY_ADB', 'adb')
 SERIAL = os.environ.get('OVERLAY_SERIAL', '')
 
-def select_device(output):
-    devices = [line.split()[:2] for line in output.splitlines() if line.strip() and not line.startswith(('List of', '*'))]
-    if not devices:
-        raise ValueError('ADB no detecta un teléfono. Conecta un cable de datos, desbloquea Android y activa Opciones de desarrollador → Depuración USB. No se puede distinguir cable desconectado de depuración desactivada.')
-    if not SERIAL and len(devices) > 1:
-        raise ValueError('Hay varios dispositivos. Reinicia con --serial SERIAL: ' + ', '.join(d[0] for d in devices))
-    device = next((d for d in devices if d[0] == SERIAL), None) if SERIAL else devices[0]
-    if not device: raise ValueError('El dispositivo seleccionado no está conectado: ' + SERIAL)
-    serial, status = device
-    if status == 'unauthorized': raise ValueError('Teléfono sin autorizar. Desbloquéalo y acepta «Permitir depuración USB» para este equipo. Si no aparece, reconecta el cable.')
-    if status == 'no': raise ValueError('Sin permisos USB. Revisa reglas udev y grupos del usuario; en Ubuntu, android-sdk-platform-tools-common y plugdev. Vuelve a iniciar sesión después de cambiar grupos.')
-    if status == 'offline': raise ValueError('Teléfono offline. Desbloquéalo y reconecta el cable USB.')
-    if status != 'device': raise ValueError('Dispositivo no disponible: ' + status)
-    return serial
+from device_connection import DeviceConnection
+from pathlib import Path
 
 if __name__ == '__main__':
+    data_dir = os.environ.get('OVERLAY_DATA_DIR')
+    connection = DeviceConnection(SERIAL, Path(data_dir) / 'phone-connection.json' if data_dir else None)
     while True:
+        device = None
         try:
-            result = subprocess.run([ADB, 'devices', '-l'], capture_output=True, text=True, encoding='utf-8', errors='replace', check=True, timeout=10)
-            serial = select_device(result.stdout)
+            device = connection.select()
+            serial = device['serial']
             state = parse(capture(serial))
-            print(json.dumps(dict(state, connected=True, updatedAt=time.time(), error=None)), flush=True)
+            print(json.dumps(dict(state, connected=True, phoneConnected=True, transport=device["transport"], deviceSerial=serial, updatedAt=time.time(), error=None)), flush=True)
         except Exception as e:
             message = str(e)
             if isinstance(e, subprocess.TimeoutExpired): message = 'El teléfono no respondió a tiempo. Desbloquéalo y abre la ronda; volveré a intentar la lectura.'
             elif isinstance(e, subprocess.CalledProcessError): message = 'No se pudo leer Android. Abre la ronda y cierra otros lectores UIAutomator. Se reintentará. ' + (e.stderr or '').strip()[:300]
             elif isinstance(e, FileNotFoundError): message = 'ADB no está disponible. Ejecuta wargaming-overlay setup --install-adb.'
-            print(json.dumps({'connected':False, 'error':message}), flush=True)
+            print(json.dumps({'connected':False, 'phoneConnected':device is not None and isinstance(e, ValueError), 'transport':device['transport'] if device is not None else None, 'error':message}), flush=True)
         time.sleep(float(os.environ.get('OVERLAY_INTERVAL', '3')))