diff --git a/CMBNet/README_CMBNet.md b/CMBNet/README_CMBNet.md index 548c61f..bdeb3b8 100644 --- a/CMBNet/README_CMBNet.md +++ b/CMBNet/README_CMBNet.md @@ -175,7 +175,10 @@ Mobile Gruppen- und Dispatcher-Views können über Firebase Cloud Messaging Nachrichten und Positionen bleiben in der WebSocket-Kommunikation bzw. in der Broker-Queue. Die Signale werden bei gequeueten Nachrichten, nach einem konfigurierbaren Offline-Timeout und über den Radar-Button im Desktop- und -mobilen Dispatcher ausgelöst. +mobilen Dispatcher ausgelöst. Nachrichten und der manuelle Radar-Button wecken +auch Clients, die der Broker noch als verbunden führt; auf iOS ist der +Verbindungsstatus häufig veraltet. Mit `CMBNET_FCM_WAKE_CONNECTED_CLIENTS=0` +lässt sich dieses zusätzliche Wecken abschalten. Die Architektur, Trigger, Grenzen auf Android/iOS und alle Konfigurationsvariablen stehen in diff --git a/CMBNet/cmbnet/api/push.py b/CMBNet/cmbnet/api/push.py index 3953262..482649e 100644 --- a/CMBNet/cmbnet/api/push.py +++ b/CMBNet/cmbnet/api/push.py @@ -93,11 +93,13 @@ def unregister_push_token(**kwargs): @api_push_bp.route('/push/wake', methods=['POST']) @role_required(['Dispatcher', 'Administrator']) def wake_mobile_clients(**kwargs): - """Löst manuell ein FCM-Aufwachsignal für offline mobile Clients aus. + """Löst manuell ein FCM-Aufwachsignal für mobile Clients aus. Optional kann mit ``group_id`` auf die Clients einer Gruppe eingeschränkt - werden. Es werden nur Clients angesprochen, die aktuell als getrennt - gelten und ein gültiges FCM-Token besitzen. + werden. Angesprochen werden alle mobilen Clients mit gültigem FCM-Token, + unabhängig davon, ob der Broker sie noch als verbunden führt. Gerade auf + iOS bleibt der Verbindungsstatus häufig veraltet, obwohl der Push-Kanal + weiterhin funktioniert. """ config = public_fcm_config() if not config.get('enabled'): @@ -125,6 +127,9 @@ def wake_mobile_clients(**kwargs): re_wake_before=current - cooldown if cooldown else None, group_id=group_id, auto_position_only=False, + # Der Button soll alle registrierten mobilen Clients erreichen – auch + # solche, die der Broker noch als verbunden führt (typisch bei iOS). + include_connected=True, limit=1000, ) diff --git a/CMBNet/cmbnet/ws/broker.py b/CMBNet/cmbnet/ws/broker.py index 09e89a3..729617a 100644 --- a/CMBNet/cmbnet/ws/broker.py +++ b/CMBNet/cmbnet/ws/broker.py @@ -621,6 +621,13 @@ class WebSocketBroker: disconnected_before=current, re_wake_before=current - max(0, cooldown_seconds), client_id=client_id, + # Auch verbundene mobile Clients wecken: Besonders auf iOS + # bleibt der Broker-Status „verbunden“, obwohl der Socket + # nicht mehr erreichbar ist. Der Cooldown verhindert eine + # Flut von Signalen. + include_connected=current_app.config.get( + 'FCM_WAKE_CONNECTED_CLIENTS', True + ), reason=reason, limit=1, ) @@ -1596,6 +1603,15 @@ class WebSocketBroker: # eingereiht, damit die Reihenfolge erhalten bleibt. if conn and authenticated and not store.client_has_queue(tenant_id, client_id): if self.send_to_connection(tenant_id, client_id, message.to_json()): + # Ein erfolgreicher Socket-Schreibvorgang bedeutet nicht, + # dass der Client die Nachricht wirklich empfängt. Gerade + # iOS-Geräte im Hintergrund behalten scheinbar eine offene + # Verbindung. Deshalb wird für mobile Clients zusätzlich ein + # FCM-Signal abgesetzt; der Cooldown verhindert Duplikate. + if message.code >= 99 and current_app.config.get( + 'FCM_WAKE_CONNECTED_CLIENTS', True + ): + self.wake_client(tenant_id, client_id, 'queue') return True self._queue_undeliverable(tenant_id, client_id, message) diff --git a/CMBNet/cmbnet/ws/store.py b/CMBNet/cmbnet/ws/store.py index f5d6ab2..52ccf35 100644 --- a/CMBNet/cmbnet/ws/store.py +++ b/CMBNet/cmbnet/ws/store.py @@ -362,7 +362,7 @@ def mark_push_token_invalid(token): def _offline_mobile_wake_query(tenant_id, disconnected_before, re_wake_before=None, group_id=None, auto_position_only=False, client_id=None, - limit=500): + include_connected=False, limit=500): sql = [ '''SELECT c.tenant_id, c.client_id, c.account_id, c.client_type, c.disconnected_at, c.last_wake_at, c.last_wake_reason, @@ -378,11 +378,20 @@ def _offline_mobile_wake_query(tenant_id, disconnected_before, LIMIT 1 ) WHERE c.tenant_id = ? - AND p.client_type IN ('group_view', 'dispatcher_mobile') - AND c.disconnected_at IS NOT NULL - AND c.disconnected_at <= ?''' + AND p.client_type IN ('group_view', 'dispatcher_mobile')''' ] - params = [tenant_id, disconnected_before] + params = [tenant_id] + + # Standardmäßig nur tatsächlich getrennte Clients. Für den manuellen + # Wake-Button und für zuverlässige Zustellung an iOS-Clients kann bewusst + # auch an als verbunden geltende Clients gesendet werden: Bei iOS ist der + # DB-Status oft unzuverlässig, obwohl Push-Nachrichten den Service Worker + # erreichen. + if not include_connected: + sql.append( + 'AND c.disconnected_at IS NOT NULL AND c.disconnected_at <= ?' + ) + params.append(disconnected_before) if client_id is not None: sql.append('AND c.client_id = ?') @@ -416,8 +425,8 @@ def _offline_mobile_wake_query(tenant_id, disconnected_before, def offline_mobile_wake_candidates(tenant_id, disconnected_before, re_wake_before=None, group_id=None, auto_position_only=False, client_id=None, - limit=500): - """Liefert offline mobile Clients mit gültigem FCM-Token. + include_connected=False, limit=500): + """Liefert mobile Clients mit gültigem FCM-Token. ``disconnected_before`` ist der Spätzeitpunkt, zu dem die Trennung eingetreten sein muss (für den regulären Offline-Timeout). @@ -425,6 +434,9 @@ def offline_mobile_wake_candidates(tenant_id, disconnected_before, die Sperre auf (manueller Aufruf). ``auto_position_only`` berücksichtigt nur Gruppen-Views, bei denen die automatische Positionsübertragung aktiviert ist. + ``include_connected`` nimmt auch Clients auf, die laut Broker noch + verbunden sind. Das ist für iOS nötig, weil der Verbindungsstatus dort + trotz nicht mehr erreichbarem Socket „verbunden“ bleiben kann. """ sql, params = _offline_mobile_wake_query( tenant_id, @@ -433,6 +445,7 @@ def offline_mobile_wake_candidates(tenant_id, disconnected_before, group_id=group_id, auto_position_only=auto_position_only, client_id=client_id, + include_connected=include_connected, limit=limit, ) return get_db().execute(sql, params).fetchall() @@ -441,6 +454,7 @@ def offline_mobile_wake_candidates(tenant_id, disconnected_before, def claim_offline_mobile_wakes(tenant_id, disconnected_before, re_wake_before=None, group_id=None, auto_position_only=False, client_id=None, + include_connected=False, reason='offline', limit=500): """Reserviert fällige Wake-Kandidaten prozessübergreifend. @@ -461,6 +475,7 @@ def claim_offline_mobile_wakes(tenant_id, disconnected_before, group_id=group_id, auto_position_only=auto_position_only, client_id=client_id, + include_connected=include_connected, limit=limit, ) rows = db.execute(sql, params).fetchall() diff --git a/CMBNet/config.py b/CMBNet/config.py index 6c07df1..7467663 100644 --- a/CMBNet/config.py +++ b/CMBNet/config.py @@ -118,6 +118,13 @@ class Config: FCM_SIGNAL_TTL_SECONDS = int(os.environ.get( 'CMBNET_FCM_SIGNAL_TTL_SECONDS', '600' )) + # Auch als verbunden geltende mobile Clients zusätzlich über FCM + # benachrichtigen. Auf iOS bleibt der Broker-Status oft veraltet; ohne + # dieses Signal kämen Nachrichten dort erst beim nächsten manuellen + # Öffnen an. Der Queue-Cooldown begrenzt die Häufigkeit pro Client. + FCM_WAKE_CONNECTED_CLIENTS = os.environ.get( + 'CMBNET_FCM_WAKE_CONNECTED_CLIENTS', '1' + ).strip().lower() in ('1', 'true', 'yes', 'on') FCM_WAKE_POLL_INTERVAL_SECONDS = float(os.environ.get( 'CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS', '30' )) diff --git a/CMBNet/docs/FCM_ARCHITEKTUR.md b/CMBNet/docs/FCM_ARCHITEKTUR.md index 61f3f03..f1ae838 100644 --- a/CMBNet/docs/FCM_ARCHITEKTUR.md +++ b/CMBNet/docs/FCM_ARCHITEKTUR.md @@ -57,9 +57,13 @@ Sie sind kein Anwendungsinhalt. ### Gequeuete Nachricht -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. +Sobald eine Nachricht mit Code `>= 99` für einen mobilen Client eingereiht +oder direkt an ihn gesendet wird, versucht der Broker ein FCM-Signal. Das gilt +bewusst auch dann, wenn der Client laut Broker noch als verbunden gilt: Auf +iOS bleibt dieser Status oft veraltet, obwohl der WebSocket nicht mehr +erreichbar ist. Mehrere Nachrichten innerhalb des Queue-Cooldowns lösen nur +ein Signal aus. Mit `CMBNET_FCM_WAKE_CONNECTED_CLIENTS=0` lässt sich das +zusätzliche Wecken verbundener Clients abschalten. ### Offline-Erkennung @@ -102,7 +106,8 @@ ebenfalls berücksichtigt, haben aber keine automatische Positionsübertragung. Der Radar-Button im Desktop-Dispatcher und im mobilen Dispatcher ruft `POST //api/push/wake` auf. Der mobile Dispatcher schränkt den Aufruf auf die aktuell ausgewählte Gruppe ein, sofern eine Gruppe gewählt ist. Der -Desktop-Dispatcher weckt alle getrennten mobilen Clients. Ein kurzer Cooldown +Desktop-Dispatcher weckt alle mobilen Clients mit gültigem Token – auch +solche, die der Broker noch als verbunden führt. Ein kurzer Cooldown verhindert versehentliche Doppelklicks. ## Client-Typen @@ -173,6 +178,7 @@ inaktiv: | `CMBNET_FCM_QUEUE_WAKE_COOLDOWN_SECONDS` | `60` | Cooldown je Queue-Wake | | `CMBNET_FCM_MANUAL_WAKE_COOLDOWN_SECONDS` | `15` | Cooldown für den Button | | `CMBNET_FCM_SIGNAL_TTL_SECONDS` | `600` | FCM-TTL | +| `CMBNET_FCM_WAKE_CONNECTED_CLIENTS` | `1` | Auch als verbunden geltende mobile Clients wecken (iOS) | | `CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS` | `30` | Prüfintervall des Workers | | `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 | diff --git a/CMBNet/static/js/sw.js b/CMBNet/static/js/sw.js index f6f20f7..0b24d10 100644 --- a/CMBNet/static/js/sw.js +++ b/CMBNet/static/js/sw.js @@ -5,7 +5,7 @@ * damit er sowohl die mobilen Views als auch die statischen Assets * kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet. */ -const VERSION = 'cmbnet-pwa-v24'; +const VERSION = 'cmbnet-pwa-v25'; const BASE = new URL('./', self.location).href; const SHELL_CACHE = `${VERSION}-shell`; const TILE_CACHE = `${VERSION}-tiles`; diff --git a/CMBNet/static/js/views/dispatcher.js b/CMBNet/static/js/views/dispatcher.js index 96d6032..cc527f3 100644 --- a/CMBNet/static/js/views/dispatcher.js +++ b/CMBNet/static/js/views/dispatcher.js @@ -3659,7 +3659,7 @@ async function wakeMobileClients() { const tokens = Number(result.valid_tokens) || 0; const connected = Number(result.connected) || 0; setStreetSearchStatus( - 'Keine offline mobilen Clients mit Push-Token gefunden ' + 'Keine mobilen Clients mit Push-Token gefunden ' + `(registriert: ${tokens}, verbunden: ${connected}).` ); } diff --git a/CMBNet/static/js/views/mobile.js b/CMBNet/static/js/views/mobile.js index d5febb6..bad95e4 100644 --- a/CMBNet/static/js/views/mobile.js +++ b/CMBNet/static/js/views/mobile.js @@ -664,7 +664,7 @@ async function wakeMobileClientsFromUi() { const tokens = Number(result.valid_tokens) || 0; const connected = Number(result.connected) || 0; showMobileToast( - 'Keine offline mobilen Clients mit Push-Token gefunden ' + 'Keine mobilen Clients mit Push-Token gefunden ' + `(registriert: ${tokens}, verbunden: ${connected}).` ); }