diff --git a/CMBNet/README_CMBNet.md b/CMBNet/README_CMBNet.md index 5b9dfd8..548c61f 100644 --- a/CMBNet/README_CMBNet.md +++ b/CMBNet/README_CMBNet.md @@ -125,7 +125,12 @@ Die Zeitfenster lassen sich über Umgebungsvariablen konfigurieren: die zu lange Unterbrechung zugestellt. - `CMBNET_WS_CLIENT_RETENTION_MINUTES` (Default `60`): Wie lange eine nicht mehr verbundene Webview samt Queue registriert bleibt, bevor der Broker sie - endgültig aufräumt. + endgültig aufräumt. Clients mit gültigem FCM-Token bleiben länger erhalten. +- `CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` (Default `180`): Zeit ohne + Lebenszeichen (Pong oder beliebige eingehende WebSocket-Nachricht), nach der + der Server eine halb offene Verbindung schließt und den Client als getrennt + markiert. Erst dadurch werden schlafende Mobilgeräte zuverlässig als + „offline“ erkannt. - `CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS` (Default `120`): Zeit ohne Code-2- Lebenszeichen, nach der eine Gruppe von `online` auf `unterwegs` wechselt. - `CMBNET_WS_DEBUG_MESSAGES` (Default `1`): schreibt jede beim Broker diff --git a/CMBNet/cmbnet/api/push.py b/CMBNet/cmbnet/api/push.py index 8df8562..3953262 100644 --- a/CMBNet/cmbnet/api/push.py +++ b/CMBNet/cmbnet/api/push.py @@ -115,6 +115,7 @@ def wake_mobile_clients(**kwargs): return jsonify({'ok': False, 'error': 'Ungültige Gruppen-ID.'}), 400 current = store.now() + stats = store.mobile_push_stats(g.tenant_id) cooldown = max(0, int(current_app.config.get( 'FCM_MANUAL_WAKE_COOLDOWN_SECONDS', 15 ))) @@ -140,11 +141,21 @@ def wake_mobile_clients(**kwargs): for token in invalid_tokens: store.mark_push_token_invalid(token) + current_app.logger.info( + 'FCM-Wake manuell: tenant=%s group=%s tokens=%s verbunden=%s ' + 'candidates=%s sent=%s failed=%s', + g.tenant_id, group_id, stats['valid_tokens'], stats['connected'], + len(candidates), int(result.get('sent') or 0), + int(result.get('failed') or 0) + ) + return jsonify({ 'ok': True, 'configured': bool(result.get('configured')), 'candidates': len(candidates), 'sent': int(result.get('sent') or 0), 'failed': int(result.get('failed') or 0), + 'valid_tokens': stats['valid_tokens'], + 'connected': stats['connected'], 'error': result.get('error'), }) diff --git a/CMBNet/cmbnet/db/database.py b/CMBNet/cmbnet/db/database.py index 37030da..e45ec3c 100644 --- a/CMBNet/cmbnet/db/database.py +++ b/CMBNet/cmbnet/db/database.py @@ -99,6 +99,12 @@ def ensure_ws_schema(db): FOREIGN KEY (group_id) REFERENCES groups(id) ); + CREATE TABLE IF NOT EXISTS ws_workers ( + worker_id TEXT PRIMARY KEY, + started_at REAL NOT NULL, + heartbeat_at REAL NOT NULL + ); + CREATE TABLE IF NOT EXISTS cache_state ( key TEXT PRIMARY KEY, revision INTEGER NOT NULL DEFAULT 0, diff --git a/CMBNet/cmbnet/ws/broker.py b/CMBNet/cmbnet/ws/broker.py index 29c04e7..09e89a3 100644 --- a/CMBNet/cmbnet/ws/broker.py +++ b/CMBNet/cmbnet/ws/broker.py @@ -122,6 +122,10 @@ class WebSocketBroker: ): return False + # Der Worker ist offensichtlich aktiv; sein Lebenszeichen verhindert, + # dass andere Worker seine Clients fälschlich als verwaist markieren. + store.touch_worker(self.worker_id) + # Für Gruppen-Accounts die zugehörige Gruppe ermitteln. Ein Account der # Rolle "Gruppe" ist höchstens einer Gruppe zugeordnet. if group_id is None and role == 'Gruppe': @@ -161,6 +165,11 @@ class WebSocketBroker: 'last_ping': datetime.now(), 'connected_at': time.monotonic(), 'last_pong_at': None, + # Zeitpunkt des letzten beliebigen Lebenszeichens. Wird beim + # Handshake gesetzt und bei jeder eingehenden Nachricht + # aktualisiert, damit auch Clients ohne Pong nicht fälschlich + # als tot gelten. + 'last_seen_at': time.time(), # Zuletzt an diese Client-ID zugestellte Sequenznummer. Die # maßgebliche Zählung liegt in ws_clients und überlebt damit einen # Worker-Wechsel. @@ -283,6 +292,8 @@ class WebSocketBroker: store.set_group_online_since(tenant_id, conn['group_id']) self.authenticated.setdefault(tenant_id, {})[client_id] = True + conn['last_seen_at'] = time.time() + conn['last_pong_at'] = conn['last_seen_at'] store.mark_authenticated( tenant_id, client_id, True, worker_id=self.worker_id ) @@ -359,6 +370,60 @@ class WebSocketBroker: tenant_id, client_id, worker_id=self.worker_id ) + def check_client_liveness(self, timeout_seconds): + """Trennt authentifizierte Verbindungen ohne Lebenszeichen. + + Ein sauber geschlossener WebSocket wird bereits in der WS-Route + erkannt. Mobile Geräte verlieren die Verbindung beim Schlafenlegen + jedoch oft ohne FIN/RST; der Server sieht dann scheinbar eine offene + Verbindung und markiert den Client nie als getrennt. Diese Prüfung + schließt solche halb offenen Verbindungen nach ``timeout_seconds`` + und macht sie damit für FCM-Aufwachsignale sichtbar. + + Rückgabe: Anzahl der getrennten Verbindungen. + """ + try: + timeout_seconds = float(timeout_seconds) + except (TypeError, ValueError): + timeout_seconds = 0 + if timeout_seconds <= 0: + return 0 + + now = time.time() + disconnected = 0 + for tenant_id, connections in list(self.connections.items()): + for client_id, conn in list(connections.items()): + if not self.is_authenticated(tenant_id, client_id): + continue + + last_seen = conn.get('last_seen_at') or conn.get('last_pong_at') + if last_seen is None: + # Sehr alte Verbindungsobjekte haben noch keinen + # Zeitstempel; sie erhalten eine Gnadenfrist. + conn['last_seen_at'] = now + continue + if now - last_seen <= timeout_seconds: + continue + + ws = conn.get('ws') + try: + if ws is not None: + ws.close() + except Exception: + pass + self.remove_connection(tenant_id, client_id, ws) + disconnected += 1 + + try: + current_app.logger.info( + 'WebSocket-Verbindung ohne Lebenszeichen getrennt: ' + 'tenant=%s client=%s last_seen=%.0fs', + tenant_id, client_id, now - last_seen + ) + except Exception: + pass + return disconnected + def _get_connection(self, tenant_id, client_id): return self.connections.get(tenant_id, {}).get(client_id) @@ -835,6 +900,9 @@ class WebSocketBroker: """ if client_id: message._sender_client_id = client_id + conn = self._get_connection(tenant_id, client_id) + if conn is not None: + conn['last_seen_at'] = time.time() db = get_db() diff --git a/CMBNet/cmbnet/ws/heartbeat.py b/CMBNet/cmbnet/ws/heartbeat.py index 0670f0f..1be194b 100644 --- a/CMBNet/cmbnet/ws/heartbeat.py +++ b/CMBNet/cmbnet/ws/heartbeat.py @@ -9,7 +9,7 @@ Zusätzlich räumt die Routine abgelaufene Late-Entry-Nachrichten auf, damit die Tabelle ws_messages_store nicht unbegrenzt wächst. """ from threading import Timer -from cmbnet.ws import broker +from cmbnet.ws import broker, store from cmbnet.ws.protocol import WSMessage @@ -75,6 +75,17 @@ class HeartbeatManager: # Sequenznummern liegen inzwischen in der gemeinsamen # SQLite-Datenbank und werden beim Senden fortgeschrieben. with self.app.app_context(): + # Eigenes Lebenszeichen aktualisieren, bevor verwaiste + # Clients anderer Worker erkannt werden. + timeout = self.app.config.get( + 'WS_CLIENT_OFFLINE_TIMEOUT_SECONDS', + max(180, int(self.interval) * 3) + ) + store.touch_worker(broker.worker_id) + store.mark_orphan_clients_disconnected( + store.now() - max(1, int(timeout)) + ) + # Nur authentifizierte Verbindungen erhalten einen # Heartbeat. for tenant_id, connections in list(broker.connections.items()): @@ -85,6 +96,14 @@ class HeartbeatManager: tenant_id, client_id, msg.to_json() ) + # Halb offene Verbindungen erkennen. Ein mobiles Gerät + # verliert beim Schlafenlegen oft die Verbindung, ohne + # dass der Server ein FIN/RST erhält. Ohne diese Prüfung + # bliebe der Client dauerhaft als "verbunden" markiert + # und würde nie über FCM geweckt. + broker.check_client_liveness(timeout) + store.cleanup_worker_registry(max(600, int(timeout) * 4)) + # Abgelaufene persistierte Nachrichten und Client-Queues # löschen. broker.cleanup_client_queues() diff --git a/CMBNet/cmbnet/ws/store.py b/CMBNet/cmbnet/ws/store.py index 8ab3982..f5d6ab2 100644 --- a/CMBNet/cmbnet/ws/store.py +++ b/CMBNet/cmbnet/ws/store.py @@ -294,6 +294,61 @@ def get_push_token(tenant_id, client_id): ).fetchone() +def touch_worker(worker_id, timestamp=None): + """Aktualisiert das Lebenszeichen eines WSGI-Workers.""" + if not worker_id: + return + current = now() if timestamp is None else timestamp + db = get_db() + db.execute( + '''INSERT INTO ws_workers (worker_id, started_at, heartbeat_at) + VALUES (?, ?, ?) + ON CONFLICT(worker_id) DO UPDATE SET + heartbeat_at = excluded.heartbeat_at''', + (worker_id, current, current) + ) + db.commit() + + +def mark_orphan_clients_disconnected(active_since): + """Markiert Clients von nicht mehr lebenden Workern als getrennt. + + Nach einem Neustart bleiben in ``ws_clients`` Einträge mit + ``disconnected_at IS NULL`` zurück, obwohl die zugehörige Verbindung nur + im Speicher des alten Prozesses existierte. Ohne diese Bereinigung würden + solche Clients nie als Wake-Kandidaten erscheinen. Clients eines Workers, + dessen Heartbeat noch innerhalb von ``active_since`` liegt, bleiben + unberührt. + """ + db = get_db() + cursor = db.execute( + '''UPDATE ws_clients + SET worker_id = NULL, disconnected_at = ?, authenticated = 0 + WHERE disconnected_at IS NULL + AND ( + worker_id IS NULL + OR NOT EXISTS ( + SELECT 1 FROM ws_workers w + WHERE w.worker_id = ws_clients.worker_id + AND w.heartbeat_at >= ? + ) + )''', + (now(), active_since) + ) + db.commit() + return cursor.rowcount + + +def cleanup_worker_registry(max_age_seconds): + """Entfernt Lebenszeichen-Einträge beendeter Worker.""" + db = get_db() + db.execute( + 'DELETE FROM ws_workers WHERE heartbeat_at < ?', + (now() - max_age_seconds,) + ) + db.commit() + + def mark_push_token_invalid(token): """Markiert ein von FCM abgelehntes Token als ungültig.""" db = get_db() @@ -323,7 +378,7 @@ def _offline_mobile_wake_query(tenant_id, disconnected_before, LIMIT 1 ) WHERE c.tenant_id = ? - AND c.client_type IN ('group_view', 'dispatcher_mobile') + AND p.client_type IN ('group_view', 'dispatcher_mobile') AND c.disconnected_at IS NOT NULL AND c.disconnected_at <= ?''' ] @@ -423,8 +478,47 @@ def claim_offline_mobile_wakes(tenant_id, disconnected_before, raise +def mobile_push_stats(tenant_id): + """Liefert Diagnosezahlen für den manuellen FCM-Wake. + + ``valid_tokens`` zählt registrierte, nicht von FCM abgelehnte Tokens + mobiler Webviews. ``connected`` zählt die davon aktuell als verbunden + geltenden Clients. Damit lässt sich in der Oberfläche unterscheiden, ob + die Registrierung oder die Offline-Erkennung das Problem ist. + """ + db = get_db() + valid_tokens = db.execute( + '''SELECT COUNT(*) FROM ws_push_tokens + WHERE tenant_id = ? AND invalid = 0 + AND client_type IN ('group_view', 'dispatcher_mobile')''', + (tenant_id,) + ).fetchone()[0] + connected = db.execute( + '''SELECT COUNT(DISTINCT c.client_id) + FROM ws_clients c + JOIN ws_push_tokens p + ON p.tenant_id = c.tenant_id + AND p.client_id = c.client_id + AND p.invalid = 0 + WHERE c.tenant_id = ? + AND p.client_type IN ('group_view', 'dispatcher_mobile') + AND c.disconnected_at IS NULL''', + (tenant_id,) + ).fetchone()[0] + return { + 'valid_tokens': int(valid_tokens or 0), + 'connected': int(connected or 0), + } + + def cleanup_orphan_push_tokens(max_age_seconds): - """Entfernt ungültige sowie verwaiste, lange nicht aktualisierte Tokens.""" + """Entfernt ungültige sowie veraltete, nicht mehr verbundene Tokens. + + Tokens von aktuell verbundenen Clients bleiben erhalten, auch wenn die + Registrierung länger zurückliegt. Getrennte Tokens werden erst nach der + (bewusst großzügigen) Aufbewahrungsfrist entfernt, damit auch über Nacht + schlafende Mobilgeräte noch geweckt werden können. + """ db = get_db() cutoff = now() - max_age_seconds db.execute( @@ -437,6 +531,7 @@ def cleanup_orphan_push_tokens(max_age_seconds): SELECT 1 FROM ws_clients c WHERE c.tenant_id = ws_push_tokens.tenant_id AND c.client_id = ws_push_tokens.client_id + AND c.disconnected_at IS NULL )''', (cutoff,) ) @@ -713,6 +808,20 @@ def cleanup_clients(retention_seconds): 'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?', (tenant_id, client_id) ) + + # Ein gültiges FCM-Token hält den Client-Eintrag am Leben. Sonst + # würden schlafende Mobilgeräte schon nach der kurzen + # Client-Aufbewahrung samt Token verschwinden und könnten nie wieder + # geweckt werden. Das Token selbst wird über + # ``cleanup_orphan_push_tokens`` mit eigener Frist aufgeräumt. + has_push_token = db.execute( + 'SELECT 1 FROM ws_push_tokens ' + 'WHERE tenant_id = ? AND client_id = ? AND invalid = 0 LIMIT 1', + (tenant_id, client_id) + ).fetchone() + if has_push_token is not None: + continue + db.execute( 'DELETE FROM ws_push_tokens WHERE tenant_id = ? AND client_id = ?', (tenant_id, client_id) diff --git a/CMBNet/config.py b/CMBNet/config.py index 1fac2c3..6c07df1 100644 --- a/CMBNet/config.py +++ b/CMBNet/config.py @@ -19,6 +19,13 @@ class Config: WS_GROUP_ONLINE_TIMEOUT_SECONDS = int( os.environ.get('CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS', '120') ) + # Wartezeit ohne Lebenszeichen, nach der eine WebSocket-Verbindung als + # verloren gilt. Der Server sendet jede ``WS_HEARTBEAT_INTERVAL`` Sekunde + # einen Ping; der Timeout muss deutlich darüber liegen, damit ein + # einzelner ausgefallener Pong die Verbindung nicht sofort trennt. + WS_CLIENT_OFFLINE_TIMEOUT_SECONDS = int( + os.environ.get('CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS', '180') + ) # Wie lange nicht zustellbare Nachrichten pro Client vorgehalten werden, # bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden. WS_QUEUE_MAX_AGE_MINUTES = int( @@ -114,8 +121,11 @@ class Config: FCM_WAKE_POLL_INTERVAL_SECONDS = float(os.environ.get( 'CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS', '30' )) + # FCM-Tokens bleiben auch für länger schlafende Geräte erhalten. Sie + # werden erst entfernt, wenn sie von FCM abgelehnt wurden oder das Gerät + # über diesen Zeitraum weder verbunden noch neu registriert war. FCM_PUSH_TOKEN_RETENTION_MINUTES = int(os.environ.get( - 'CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES', '1440' + 'CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES', '43200' )) # Ausführliche Broker-Debugausgabe für eingehende Nachrichten und den # ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable diff --git a/CMBNet/docs/FCM_ARCHITEKTUR.md b/CMBNet/docs/FCM_ARCHITEKTUR.md index be9b9ee..61f3f03 100644 --- a/CMBNet/docs/FCM_ARCHITEKTUR.md +++ b/CMBNet/docs/FCM_ARCHITEKTUR.md @@ -18,7 +18,8 @@ Sie sind kein Anwendungsinhalt. | Komponente | Aufgabe | | --- | --- | -| `cmbnet/ws/broker.py` | Erkennt nicht zustellbare Nachrichten und fordert ein Wake-Signal an. | +| `cmbnet/ws/broker.py` | Erkennt nicht zustellbare Nachrichten, trennt Verbindungen ohne Lebenszeichen und fordert ein Wake-Signal an. | +| `cmbnet/ws/heartbeat.py` | Sendet Code-1-Pings und prüft, ob Clients noch antworten. | | `cmbnet/ws/push.py` | Periodischer Worker für den Offline-Timeout. | | `cmbnet/services/fcm_service.py` | Firebase-Admin-Initialisierung und FCM-Versand. | | `cmbnet/api/push.py` | Token-Registrierung, Abmeldung und manueller Wake-Button. | @@ -60,6 +61,33 @@ Sobald eine Nachricht mit Code `>= 99` für einen getrennten mobilen Client eingereiht wird, versucht der Broker ein FCM-Signal. Mehrere Nachrichten innerhalb des Queue-Cooldowns lösen nur ein Signal aus. +### Offline-Erkennung + +Ein Client gilt nur dann als offline, wenn der Broker seine WebSocket- +Verbindung als beendet markiert hat (`ws_clients.disconnected_at`). Dafür gibt +es drei Wege: + +1. Ein sauber geschlossener Socket wird in der WS-Route unmittelbar erkannt. +2. Die mobile View schließt ihren Socket beim Wechsel in den Hintergrund + (`visibilitychange`) bzw. beim Verlassen der Seite (`pagehide`). Damit ist + sie sofort offline, ohne auf einen Timeout warten zu müssen. Beim + Sichtbarwerden verbindet sie sich neu und frischt ihr FCM-Token auf. +3. Halb offene Verbindungen, bei denen das Gerät einschläft, ohne FIN/RST zu + senden, werden vom Heartbeat nach + `CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` (Default 180) ohne Lebenszeichen + geschlossen. Als Lebenszeichen zählt ein Code-2-Pong oder jede andere + eingehende WebSocket-Nachricht des Clients. +4. Jeder WSGI-Worker hinterlässt ein Lebenszeichen in `ws_workers`. Clients + eines nicht mehr laufenden Workers – etwa nach einem Neustart – werden + automatisch als getrennt markiert. Das verhindert dauerhaft „verbundene“ + Karteileichen in der Datenbank. + +Ohne Schritt 3 und 4 blieben schlafende Geräte bzw. Clients aus einem alten +Prozess dauerhaft als „verbunden“ markiert und würden nie als Wake-Kandidaten +erscheinen. `ws_clients`-Einträge mit gültigem FCM-Token werden beim normalen +Client-Aufräumen nicht entfernt; das Token hat eine eigene, großzügigere +Aufbewahrungsfrist. + ### Offline-Timeout Ein periodischer Worker prüft getrennte Clients. Nach @@ -96,6 +124,11 @@ Desktop-Dispatcher erhalten keine FCM-Behandlung. - `client_type`: Client-Typ für das FCM-Routing - `last_wake_at`, `last_wake_reason`: Drosselung und Nachvollziehbarkeit +Neue Tabelle `ws_workers`: + +- Lebenszeichen je WSGI-Worker (`started_at`, `heartbeat_at`) +- dient der Erkennung verwaister Clients nach einem Worker-Neustart + Neue Tabelle `ws_push_tokens`: - ein FCM-Token ist projektweit eindeutig @@ -105,8 +138,9 @@ Neue Tabelle `ws_push_tokens`: Die Registrierung wird bei einem Reload mit neuer Client-ID auf die neue Client-ID verschoben. Nach einer Token-Rotation wird das alte Token derselben -Webview entfernt. Verwaiste Tokens werden zusammen mit den Client-Queues -aufgeräumt. +Webview entfernt. Verwaiste Tokens werden mit einer eigenen Frist aufgeräumt; +der zugehörige `ws_clients`-Eintrag bleibt so lange erhalten. Die +Client-Queues werden weiterhin nach der kürzeren Queue-Frist bereinigt. ## Mehrere Worker @@ -140,7 +174,8 @@ inaktiv: | `CMBNET_FCM_MANUAL_WAKE_COOLDOWN_SECONDS` | `15` | Cooldown für den Button | | `CMBNET_FCM_SIGNAL_TTL_SECONDS` | `600` | FCM-TTL | | `CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS` | `30` | Prüfintervall des Workers | -| `CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES` | `1440` | Aufbewahrung verwaister Tokens | +| `CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES` | `43200` | Aufbewahrung nicht verbundener Tokens (30 Tage) | +| `CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` | `180` | Zeit ohne Lebenszeichen bis zur Offline-Markierung | ## Beschränkungen und Konsequenzen bei PWAs diff --git a/CMBNet/migrations/schema.sql b/CMBNet/migrations/schema.sql index 84e17fc..1a14985 100644 --- a/CMBNet/migrations/schema.sql +++ b/CMBNet/migrations/schema.sql @@ -214,6 +214,15 @@ CREATE TABLE IF NOT EXISTS ws_group_presence ( FOREIGN KEY (group_id) REFERENCES groups(id) ); +-- Lebenszeichen der WSGI-Worker. Clients eines Workers, dessen Heartbeat +-- länger als der Offline-Timeout zurückliegt (z. B. nach einem Neustart), +-- werden als getrennt markiert und können über FCM geweckt werden. +CREATE TABLE IF NOT EXISTS ws_workers ( + worker_id TEXT PRIMARY KEY, + started_at REAL NOT NULL, + heartbeat_at REAL NOT NULL +); + -- Workerübergreifende Cache-Revisionen. Jeder Worker vergleicht die Revision -- seines In-Memory-Caches mit diesem Wert und lädt bei Abweichung neu. CREATE TABLE IF NOT EXISTS cache_state ( diff --git a/CMBNet/static/js/views/dispatcher.js b/CMBNet/static/js/views/dispatcher.js index 1dbde3a..96d6032 100644 --- a/CMBNet/static/js/views/dispatcher.js +++ b/CMBNet/static/js/views/dispatcher.js @@ -3656,7 +3656,12 @@ async function wakeMobileClients() { if (sent > 0) { setStreetSearchStatus(`${sent} mobile Clients geweckt.`); } else { - setStreetSearchStatus('Keine offline mobilen Clients mit Push-Token gefunden.'); + const tokens = Number(result.valid_tokens) || 0; + const connected = Number(result.connected) || 0; + setStreetSearchStatus( + 'Keine offline mobilen Clients mit Push-Token gefunden ' + + `(registriert: ${tokens}, verbunden: ${connected}).` + ); } setTimeout(() => setStreetSearchStatus(''), 5000); } catch (error) { diff --git a/CMBNet/static/js/views/mobile.js b/CMBNet/static/js/views/mobile.js index 8152a36..d5febb6 100644 --- a/CMBNet/static/js/views/mobile.js +++ b/CMBNet/static/js/views/mobile.js @@ -156,6 +156,38 @@ async function initMobile() { } if (state.ws) state.ws.close(); }); + + // ``pagehide`` wird auf mobilen Browsern zuverlässiger ausgelöst als + // ``beforeunload``, wenn die PWA verlassen oder eingefroren wird. + window.addEventListener('pagehide', () => { + if (state.ws) state.ws.close(); + }); + + document.addEventListener('visibilitychange', () => { + if (document.hidden) { + // Im Hintergrund kann die View nicht bedient werden und mobile + // Browser frieren die Verbindung ohnehin ein. Das saubere + // Schließen markiert den Client sofort als offline, sodass der + // manuelle Wake-Button ihn über FCM erreichen kann. + if (state.reconnectTimer) { + clearTimeout(state.reconnectTimer); + state.reconnectTimer = null; + } + if (state.ws) { + const ws = state.ws; + state.ws = null; + state.authenticated = false; + try { ws.close(); } catch (error) {} + } + setMobileWsStatus('getrennt', 'disconnected'); + return; + } + + // Beim Zurückkehren sofort wieder verbinden und die Token- + // Registrierung auffrischen (verhindert veraltete Tokens). + syncPushRegistration(); + connectWebSocket(); + }); } function fetchJson(url, options={}) { @@ -629,7 +661,12 @@ async function wakeMobileClientsFromUi() { if (sent > 0) { showMobileToast(`${sent} mobile Clients geweckt.`); } else { - showMobileToast('Keine offline mobilen Clients mit Push-Token gefunden.'); + const tokens = Number(result.valid_tokens) || 0; + const connected = Number(result.connected) || 0; + showMobileToast( + 'Keine offline mobilen Clients mit Push-Token gefunden ' + + `(registriert: ${tokens}, verbunden: ${connected}).` + ); } } catch (error) { showMobileToast(`Wecken fehlgeschlagen: ${error.message}`, true); @@ -1748,6 +1785,9 @@ function setMobileWsStatus(label, status) { } function scheduleMobileReconnect() { + // Im Hintergrund nicht in einer Reconnect-Schleife hängen bleiben. Die + // Verbindung wird beim nächsten Sichtbarwerden wieder aufgebaut. + if (document.hidden) return; if (state.reconnectTimer) return; state.reconnectTimer = setTimeout(() => { state.reconnectTimer = null; @@ -2132,6 +2172,9 @@ function handleWs(event) { setMobileWsStatus('verbunden', 'connected'); flushWsOutbox(); resolveWsAuthentication(); + // Token-Aktualität erhalten, damit die FCM-Aufbewahrung auch bei + // lange laufenden PWAs nicht abläuft. + syncPushRegistration(); } else if (message.code === 1) { setMobileWsStatus('verbunden', 'connected'); if (state.ws && state.ws.readyState === WebSocket.OPEN) {