@ethora/chat-component-rn 26.10.6 → 26.10.8

package/plugins/withNotificationServiceExtension.js

@@ -1,15 +1,21 @@
 /**
- * Expo config plugin — adds an iOS Notification Service Extension that shows
- * the attachment thumbnail (photo / video preview) in chat pushes.
- *
- * The push service sends `previewUrl` with `mutable-content: 1`. Android
- * renders the picture by itself; iOS only does it through an extension
- * target inside the app, which downloads the file and attaches it
- * (plugins/notification-service/NotificationService.swift).
+ * Expo config plugin — adds an iOS Notification Service Extension for Ethora
+ * chat pushes. The extension (plugins/notification-service/NotificationService.swift)
+ *  - decrypts encrypted (sealed) pushes with the device key the app keeps in
+ *    the keychain and shows the real title and text in place of the
+ *    "New message" placeholder;
+ *  - shows the attachment thumbnail (photo / video preview) the push service
+ *    sends as `previewUrl`.
  *
  * An extension is a separate target signed with the app, so it cannot ship
  * inside the npm package as code: this plugin writes it into ios/ on every
  * `expo prebuild` (the generated ios/ folder is gitignored in Expo apps).
+ * For the key to be readable from the extension, the app and the extension
+ * share a keychain access group (`$(AppIdentifierPrefix)<bundle id>`, the
+ * app's own default group, listed first so items the app writes without a
+ * group — expo-secure-store's — land in it). The sealed box is opened in
+ * plain Swift (SealedBox.swift: CryptoKit for X25519, the rest ported from
+ * tweetnacl), so the extension needs no pod.
  *
  * Host app.json:
  *   "plugins": ["@ethora/chat-component-rn"]
@@ -23,25 +29,39 @@
 
 const fs = require('fs');
 const path = require('path');
-const { withDangerousMod, withXcodeProject } = require('expo/config-plugins');
+const { withDangerousMod, withEntitlementsPlist, withXcodeProject } = require('expo/config-plugins');
 
 const TARGET_NAME = 'EthoraNotificationService';
 const SOURCE_DIR = path.join(__dirname, 'notification-service');
-const FILES = ['NotificationService.swift', 'Info.plist'];
+const SOURCES = ['NotificationService.swift', 'SealedBox.swift'];
+const FILES = [...SOURCES, 'Info.plist'];
+const ENTITLEMENTS_FILE = `${TARGET_NAME}.entitlements`;
+const KEYCHAIN_GROUPS_KEY = 'keychain-access-groups';
 
-const extensionBundleId = (config) => {
-  const appBundleId = config.ios && config.ios.bundleIdentifier;
-  if (!appBundleId) {
+const appBundleId = (config) => {
+  const bundleId = config.ios && config.ios.bundleIdentifier;
+  if (!bundleId) {
     throw new Error(
       '[@ethora/chat-component-rn] ios.bundleIdentifier is required for the notification service extension'
     );
   }
-  return `${appBundleId}.${TARGET_NAME}`;
+  return bundleId;
+};
+
+const extensionBundleId = (config) => `${appBundleId(config)}.${TARGET_NAME}`;
+
+/** The keychain access group shared by the app and the extension. */
+const keychainGroup = (config) => `$(AppIdentifierPrefix)${appBundleId(config)}`;
+
+const withSharedGroupFirst = (groups, group) => {
+  const list = Array.isArray(groups) ? groups.filter((g) => g !== group) : [];
+  return [group, ...list];
 };
 
 // EAS Build creates signing credentials only for targets it knows about.
 const withEasAppExtension = (config) => {
   const bundleIdentifier = extensionBundleId(config);
+  const group = keychainGroup(config);
   config.extra = config.extra || {};
   config.extra.eas = config.extra.eas || {};
   config.extra.eas.build = config.extra.eas.build || {};
@@ -49,12 +69,42 @@ const withEasAppExtension = (config) => {
   const ios = (config.extra.eas.build.experimental.ios =
     config.extra.eas.build.experimental.ios || {});
   const extensions = (ios.appExtensions = ios.appExtensions || []);
-  if (!extensions.some((ext) => ext.targetName === TARGET_NAME)) {
-    extensions.push({ targetName: TARGET_NAME, bundleIdentifier, entitlements: {} });
+  let entry = extensions.find((ext) => ext.targetName === TARGET_NAME);
+  if (!entry) {
+    entry = { targetName: TARGET_NAME, bundleIdentifier, entitlements: {} };
+    extensions.push(entry);
   }
+  entry.entitlements = entry.entitlements || {};
+  entry.entitlements[KEYCHAIN_GROUPS_KEY] = withSharedGroupFirst(
+    entry.entitlements[KEYCHAIN_GROUPS_KEY],
+    group
+  );
   return config;
 };
 
+// The app's side of the shared keychain group (Keychain Sharing capability).
+const withAppKeychainGroup = (config) =>
+  withEntitlementsPlist(config, (cfg) => {
+    const group = keychainGroup(cfg);
+    cfg.modResults[KEYCHAIN_GROUPS_KEY] = withSharedGroupFirst(
+      cfg.modResults[KEYCHAIN_GROUPS_KEY],
+      group
+    );
+    return cfg;
+  });
+
+const entitlementsPlist = (group) => `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>${KEYCHAIN_GROUPS_KEY}</key>
+  <array>
+    <string>${group}</string>
+  </array>
+</dict>
+</plist>
+`;
+
 // Copied on every prebuild so an SDK update reaches the app.
 const withExtensionFiles = (config) =>
   withDangerousMod(config, [
@@ -65,6 +115,7 @@ const withExtensionFiles = (config) =>
       for (const file of FILES) {
         fs.copyFileSync(path.join(SOURCE_DIR, file), path.join(dest, file));
       }
+      fs.writeFileSync(path.join(dest, ENTITLEMENTS_FILE), entitlementsPlist(keychainGroup(cfg)));
       return cfg;
     },
   ]);
@@ -97,14 +148,14 @@ const withExtensionTarget = (config, { appleTeamId } = {}) =>
       objects.PBXTargetDependency = objects.PBXTargetDependency || {};
       objects.PBXContainerItemProxy = objects.PBXContainerItemProxy || {};
 
-      const group = project.addPbxGroup(FILES, TARGET_NAME, TARGET_NAME);
+      const group = project.addPbxGroup([...FILES, ENTITLEMENTS_FILE], TARGET_NAME, TARGET_NAME);
       const mainGroup = project.getFirstProject().firstProject.mainGroup;
       project.addToPbxGroup(group.uuid, mainGroup);
 
       // 'app_extension' also embeds the .appex into the app (Copy Files to
       // PlugIns) and makes the app depend on it.
       const target = project.addTarget(TARGET_NAME, 'app_extension', TARGET_NAME, bundleIdentifier);
-      project.addBuildPhase(['NotificationService.swift'], 'PBXSourcesBuildPhase', 'Sources', target.uuid);
+      project.addBuildPhase(SOURCES, 'PBXSourcesBuildPhase', 'Sources', target.uuid);
       project.addBuildPhase([], 'PBXResourcesBuildPhase', 'Resources', target.uuid);
       project.addBuildPhase([], 'PBXFrameworksBuildPhase', 'Frameworks', target.uuid);
       targetUuid = target.uuid;
@@ -116,6 +167,7 @@ const withExtensionTarget = (config, { appleTeamId } = {}) =>
         PRODUCT_BUNDLE_IDENTIFIER: `"${bundleIdentifier}"`,
         INFOPLIST_FILE: `"${TARGET_NAME}/Info.plist"`,
         GENERATE_INFOPLIST_FILE: 'NO',
+        CODE_SIGN_ENTITLEMENTS: `"${TARGET_NAME}/${ENTITLEMENTS_FILE}"`,
         SWIFT_VERSION: appSettings.SWIFT_VERSION || '5.0',
         IPHONEOS_DEPLOYMENT_TARGET: appSettings.IPHONEOS_DEPLOYMENT_TARGET || '15.1',
         TARGETED_DEVICE_FAMILY: appSettings.TARGETED_DEVICE_FAMILY || '"1,2"',
@@ -132,6 +184,6 @@ const withExtensionTarget = (config, { appleTeamId } = {}) =>
   });
 
 const withNotificationServiceExtension = (config, props = {}) =>
-  withExtensionTarget(withExtensionFiles(withEasAppExtension(config)), props);
+  withExtensionTarget(withExtensionFiles(withAppKeychainGroup(withEasAppExtension(config))), props);
 
 module.exports = withNotificationServiceExtension;

package/src/components/MessageBubble/Message.tsx

@@ -407,12 +407,23 @@ const Message: React.FC<MessageProps> = ({ message, isUser, isReply }) => {
 
   const handleReactionMessage = (emoji: string) => {
     if (!reactionsEnabled(config) || config?.disableInteractions) {return;}
-    const sender = { firstName: user.firstName, lastName: user.lastName };
     const own = message.reaction?.[user.xmppUsername || '']?.emoji || [];
-    const next = own.includes(emoji)
-      ? own.filter((reaction) => reaction !== emoji)
-      : [...own, emoji];
-    client?.sendMessageReactionStanza(message.id, message.roomJid, next, sender);
+    const adding = !own.includes(emoji);
+    const next = adding ? [...own, emoji] : own.filter((reaction) => reaction !== emoji);
+    // The author gets a push about an added emoji (see sendMessageReaction);
+    // nothing for a removed one or for one's own message.
+    const author = message.user?.id || '';
+    client?.sendMessageReactionStanza(message.id, message.roomJid, next, {
+      firstName: user.firstName,
+      lastName: user.lastName,
+      photoURL: user.profileImage,
+      push: adding && !!author && author !== user.xmppUsername,
+      messageAuthor: author,
+      messageText: message.body,
+      isMediafile: message.isMediafile,
+      mimetype: message.mimetype,
+      fileName: message.originalName || message.fileName,
+    });
   };
 
   // Long-press → capture the bubble's on-screen bounding box. The actual

package/src/components/VideoCalls/VideoCallOverlay.tsx

@@ -26,6 +26,7 @@ import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { RootState } from '../../roomStore';
 import {
   acceptIncomingCall,
+  declineIncomingCall,
   resetCall,
   setCallError,
 } from '../../roomStore/callSlice';
@@ -64,6 +65,12 @@ const ACCEPT = '#10B981';
 // PSTN ring window.
 const OUTGOING_CALL_TIMEOUT_MS = 30000;
 
+// Stop ringing an incoming call nobody cancelled. The caller gives up after
+// OUTGOING_CALL_TIMEOUT_MS and says so, but that signal is lost when the
+// call came in by push and the socket never came up (the system call
+// screen of a VoIP push would otherwise ring on).
+const INCOMING_CALL_TIMEOUT_MS = 45000;
+
 // Ring pattern for an incoming call: wait, buzz, pause, buzz... Android
 // loops this from index 0, iOS ignores the pattern and just vibrates.
 const RING_VIBRATION_PATTERN = [0, 700, 900];
@@ -507,8 +514,6 @@ const VideoCallOverlayInner: FC = () => {
   }, [enabled, canRenderSession, call.token, livekitUrl, call.kind]);
 
   // Give up on an unanswered outgoing dial. Unlike web (which only shows
-  // the error), also tell the callee, who would otherwise keep ringing:
-  // there is no incoming ring timeout on either platform.
   useEffect(() => {
     if (call.phase !== 'requesting' || call.direction !== 'outgoing') {
       return;
@@ -520,6 +525,17 @@ const VideoCallOverlayInner: FC = () => {
     return () => clearTimeout(timer);
   }, [call.phase, call.direction, call.startedAt, dispatch, t]);
 
+  useEffect(() => {
+    if (call.phase !== 'ringing-incoming' || call.direction !== 'incoming') {
+      return;
+    }
+    const elapsed = Date.now() - (call.startedAt || Date.now());
+    const timer = setTimeout(() => {
+      dispatch(declineIncomingCall());
+    }, Math.max(0, INCOMING_CALL_TIMEOUT_MS - elapsed));
+    return () => clearTimeout(timer);
+  }, [call.phase, call.direction, call.startedAt, dispatch]);
+
   // Buzz while an incoming call is ringing. The ring screen is already on
   // top, so this is the only alert needed when the app is in the
   // foreground; a backgrounded/killed app is handled by the call push.

package/src/components/VideoCalls/callActions.ts

@@ -7,6 +7,7 @@ import {
   sendCallStateSignal,
 } from '../../networking/callTokenStanza';
 import { translateKey } from '../../i18n/strings';
+import { getGlobalXmppClient } from '../../utils/clientRegistry';
 
 /**
  * Call teardown that doesn't need a mounted component.
@@ -51,6 +52,33 @@ export const declineActiveCall = (): void => {
   store.dispatch(declineIncomingCall());
 };
 
+const DECLINE_SIGNAL_WAIT_MS = 30_000;
+const DECLINE_SIGNAL_POLL_MS = 500;
+
+/**
+ * Decline the ringing call, telling the caller as soon as the socket is
+ * up. A call declined on the lock screen right after a push woke the app
+ * gets here while XMPP is still connecting, and the signal would be lost.
+ */
+export const declineActiveCallWhenOnline = (): void => {
+  const call = store.getState().call;
+  const signal = {
+    peerXmppUsername: call.peerXmppUsername,
+    callId: call.callId,
+    roomBareName: call.roomBareName,
+  };
+  store.dispatch(declineIncomingCall());
+  const deadline = Date.now() + DECLINE_SIGNAL_WAIT_MS;
+  const attempt = () => {
+    if (getGlobalXmppClient()?.status === 'online') {
+      sendCallStateSignal('declined', signal);
+      return;
+    }
+    if (Date.now() < deadline) {setTimeout(attempt, DECLINE_SIGNAL_POLL_MS);}
+  };
+  attempt();
+};
+
 /** `t` for code outside React, resolved by the same rule as useT. */
 export const translateCallString = (
   key: string,

package/src/components/VideoCalls/systemCall.ts

@@ -0,0 +1,109 @@
+import { Platform } from 'react-native';
+
+
+export interface CallKeepModule {
+  setup: (options: any) => Promise<void>;
+  displayIncomingCall: (
+    uuid: string,
+    handle: string,
+    localizedCallerName?: string,
+    handleType?: string,
+    hasVideo?: boolean
+  ) => void;
+  endCall: (uuid: string) => void;
+  endAllCalls: () => void;
+  startCall?: (
+    uuid: string,
+    handle: string,
+    contactIdentifier?: string,
+    handleType?: string,
+    hasVideo?: boolean
+  ) => void;
+  answerIncomingCall?: (uuid: string) => void;
+  reportConnectingOutgoingCallWithUUID?: (uuid: string) => void;
+  reportConnectedOutgoingCallWithUUID?: (uuid: string) => void;
+  reportEndCallWithUUID?: (uuid: string, reason: number) => void;
+  setMutedCall?: (uuid: string, muted: boolean) => void;
+  addEventListener: (event: string, handler: (payload: any) => void) => void;
+  removeEventListener: (event: string) => void;
+  setAvailable?: (available: boolean) => void;
+  backToForeground?: () => void;
+  clearInitialEvents?: () => void;
+}
+
+let cachedCallKeep: CallKeepModule | null | undefined;
+
+export const loadCallKeep = (): CallKeepModule | null => {
+  if (cachedCallKeep !== undefined) {
+    return cachedCallKeep;
+  }
+  try {
+    const { NativeModules } = require('react-native');
+    if (!NativeModules?.RNCallKeep) {
+      cachedCallKeep = null;
+      return cachedCallKeep;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('react-native-callkeep');
+    cachedCallKeep = (mod?.default || mod) as CallKeepModule;
+  } catch {
+    cachedCallKeep = null;
+  }
+  return cachedCallKeep;
+};
+
+export const callKitUuid = (seed: string): string => {
+  let hash = 0x811c9dc5;
+  const bytes: number[] = [];
+  for (let i = 0; i < 32; i++) {
+    const ch = seed.charCodeAt(i % Math.max(1, seed.length)) + i;
+    hash ^= ch;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    bytes.push(hash & 0xff);
+  }
+  const hex = bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    '4' + hex.slice(13, 16),
+    ((parseInt(hex[16], 16) & 0x3) | 0x8).toString(16) + hex.slice(17, 20),
+    hex.slice(20, 32),
+  ].join('-');
+};
+
+export type SystemCallAction = 'answer' | 'end';
+
+const SYSTEM_ACTION_TTL_MS = 2 * 60 * 1000;
+const pendingActions = new Map<string, { action: SystemCallAction; at: number }>();
+
+const key = (uuid: string) => uuid.trim().toLowerCase();
+
+export const rememberSystemCallAction = (
+  uuid: string,
+  action: SystemCallAction
+): void => {
+  if (!uuid) {return;}
+  pendingActions.set(key(uuid), { action, at: Date.now() });
+};
+
+export const takeSystemCallAction = (uuid: string): SystemCallAction | null => {
+  const entry = pendingActions.get(key(uuid));
+  pendingActions.delete(key(uuid));
+  if (!entry || Date.now() - entry.at > SYSTEM_ACTION_TTL_MS) {return null;}
+  return entry.action;
+};
+
+export const endSystemIncomingCall = (callId: string | null | undefined): void => {
+  if (Platform.OS !== 'ios' || !callId) {return;}
+  const callKeep = loadCallKeep();
+  if (!callKeep?.reportEndCallWithUUID) {return;}
+  try {
+    callKeep.reportEndCallWithUUID(callKitUuid(callId), 3);
+  } catch {
+  }
+};
+
+export const __resetSystemCallForTests = (): void => {
+  pendingActions.clear();
+  cachedCallKeep = undefined;
+};

package/src/components/VideoCalls/useCallKeep.ts

@@ -4,10 +4,16 @@ import { useDispatch, useSelector } from 'react-redux';
 import { RootState, store } from '../../roomStore';
 import { acceptIncomingCall, declineIncomingCall } from '../../roomStore/callSlice';
 import { sendCallStateSignal } from '../../networking/callTokenStanza';
-import { terminateActiveCall } from './callActions';
+import { declineActiveCallWhenOnline, terminateActiveCall } from './callActions';
 import { setCallMicEnabled, useCallSession } from './callSessionController';
 import { loadLiveKit } from './livekitRuntime';
 import { setCallSystemRinging } from './callUiStore';
+import {
+  callKitUuid,
+  loadCallKeep,
+  rememberSystemCallAction,
+  takeSystemCallAction,
+} from './systemCall';
 
 /**
  * Native incoming-call UI (Android ConnectionService / iOS CallKit) via
@@ -27,95 +33,15 @@ import { setCallSystemRinging } from './callUiStore';
  * Platform reality, stated plainly:
  *  - Android: full value. A ConnectionService call shows the system
  *    incoming-call screen over the lock screen.
- *  - iOS: this only fires while the app is running. A CallKit screen from
- *    a killed app requires a VoIP push over PushKit, which needs a
- *    separate Apple VoIP certificate and a separate send path on the
- *    backend (not FCM). Until that exists, iOS falls back to the regular
- *    data push and the in-app ring screen.
+ *  - iOS: this hook only runs while `<Chat>` is mounted. A CallKit screen
+ *    from a killed app comes from the host: its PushKit handler reports
+ *    the VoIP push to CallKit natively under `callKitUuid(callId)` and
+ *    hands the payload to `handlePushPayload`. This hook then adopts that
+ *    call (same UUID, CallKit answers "CallUUIDAlreadyExists" to our own
+ *    report) and replays what the user did on it before JS was up.
  */
 
-interface CallKeepModule {
-  setup: (options: any) => Promise<void>;
-  displayIncomingCall: (
-    uuid: string,
-    handle: string,
-    localizedCallerName?: string,
-    handleType?: string,
-    hasVideo?: boolean
-  ) => void;
-  endCall: (uuid: string) => void;
-  endAllCalls: () => void;
-  startCall?: (
-    uuid: string,
-    handle: string,
-    contactIdentifier?: string,
-    handleType?: string,
-    hasVideo?: boolean
-  ) => void;
-  answerIncomingCall?: (uuid: string) => void;
-  reportConnectingOutgoingCallWithUUID?: (uuid: string) => void;
-  reportConnectedOutgoingCallWithUUID?: (uuid: string) => void;
-  reportEndCallWithUUID?: (uuid: string, reason: number) => void;
-  setMutedCall?: (uuid: string, muted: boolean) => void;
-  addEventListener: (event: string, handler: (payload: any) => void) => void;
-  removeEventListener: (event: string) => void;
-  setAvailable?: (available: boolean) => void;
-  backToForeground?: () => void;
-}
-
-let cachedCallKeep: CallKeepModule | null | undefined;
-
-export const loadCallKeep = (): CallKeepModule | null => {
-  if (cachedCallKeep !== undefined) {
-    return cachedCallKeep;
-  }
-  try {
-    // The JS package being installed does NOT mean the native side is
-    // linked: a host can `npm i react-native-callkeep` and skip
-    // `pod install`, or (very common in this repo) node_modules can carry
-    // it over from another branch whose build did link it. In that state
-    // requiring the package builds a `new NativeEventEmitter(null)` at
-    // module scope, which throws an invariant that RN surfaces as an
-    // uncaught redbox on every render of the call overlay — the whole app
-    // becomes unusable over a feature the host never switched on.
-    // Probing NativeModules first keeps the optional dependency genuinely
-    // optional: no native module => behave exactly as if it isn't installed.
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { NativeModules } = require('react-native');
-    if (!NativeModules?.RNCallKeep) {
-      cachedCallKeep = null;
-      return cachedCallKeep;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const mod = require('react-native-callkeep');
-    cachedCallKeep = (mod?.default || mod) as CallKeepModule;
-  } catch {
-    cachedCallKeep = null;
-  }
-  return cachedCallKeep;
-};
-
-// CallKeep identifies calls by UUID. Our callIds aren't UUIDs, so derive a
-// stable v4-shaped string from the callId: same call always maps to the
-// same UUID, which is what endCall() needs to dismiss the right screen.
-const toUuid = (seed: string): string => {
-  let hash = 0x811c9dc5;
-  const bytes: number[] = [];
-  for (let i = 0; i < 32; i++) {
-    const ch = seed.charCodeAt(i % Math.max(1, seed.length)) + i;
-    hash ^= ch;
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-    bytes.push(hash & 0xff);
-  }
-  const hex = bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    '4' + hex.slice(13, 16),
-    ((parseInt(hex[16], 16) & 0x3) | 0x8).toString(16) + hex.slice(17, 20),
-    hex.slice(20, 32),
-  ].join('-');
-};
+export { loadCallKeep };
 
 const trace = (...args: unknown[]) => {
   if (__DEV__) {console.log('[calls] CallKit:', ...args);}
@@ -192,7 +118,25 @@ export const useCallKeep = (): void => {
   useEffect(() => {
     if (!callKeep) {return;}
 
-    const onAnswer = () => {
+    const isOtherCall = (payload: any): boolean => {
+      const uuid = String(payload?.callUUID || '').toLowerCase();
+      if (!uuid) {return false;}
+      const active = activeUuidRef.current?.toLowerCase() || null;
+      if (active === uuid) {return false;}
+      const current = store.getState().call;
+      const ringingUuid =
+        current.direction === 'incoming' && current.callId
+          ? callKitUuid(current.callId)
+          : null;
+      return ringingUuid !== uuid;
+    };
+
+    const onAnswer = (payload?: any) => {
+      if (isOtherCall(payload)) {
+        trace('answer before the call arrived', payload?.callUUID);
+        rememberSystemCallAction(String(payload.callUUID), 'answer');
+        return;
+      }
       answeredRef.current = true;
       // The user answered from the system screen, which on Android may
       // mean the app was not even in the foreground.
@@ -206,7 +150,12 @@ export const useCallKeep = (): void => {
       }
     };
 
-    const onEnd = () => {
+    const onEnd = (payload?: any) => {
+      if (isOtherCall(payload)) {
+        trace('declined before the call arrived', payload?.callUUID);
+        rememberSystemCallAction(String(payload.callUUID), 'end');
+        return;
+      }
       const snapshot = store.getState().call;
       if (snapshot.phase === 'idle') {return;}
       if (
@@ -262,16 +211,46 @@ export const useCallKeep = (): void => {
     callKeep.addEventListener('didResetProvider', onReset);
     // The system's verdict on displayIncomingCall ("Unentitled" means the
     // app lacks the voip background mode).
-    const onDisplayed = ({ error, errorCode }: { error?: string; errorCode?: string }) => {
-      trace('incoming call shown', error ? `failed: ${errorCode || ''} ${error}` : 'ok');
+    const onDisplayed = ({
+      error,
+      errorCode,
+      fromPushKit,
+    }: {
+      error?: string;
+      errorCode?: string;
+      fromPushKit?: string;
+    }) => {
+      trace(
+        `incoming call shown${fromPushKit === '1' ? ' (PushKit)' : ''}`,
+        error ? `failed: ${errorCode || ''} ${error}` : 'ok'
+      );
+      if (errorCode === 'CallUUIDAlreadyExists') {return;}
       // CallKit refused it (Do Not Disturb, unentitled...): bring the
-      // in-app ring card back so the call can still be answered.
-      if (error) {setCallSystemRinging(false);}
+      if (error && fromPushKit !== '1') {setCallSystemRinging(false);}
     };
     callKeep.addEventListener('didDisplayIncomingCall', onDisplayed);
     callKeep.addEventListener('didDeactivateAudioSession', onAudioDeactivated);
 
+    const replay: Record<string, (data: any) => void> = {
+      RNCallKeepPerformAnswerCallAction: onAnswer,
+      RNCallKeepPerformEndCallAction: onEnd,
+      RNCallKeepDidDisplayIncomingCall: onDisplayed,
+      RNCallKeepDidActivateAudioSession: onAudioActivated,
+      RNCallKeepDidDeactivateAudioSession: onAudioDeactivated,
+      RNCallKeepDidPerformSetMutedCallAction: onMuted,
+    };
+    const onLoadWithEvents = (events: { name: string; data: any }[]) => {
+      if (!Array.isArray(events) || events.length === 0) {return;}
+      trace('replaying', events.map((e) => e.name).join(', '));
+      callKeep.clearInitialEvents?.();
+      for (const event of events) {
+        replay[event.name]?.(event.data);
+      }
+    };
+    callKeep.addEventListener('didLoadWithEvents', onLoadWithEvents);
+
     return () => {
+      callKeep.removeEventListener('didLoadWithEvents');
       callKeep.removeEventListener('answerCall');
       callKeep.removeEventListener('endCall');
       callKeep.removeEventListener('didPerformSetMutedCallAction');
@@ -313,11 +292,23 @@ export const useCallKeep = (): void => {
 
     if (isRinging) {
       if (activeUuidRef.current) {return;}
-      const uuid = toUuid(call.callId || call.roomJid || String(Date.now()));
+      const uuid = callKitUuid(call.callId || call.roomJid || String(Date.now()));
       activeUuidRef.current = uuid;
       answeredRef.current = false;
+      const earlier = takeSystemCallAction(uuid);
+      if (earlier === 'answer') {
+        trace('answered earlier on the system screen', uuid);
+        answeredRef.current = true;
+        dispatch(acceptIncomingCall());
+        return;
+      }
+      if (earlier === 'end') {
+        trace('declined earlier on the system screen', uuid);
+        activeUuidRef.current = null;
+        declineActiveCallWhenOnline();
+        return;
+      }
       // iOS: the system banner is the ring UI (Telegram-style); the in-app
-      // card would only cover the screen under it.
       if (isIOS) {setCallSystemRinging(true);}
       try {
         callKeep.displayIncomingCall(
@@ -339,7 +330,7 @@ export const useCallKeep = (): void => {
     if (isIOS && isOutgoing && !activeUuidRef.current && callKeep.startCall) {
       // Unique per call: CallKit refuses a UUID it has seen before, and
       // the callId only arrives with the token.
-      const uuid = toUuid(`${call.roomJid || ''}|${call.startedAt || Date.now()}`);
+      const uuid = callKitUuid(`${call.roomJid || ''}|${call.startedAt || Date.now()}`);
       activeUuidRef.current = uuid;
       outgoingReportedRef.current = 'none';
       trace('startCall', uuid);
@@ -382,6 +373,7 @@ export const useCallKeep = (): void => {
   }, [
     callKeep,
     ready,
+    dispatch,
     isIOS,
     isRinging,
     isLive,