@ethora/chat-component-rn 26.10.9 → 26.10.11

package/src/networking/callTokenStanza.ts

@@ -8,6 +8,21 @@ import {
   setOutgoingCallToken,
 } from '../roomStore/callSlice';
 import { getGlobalXmppClient } from '../utils/clientRegistry';
+import {
+  decideIncomingWhileBusy,
+  isCallRoomTypeAllowed,
+  parseCallTokenAttrs,
+} from '../calls/callMode';
+import { busySnapshot } from '../calls/callBusy';
+import { isSystemAccountSender } from '../calls/senderTrust';
+import { looksLikeRawRoomName, safeCallName } from '../calls/callDisplay';
+import { P2P_SIGNAL_TYPE } from '../calls/p2p/signalStanza';
+import { handleP2PSignalStanza } from '../calls/p2p/p2pRuntime';
+import { isP2PAvailable } from '../calls/p2p/webrtcRuntime';
+import {
+  reportCallDeclined,
+  reportCallEnded,
+} from './api-requests/callState.api';
 import { callStateHasLogData } from '../helpers/callLogMessage';
 import { pushLog } from '../utils/devLogger';
 
@@ -57,6 +72,33 @@ const consumeKindHint = (
 
 const MAX_CALL_TOKEN_AGE_MS = 5000;
 
+// XMPP domain of this session (the client's own JID domain, else the host).
+const sessionXmppDomain = (): string => {
+  const client = getGlobalXmppClient() as any;
+  return String(client?.client?.jid?.getDomain?.() || client?.host || '');
+};
+
+const isTrueishAttr = (value: unknown): boolean => {
+  const text = String(value ?? '').trim().toLowerCase();
+  return text === 'true' || text === '1';
+};
+
+// Display name of a user we only know by xmpp username (p2p tokens carry no
+// JWT, so no caller name), from the enriched usersSet.
+const lookupUserName = (xmppUsername: string | null): string => {
+  if (!xmppUsername) {return '';}
+  const usersSet = (store.getState().rooms.usersSet || {}) as Record<
+    string,
+    { firstName?: string; lastName?: string; name?: string }
+  >;
+  const user = usersSet[xmppUsername] || usersSet[xmppUsername.split('@')[0]];
+  if (!user) {return '';}
+  return (
+    `${user.firstName || ''} ${user.lastName || ''}`.trim() ||
+    String(user.name || '').trim()
+  );
+};
+
 // Dev-only trace of call signalling: which `<data type="call-*">` frames
 // arrive and why a call-token was dropped. A dropped token is silent
 // otherwise: the caller sits on "Calling..." and the callee never rings.
@@ -309,8 +351,11 @@ const handleCallStateData = (
     !!stanzaCallId &&
     !!currentCall.callId &&
     currentCall.callId === stanzaCallId;
-
-  if (stanzaCallId && currentCall.callId && !callIdMatches) {return;}
+  // A signal that names a DIFFERENT call than the one on screen (e.g. the
+  // server log of the previous call in the same room arriving late) must not
+  // tear down the current one just because the room matches.
+  const callIdConflicts =
+    !!stanzaCallId && !!currentCall.callId && currentCall.callId !== stanzaCallId;
 
   const isTerminalState =
     state === 'ended' ||
@@ -324,7 +369,10 @@ const handleCallStateData = (
   // itself a "session concluded" signal.
   const isServerCallLog = !state && callStateHasLogData(data.attrs || {});
 
-  if ((roomMatches || callIdMatches) && (isTerminalState || isServerCallLog)) {
+  if (
+    (callIdMatches || (roomMatches && !callIdConflicts)) &&
+    (isTerminalState || isServerCallLog)
+  ) {
     store.dispatch(endCall());
   }
 };
@@ -383,7 +431,15 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         .split('/')[0]
         .split('@')[0]
         .trim();
-      handleCallStateData(data, fromRoom);
+      const declinedInGroup =
+        String(data.attrs?.state || '').toLowerCase() === 'declined' &&
+        isTrueishAttr(data.attrs?.group);
+      if (!declinedInGroup) {
+        // The state / callId / room live on the <data> element, not on the
+        // <message> wrapper. This used to be handed `inner`, which made every
+        // client call-state signal and server call-log a no-op here.
+        handleCallStateData(data, fromRoom);
+      }
 
       // Server call-logs (carry callerXmppUsername / durationMs) should
       // flow on to onRealtimeMessage / onMessageHistory where they become
@@ -396,13 +452,6 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
       return true;
     }
 
-    if (dataType === 'call-state-declined') {
-      handleCallStateData({
-        attrs: { ...data.attrs, state: 'declined' },
-      } as unknown as Element);
-      return true;
-    }
-
     if (dataType === 'call-invite') {
       const inviteKind = String(data.attrs?.kind || '').toLowerCase();
       const normalized: 'audio' | 'video' =
@@ -430,6 +479,39 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
       return true;
     }
 
+    if (dataType === P2P_SIGNAL_TYPE) {
+      // Peer to peer WebRTC signalling (offer / answer / candidate / end).
+      // Routed to the p2p runtime, never to the chat pipeline.
+      if (store.getState().chatSettingStore.config?.videoCalls?.enabled === true) {
+        handleP2PSignalStanza(inner);
+      }
+      return true;
+    }
+
+    if (dataType === 'call-state-declined') {
+      // Server relay of a callee's decline. In a group call one member
+      // declining must not end the call for everybody, so it is ignored there.
+      // For 1:1 it is a terminal state, same as the client-sent `declined`.
+      if (isTrueishAttr(data.attrs?.group)) {
+        callTrace('group member declined', {
+          by: data.attrs?.by,
+          callId: data.attrs?.callId,
+        });
+        return true;
+      }
+      const fromRoom = String(stanza.attrs?.from || '')
+        .split('/')[0]
+        .split('@')[0]
+        .trim();
+      handleCallStateData(
+        ({
+          attrs: { ...(data.attrs || {}), state: 'declined' },
+        } as unknown) as Element,
+        fromRoom
+      );
+      return true;
+    }
+
     if (dataType === 'call-token') {
       const videoCallsConfig =
         store.getState().chatSettingStore.config?.videoCalls;
@@ -442,47 +524,88 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         return true;
       }
 
-      const token = String(data.attrs?.token || '').trim();
-      const stanzaRoom = String(data.attrs?.room || '').trim();
-      const stanzaKind = String(data.attrs?.kind || '').toLowerCase();
-      const stanzaCallId =
-        String(data.attrs?.callId || data.attrs?.callid || '').trim() || null;
+      // Old servers send neither `mode` nor `group`: parseCallTokenAttrs maps
+      // that to a plain LiveKit 1:1 call, exactly the legacy behaviour.
+      const attrs = parseCallTokenAttrs(data.attrs);
+      // livekitUrl and ice decide where the media goes, and callerName /
+      // caller decide who the ring screen says is calling, so they are
+      // honoured only from the app's system account (see calls/senderTrust).
+      // Anything else keeps the stanza but loses those attributes: the callee
+      // then uses config.videoCalls.livekitUrl, GET /v1/calls/ice-servers and
+      // the name it can work out locally.
+      if (
+        (attrs.livekitUrl ||
+          attrs.iceServers ||
+          attrs.callerName ||
+          attrs.caller) &&
+        !isSystemAccountSender(inner.attrs?.from, sessionXmppDomain())
+      ) {
+        callTrace(
+          'ignoring livekitUrl/ice/callerName/caller on a call-token not sent by the system account',
+          { from: inner.attrs?.from }
+        );
+        attrs.livekitUrl = null;
+        attrs.iceServers = null;
+        attrs.callerName = '';
+        attrs.caller = null;
+      }
+      const { token, mode, group, room: stanzaRoom } = attrs;
+      const isP2P = mode === 'p2p';
+      const stanzaCallId = attrs.callId;
       // Server doesn't propagate `kind` on the broadcast stanza, so first
       // look for a client-side `call-invite` hint we stashed when the
       // dialer signaled us directly. Falls back to whatever the server
       // happens to attach, finally to video (legacy default).
       const hintedKind = consumeKindHint([stanzaRoom, stanzaCallId]);
       const kind: 'audio' | 'video' =
-        hintedKind || (stanzaKind === 'audio' ? 'audio' : 'video');
-      if (!token || !stanzaRoom) {
+        hintedKind || (attrs.kind === 'audio' ? 'audio' : 'video');
+      // A p2p token is intentionally empty (the media never touches LiveKit);
+      // it needs the callId instead, to correlate the signalling.
+      if (!stanzaRoom || (isP2P ? !stanzaCallId : !token)) {
         callTrace('drop call-token: no token or room');
         return true;
       }
 
       const resolvedRoom = resolveRoomByStanzaRoom(stanzaRoom);
-      const allowedRoomTypes = videoCallsConfig.allowedRoomTypes || ['private'];
       const usersCnt = Number(resolvedRoom?.usersCnt || 0);
       const isOneToOneLikeRoom = usersCnt > 0 && usersCnt <= 2;
-      const isPrivateAllowed = allowedRoomTypes.includes('private');
-      if (
-        resolvedRoom?.type &&
-        resolvedRoom.type !== 'private' &&
-        !isOneToOneLikeRoom
-      ) {
-        callTrace('drop call-token: room type', { type: resolvedRoom.type, usersCnt });
-        return true;
-      }
-      if (resolvedRoom?.type === 'private' && !isPrivateAllowed) {
-        callTrace('drop call-token: private not allowed');
-        return true;
-      }
-      if (
-        !resolvedRoom?.type &&
-        !stanzaRoom.includes('@') &&
-        !isOneToOneLikeRoom
-      ) {
-        callTrace('drop call-token: room unknown', { stanzaRoom });
-        return true;
+      const allowedRoomTypes = videoCallsConfig.allowedRoomTypes;
+      if (group) {
+        // Group room call (always LiveKit). The host may opt out through
+        // allowedRoomTypes; a room we know to be private contradicts `group`.
+        if (!isCallRoomTypeAllowed('group', allowedRoomTypes)) {
+          callTrace('drop call-token: group calls not allowed');
+          return true;
+        }
+        if (resolvedRoom?.type === 'private') {
+          callTrace('drop call-token: group flag on a private room');
+          return true;
+        }
+      } else {
+        const isPrivateAllowed = isCallRoomTypeAllowed(
+          'private',
+          allowedRoomTypes
+        );
+        if (
+          resolvedRoom?.type &&
+          resolvedRoom.type !== 'private' &&
+          !isOneToOneLikeRoom
+        ) {
+          callTrace('drop call-token: room type', { type: resolvedRoom.type, usersCnt });
+          return true;
+        }
+        if (resolvedRoom?.type === 'private' && !isPrivateAllowed) {
+          callTrace('drop call-token: private not allowed');
+          return true;
+        }
+        if (
+          !resolvedRoom?.type &&
+          !stanzaRoom.includes('@') &&
+          !isOneToOneLikeRoom
+        ) {
+          callTrace('drop call-token: room unknown', { stanzaRoom });
+          return true;
+        }
       }
 
       const roomJid =
@@ -491,8 +614,11 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
       // ring screen, the server populates it with the caller's full name
       // ("Roman Test") which is far more useful than the resolved room
       // title (which for stale / deleted-peer chats reads "deleted").
-      const jwtPayload = decodeJwtPayload(token);
-      const callerName = extractCallerDisplayName(jwtPayload);
+      // A p2p token has no JWT, and in a group the ring should name the room.
+      const jwtPayload = isP2P ? null : decodeJwtPayload(token);
+      const jwtName = group
+        ? ''
+        : safeCallName(extractCallerDisplayName(jwtPayload)) || '';
       // `title` is the display name; on new-arch private rooms `name` is the
       // bare room id ("${appId}_<a>-${appId}_<b>"), never something to show.
       const resolvedTitle = String(
@@ -503,23 +629,81 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         resolvedTitle === stanzaRoom ||
         ['deleted', 'deleted user', 'unknown', 'null'].includes(
           resolvedTitle.toLowerCase()
-        );
-      // Never fall back to the room id: an empty name renders as
-      // "Unknown caller" on the ring screen.
-      const incomingRoomName =
-        (titleLooksBad ? callerName : resolvedTitle) || callerName || '';
+        ) ||
+        looksLikeRawRoomName(resolvedTitle);
+      const selfXmpp =
+        store.getState().chatSettingStore.user?.xmppUsername || '';
+      // Group rooms have no single peer; a "<a>-<b>" name there is a coincidence.
+      const peerXmppUsername = group
+        ? null
+        : derivePeerXmppUsername(stanzaRoom, selfXmpp) || attrs.caller;
+      const peerName = titleLooksBad ? lookupUserName(peerXmppUsername) : '';
+      // What the call is called on screen. A person's name is preferred; a
+      // raw chat name (two joined JIDs) is never used, an empty result makes
+      // the UI show a neutral label. In a group the call is the ROOM, and the
+      // caller is carried separately (callerName) for the "X is calling in Y"
+      // line.
+      const incomingRoomName = group
+        ? (titleLooksBad ? '' : resolvedTitle) || safeCallName(stanzaRoom) || ''
+        : attrs.callerName ||
+          jwtName ||
+          (titleLooksBad ? '' : resolvedTitle) ||
+          safeCallName(peerName) ||
+          safeCallName(stanzaRoom) ||
+          '';
       if (!roomJid) {
         callTrace('drop call-token: no room jid', { stanzaRoom });
         return true;
       }
 
       const callId = extractCallId(data, jwtPayload);
-      const selfXmpp =
-        store.getState().chatSettingStore.user?.xmppUsername || '';
-      const peerXmppUsername = derivePeerXmppUsername(stanzaRoom, selfXmpp);
+      if (isP2P && !callId) {return true;}
 
       const callState = store.getState().call;
+
+      if (isP2P || callState.mode === 'p2p') {
+        // Peer to peer (or an active p2p call): one call at a time, decided
+        // by callId. The legacy LiveKit-over-LiveKit path below is untouched.
+        if (isP2P && !isP2PAvailable()) {
+          // This device cannot take the call (the WebRTC package is not
+          // installed); tell the caller instead of leaving them ringing.
+          callTrace('decline p2p call-token: WebRTC unavailable', { callId });
+          reportCallDeclined(callId);
+          return true;
+        }
+        const decision = decideIncomingWhileBusy(busySnapshot(callState), {
+          mode,
+          callId,
+          roomBareName: stanzaRoom,
+        });
+        if (decision === 'duplicate' || decision === 'glare-keep') {
+          callTrace(`drop call-token: ${decision}`, { callId });
+          return true;
+        }
+        if (decision === 'busy') {
+          callTrace('decline call-token: busy', { callId });
+          if (isP2P) {
+            reportCallDeclined(callId);
+            if (peerXmppUsername) {
+              sendCallStateSignal('declined', {
+                peerXmppUsername,
+                callId,
+                roomBareName: stanzaRoom,
+              });
+            }
+          }
+          return true;
+        }
+        if (decision === 'glare-yield') {
+          // We both dialled at once and the other call has the smaller id:
+          // drop ours (the other side keeps theirs and ignores our token).
+          sendCallStateSignal('cancelled');
+          reportCallEnded(callState.callId);
+        }
+      }
+
       const isOutgoingRoomMatch =
+        !isP2P &&
         callState.direction === 'outgoing' &&
         (callState.roomJid === roomJid ||
           callState.roomName === incomingRoomName ||
@@ -529,10 +713,17 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         outgoing: isOutgoingRoomMatch,
         roomJid,
         callId,
+        mode,
+        group,
       });
       if (isOutgoingRoomMatch) {
         store.dispatch(
-          setOutgoingCallToken({ roomJid, token, callId: callId || null })
+          setOutgoingCallToken({
+            roomJid,
+            token,
+            callId: callId || null,
+            livekitUrl: attrs.livekitUrl,
+          })
         );
         return true;
       }
@@ -556,6 +747,12 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
           kind,
           callId: callId || null,
           peerXmppUsername: peerXmppUsername || null,
+          mode,
+          isGroup: group,
+          iceServers: attrs.iceServers,
+          livekitUrl: attrs.livekitUrl,
+          callerName: attrs.callerName || null,
+          callerXmppUsername: attrs.caller,
         })
       );
       return true;

package/src/roomStore/callSlice.ts

@@ -1,4 +1,6 @@
 import { PayloadAction, createSlice } from '@reduxjs/toolkit';
+import type { CallMode, IceServerConfig } from '../calls/callMode';
+import { safeCallName } from '../calls/callDisplay';
 
 export type CallPhase =
   | 'idle'
@@ -33,6 +35,23 @@ export interface CallState {
   // When the call actually connected (phase -> 'in-call'). Null until then.
   // Used to compute a duration for the local "call ended" log fallback.
   connectedAt: number | null;
+  // Transport of this call. `livekit` is the legacy path (and the only one for
+  // group rooms); `p2p` is our own WebRTC peer connection for 1:1. Decided by
+  // the server (create response for the caller, call-token `mode` for the
+  // callee), defaults to livekit so older servers behave exactly as before.
+  mode: CallMode;
+  // Group room call (always LiveKit): more than two participants, so the
+  // session must not assume the call is over when one remote participant leaves.
+  isGroup: boolean;
+  // Public LiveKit wss URL the server reported in the create response or on
+  // the call-token. Wins over config.videoCalls.livekitUrl when present.
+  livekitUrl: string | null;
+  // ICE servers (STUN/TURN with ephemeral credentials) for a p2p call.
+  iceServers: IceServerConfig[] | null;
+  // Who is calling, from the call-token (system account only). roomName is the
+  // name shown for the call; for a group it is the room, and this is the person.
+  callerName: string | null;
+  callerXmppUsername: string | null;
 }
 
 const initialState: CallState = {
@@ -48,6 +67,12 @@ const initialState: CallState = {
   error: null,
   startedAt: null,
   connectedAt: null,
+  mode: 'livekit',
+  isGroup: false,
+  livekitUrl: null,
+  iceServers: null,
+  callerName: null,
+  callerXmppUsername: null,
 };
 
 const resetState = (): CallState => ({ ...initialState });
@@ -64,13 +89,16 @@ const callSlice = createSlice({
         roomBareName?: string | null;
         kind?: CallKind;
         peerXmppUsername?: string | null;
+        isGroup?: boolean;
       }>
     ) {
       state.phase = 'requesting';
       state.direction = 'outgoing';
       state.kind = action.payload.kind || 'video';
       state.roomJid = action.payload.roomJid;
-      state.roomName = action.payload.roomName || null;
+      // A raw chat name is never a name: safeCallName drops it, the UI then
+      // shows a neutral label.
+      state.roomName = safeCallName(action.payload.roomName);
       state.roomBareName =
         action.payload.roomBareName ||
         (action.payload.roomJid || '').split('@')[0] ||
@@ -81,6 +109,45 @@ const callSlice = createSlice({
       state.error = null;
       state.startedAt = Date.now();
       state.connectedAt = null;
+      state.mode = 'livekit';
+      state.isGroup = action.payload.isGroup === true;
+      state.livekitUrl = null;
+      state.iceServers = null;
+      state.callerName = null;
+      state.callerXmppUsername = null;
+    },
+    // The create response told the caller how the call is carried. Applied
+    // only to the very call that asked (startedAt must match), so a late
+    // response for a call the user already cancelled cannot leak into the next.
+    setOutgoingCallRoute(
+      state,
+      action: PayloadAction<{
+        startedAt: number | null;
+        callId: string | null;
+        mode: CallMode;
+        group?: boolean | null;
+        livekitUrl?: string | null;
+        iceServers?: IceServerConfig[] | null;
+      }>
+    ) {
+      if (state.direction !== 'outgoing') {return;}
+      if (action.payload.startedAt !== state.startedAt) {return;}
+      // The LiveKit call-token can overtake the HTTP response, so a livekit
+      // route may still be applied once the phase has moved on to
+      // 'connecting'. A p2p route only makes sense while still dialling.
+      if (state.phase !== 'requesting') {
+        if (state.phase !== 'connecting' || action.payload.mode !== 'livekit') {
+          return;
+        }
+      }
+      state.mode = action.payload.mode;
+      if (action.payload.callId) {state.callId = action.payload.callId;}
+      if (typeof action.payload.group === 'boolean') {
+        state.isGroup = action.payload.group;
+      }
+      state.livekitUrl = action.payload.livekitUrl || null;
+      state.iceServers =
+        action.payload.mode === 'p2p' ? action.payload.iceServers || [] : null;
     },
     setIncomingCallToken(
       state,
@@ -92,13 +159,20 @@ const callSlice = createSlice({
         kind?: CallKind;
         callId?: string | null;
         peerXmppUsername?: string | null;
+        mode?: CallMode;
+        isGroup?: boolean;
+        iceServers?: IceServerConfig[] | null;
+        // LiveKit URL from the call-token stanza; wins over the host config.
+        livekitUrl?: string | null;
+        callerName?: string | null;
+        callerXmppUsername?: string | null;
       }>
     ) {
       state.phase = 'ringing-incoming';
       state.direction = 'incoming';
       state.kind = action.payload.kind || 'video';
       state.roomJid = action.payload.roomJid;
-      state.roomName = action.payload.roomName || null;
+      state.roomName = safeCallName(action.payload.roomName);
       state.roomBareName =
         action.payload.roomBareName ||
         (action.payload.roomJid || '').split('@')[0] ||
@@ -109,6 +183,12 @@ const callSlice = createSlice({
       state.error = null;
       state.startedAt = Date.now();
       state.connectedAt = null;
+      state.mode = action.payload.mode || 'livekit';
+      state.isGroup = action.payload.isGroup === true;
+      state.livekitUrl = action.payload.livekitUrl || null;
+      state.iceServers = action.payload.iceServers || null;
+      state.callerName = safeCallName(action.payload.callerName);
+      state.callerXmppUsername = action.payload.callerXmppUsername || null;
     },
     setOutgoingCallToken(
       state,
@@ -116,6 +196,7 @@ const callSlice = createSlice({
         roomJid: string;
         token: string;
         callId?: string | null;
+        livekitUrl?: string | null;
       }>
     ) {
       if (state.direction !== 'outgoing') {return;}
@@ -127,6 +208,8 @@ const callSlice = createSlice({
       state.roomJid = action.payload.roomJid;
       state.token = action.payload.token;
       if (action.payload.callId) {state.callId = action.payload.callId;}
+      // The stanza's URL, when present, wins over the create response's.
+      if (action.payload.livekitUrl) {state.livekitUrl = action.payload.livekitUrl;}
       state.error = null;
       state.startedAt = state.startedAt || Date.now();
     },
@@ -178,6 +261,7 @@ export const {
   startOutgoingCall,
   setIncomingCallToken,
   setOutgoingCallToken,
+  setOutgoingCallRoute,
   acceptIncomingCall,
   declineIncomingCall,
   endCall,

package/src/services/appBadge.ts

@@ -0,0 +1,85 @@
+// The app icon badge, kept honest from the device side.
+//
+// The backend sets the badge only on the push it sends, so nothing lowers it
+// once the user reads the messages: opening the app would keep showing the
+// count of the last push. While the app is in the foreground the badge
+// follows the total unread count instead - 0 when everything is read, the
+// real number otherwise - and the server takes over again with its next push.
+//
+// Needs expo-notifications (an optional peer); without it this is a no-op.
+// Hosts that drive the badge themselves set
+// `config.pushNotifications.syncAppBadge: false`.
+
+import { AppState } from 'react-native';
+import { store } from '../roomStore';
+import type { IRoom } from '../types/types';
+import { pushLog } from '../utils/devLogger';
+
+let installed = false;
+let lastSet: number | null = null;
+let lastRooms: unknown;
+
+const loadNotifications = (): any => {
+  try {
+    return require('expo-notifications');
+  } catch {
+    return null;
+  }
+};
+
+const totalUnread = (): number =>
+  Object.values(store.getState().rooms?.rooms || {}).reduce(
+    (sum, room: IRoom) => sum + (room?.unreadMessages || 0),
+    0
+  );
+
+const isEnabled = (): boolean =>
+  store.getState().chatSettingStore?.config?.pushNotifications?.syncAppBadge !==
+  false;
+
+const sync = (): void => {
+  if (AppState.currentState !== 'active' || !isEnabled()) {
+    return;
+  }
+  const count = totalUnread();
+  if (count === lastSet) {
+    return;
+  }
+  const notifications = loadNotifications();
+  if (typeof notifications?.setBadgeCountAsync !== 'function') {
+    return;
+  }
+  lastSet = count;
+  Promise.resolve(notifications.setBadgeCountAsync(count)).catch((error: unknown) => {
+    lastSet = null;
+    pushLog('warn', 'push: setting the app badge failed', error);
+  });
+};
+
+export const installAppBadgeSync = (): void => {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  AppState.addEventListener('change', (next) => {
+    if (next === 'active') {
+      // A push may have moved the badge while we were away.
+      lastSet = null;
+      sync();
+    }
+  });
+  // Only actions that touch the rooms can move the count.
+  store.subscribe(() => {
+    const rooms = store.getState().rooms?.rooms;
+    if (rooms !== lastRooms) {
+      lastRooms = rooms;
+      sync();
+    }
+  });
+  sync();
+};
+
+export const __resetAppBadgeForTests = (): void => {
+  lastSet = null;
+  lastRooms = undefined;
+};