bug fix shutdown/reconnect WS resultiert in offline für FCM

This commit is contained in:
concierge committed 2026-11-09 09:15:34 +01:00
1 parent c51ef02f88
commit b5f928bf76
11 files changed
+331 -11

No files matched your search

+6 -1
View File
@@ -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
+11
View File
@@ -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'),
})
+6
View File
@@ -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,
+68
View File
@@ -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()
+20 -1
View File
@@ -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()
+111 -2
View File
@@ -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)
+11 -1
View File
@@ -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
+39 -4
View File
@@ -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
+9
View File
@@ -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 (
+6 -1
View File
@@ -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) {
+44 -1
View File
@@ -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) {