@ethora/chat-component-rn 26.10.7 → 26.10.9

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

@@ -2,12 +2,17 @@ import { useEffect, useMemo, useRef, useState } from 'react';
 import { Platform } from 'react-native';
 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 { acceptIncomingCall } from '../../roomStore/callSlice';
+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 +32,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 +117,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,15 +149,19 @@ 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 (
         snapshot.direction === 'incoming' &&
         snapshot.phase === 'ringing-incoming'
       ) {
-        sendCallStateSignal('declined');
-        dispatch(declineIncomingCall());
+        declineActiveCallWhenOnline();
         return;
       }
       // Ended from the Dynamic Island, the lock screen or a headset.
@@ -262,16 +209,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 +290,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 +328,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 +371,7 @@ export const useCallKeep = (): void => {
   }, [
     callKeep,
     ready,
+    dispatch,
     isIOS,
     isRinging,
     isLive,

package/src/helpers/incomingCallFromPush.ts

@@ -1,33 +1,61 @@
 import { store } from '../roomStore';
-import { setIncomingCallToken } from '../roomStore/callSlice';
+import { acceptIncomingCall, setIncomingCallToken } from '../roomStore/callSlice';
+import { endSystemIncomingCall } from '../components/VideoCalls/systemCall';
+import { declineActiveCallWhenOnline } from '../components/VideoCalls/callActions';
 import { isCallPush, parseCallPush } from './callPush';
+import { normalizeRoomJid } from './normalizeRoomJid';
 
-/**
- * Turn an incoming-call push into a ringing call.
- *
- * On mobile the XMPP socket dies whenever the OS backgrounds or kills the
- * app, and the `call-token` stanza that normally opens the ring screen is
- * lost with it. The backend also delivers the call as a data push, so this
- * is the path every call takes when the app was not in the foreground.
- *
- * Returns true when the payload WAS a call push (whether or not it could
- * be rung), so the caller knows to stop and not also show it as a chat
- * notification. A user should never get a "new message: call-state" toast.
- */
-export const handleCallPush = (
-  data: Record<string, any> | null | undefined
-): boolean => {
-  if (!isCallPush(data)) {
-    return false;
-  }
+const PENDING_CALL_PUSH_TTL_MS = 60_000;
+
+
+export type CallPushIntent = 'ring' | 'answer' | 'decline';
+
+let pendingPush: { data: Record<string, any>; intent: CallPushIntent; at: number } | null = null;
+let unwatch: (() => void) | null = null;
+
+const trace = (...args: unknown[]) => {
+  if (__DEV__) {console.log('[calls] push:', ...args);}
+};
+
+const callsConfigured = (): boolean =>
+  store.getState().chatSettingStore.config?.videoCalls !== undefined;
+
+const holdUntilConfigured = (data: Record<string, any>, intent: CallPushIntent): void => {
+  pendingPush = { data, intent, at: Date.now() };
+  if (unwatch) {return;}
+  unwatch = store.subscribe(() => {
+    if (!callsConfigured()) {return;}
+    unwatch?.();
+    unwatch = null;
+    const held = pendingPush;
+    pendingPush = null;
+    if (!held) {return;}
+    if (Date.now() - held.at > PENDING_CALL_PUSH_TTL_MS) {
+      trace('held call push expired');
+      endSystemIncomingCall(parseCallPush(held.data).callId);
+      return;
+    }
+    ringFromPush(held.data, held.intent);
+  });
+};
 
+const applyIntent = (intent: CallPushIntent): void => {
+  const call = store.getState().call;
+  if (call.direction !== 'incoming' || call.phase !== 'ringing-incoming') {return;}
+  if (intent === 'answer') {store.dispatch(acceptIncomingCall());}
+  if (intent === 'decline') {declineActiveCallWhenOnline();}
+};
+
+const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolean => {
   const parsed = parseCallPush(data);
   const state = store.getState();
 
   // Calls off in this deployment: swallow the push rather than ringing a
   // screen the host never opted into.
   if (state.chatSettingStore.config?.videoCalls?.enabled !== true) {
-    return true;
+    trace('calls are off, dropping', parsed.callId);
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   // Already ringing or in this exact call (the push raced the stanza, or
@@ -38,9 +66,15 @@ export const handleCallPush = (
     const sameCall =
       (!!parsed.callId && parsed.callId === current.callId) ||
       (!!parsed.roomBareName && parsed.roomBareName === current.roomBareName);
-    if (sameCall || current.phase === 'in-call') {
+    if (sameCall) {
+      applyIntent(intent);
       return true;
     }
+    if (current.phase === 'in-call') {
+      // Busy with another call: no second ring.
+      endSystemIncomingCall(parsed.callId);
+      return false;
+    }
   }
 
   // Without a LiveKit token there is nothing to accept: the push is only
@@ -48,7 +82,8 @@ export const handleCallPush = (
   // cannot work, so treat it as handled and let the stanza (once the
   // socket is back up) open the real ring screen.
   if (!parsed.token) {
-    return true;
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   // Resolve the full room JID from the local room map. The push carries
@@ -60,11 +95,16 @@ export const handleCallPush = (
       room?.jid === parsed.roomRef
   ) as { jid?: string; name?: string; title?: string } | undefined;
 
-  const roomJid =
-    resolved?.jid ||
-    (parsed.roomRef && parsed.roomRef.includes('@') ? parsed.roomRef : '');
+  const conference =
+    state.chatSettingStore.config?.xmppSettings?.conference || '';
+  const fromRef = parsed.roomRef
+    ? normalizeRoomJid(parsed.roomRef, conference)
+    : '';
+  const roomJid = resolved?.jid || (fromRef.includes('@') ? fromRef : '');
   if (!roomJid) {
-    return true;
+    trace('no room for call push', parsed.roomRef);
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   store.dispatch(
@@ -78,6 +118,37 @@ export const handleCallPush = (
       peerXmppUsername: parsed.callerXmppUsername,
     })
   );
+  trace('ringing', parsed.callId, intent);
+  applyIntent(intent);
+  return true;
+};
 
+export const handleCallPush = (
+  data: Record<string, any> | null | undefined,
+  intent: CallPushIntent = 'ring'
+): boolean => {
+  if (!isCallPush(data)) {
+    return false;
+  }
+  if (!callsConfigured()) {
+    trace('holding call push until the chat is configured');
+    holdUntilConfigured(data as Record<string, any>, intent);
+    return true;
+  }
+  ringFromPush(data as Record<string, any>, intent);
   return true;
 };
+
+export const answerCallFromPush = (
+  data: Record<string, any> | null | undefined
+): boolean => handleCallPush(data, 'answer');
+
+export const declineCallFromPush = (
+  data: Record<string, any> | null | undefined
+): boolean => handleCallPush(data, 'decline');
+
+export const __resetCallPushForTests = (): void => {
+  unwatch?.();
+  unwatch = null;
+  pendingPush = null;
+};

package/src/main.ts

@@ -33,6 +33,14 @@ export { XmppProvider } from './context/xmppProvider';
 export { useUnread } from './hooks/useUnreadMessagesCounter';
 
 export { handlePushPayload, openRoomFromPush } from './helpers/pushPayload';
+export { callKitUuid } from './components/VideoCalls/systemCall';
+export {
+  answerCallFromPush,
+  declineCallFromPush,
+} from './helpers/incomingCallFromPush';
+export type { CallPushIntent } from './helpers/incomingCallFromPush';
+export { isCallPush, parseCallPush } from './helpers/callPush';
+export type { ParsedCallPush } from './helpers/callPush';
 export type { PushPayloadOutcome } from './helpers/pushPayload';
 export {
   registerPushToken,
@@ -73,7 +81,7 @@ export {
   presentSealedPush,
   SEALED_PUSH_TASK,
 } from './push/sealedPushTask';
-export type { SealedPushTaskOptions } from './push/sealedPushTask';
+export type { SealedPushTaskOptions, ShownMessagePush } from './push/sealedPushTask';
 export {
   openSealedPush,
   isSealedPush,