@ethora/chat-component-rn 26.10.10 → 26.10.11

package/src/components/VideoCalls/callSessionTypes.ts

@@ -0,0 +1,80 @@
+/**
+ * What the call UI reads from the media session of the current call.
+ *
+ * Two transports fill the same snapshot: the LiveKit room
+ * (callSessionController.ts) and the peer to peer connection
+ * (p2pCallSession.ts), so the screen, the minimized strip, CallKit and the
+ * ongoing-call notification never need to know which one carries the call.
+ */
+
+/**
+ * One person in a group call grid. `video` is an opaque handle for
+ * `<CallVideo source={...} />`, present only while a live, unmuted camera
+ * track exists.
+ */
+export interface CallParticipantView {
+  identity: string;
+  name: string;
+  isLocal: boolean;
+  video: any;
+  micMuted: boolean;
+  speaking: boolean;
+}
+
+export interface CallSessionSnapshot {
+  /** A media session (LiveKit room or p2p connection) exists for the current call. */
+  active: boolean;
+  connected: boolean;
+  /** Translated, dismissible camera/mic problem. Never fails the call. */
+  deviceError: string | null;
+  micOn: boolean;
+  cameraOn: boolean;
+  speakerOn: boolean;
+  /** Which camera the local video comes from; only the front one is mirrored. */
+  facingMode: 'user' | 'environment';
+  /**
+   * Bumped whenever the local camera track is re-acquired, so the self view
+   * can remount onto the new stream instead of holding the stopped one.
+   */
+  localVideoEpoch: number;
+  /** Opaque video handle for `<CallVideo />`, live and unmuted only. */
+  remoteVideo: any;
+  localVideo: any;
+  remoteName: string | null;
+  remoteJoined: boolean;
+  /** Peer joined but has no live microphone. */
+  remoteMicMuted: boolean;
+  /**
+   * When the call truly connected: the later of the two LiveKit `joinedAt`
+   * stamps (p2p: when media first flowed). The server sets the LiveKit ones,
+   * so both sides count from the same moment (web's useSharedCallElapsed).
+   * Null until the peer is in. In a group: when the first two were in.
+   */
+  anchorAt: number | null;
+  /** Group room call: render `participants` as a grid. */
+  isGroup: boolean;
+  /** Everyone in a group call, local first. Empty for a 1:1 call. */
+  participants: CallParticipantView[];
+  /** p2p only: media was flowing and the connection is being restored. */
+  reconnecting: boolean;
+}
+
+export const IDLE_SESSION: CallSessionSnapshot = {
+  active: false,
+  connected: false,
+  deviceError: null,
+  micOn: true,
+  cameraOn: false,
+  speakerOn: false,
+  facingMode: 'user',
+  localVideoEpoch: 0,
+  remoteVideo: null,
+  localVideo: null,
+  remoteName: null,
+  remoteJoined: false,
+  remoteMicMuted: false,
+  anchorAt: null,
+  isGroup: false,
+  participants: [],
+  reconnecting: false,
+};

package/src/components/VideoCalls/groupLayout.ts

@@ -0,0 +1,48 @@
+import type { CallParticipantView } from './callSessionTypes';
+
+/**
+ * Pure layout decisions of the group call grid, kept apart from the view so
+ * they can be tested on their own.
+ */
+
+/**
+ * Most camera surfaces rendered at once. A phone cannot decode and draw 50
+ * videos; the rest of the room shows as avatars until they speak. A track
+ * with no surface attached is also not requested from the server
+ * (adaptiveStream), so this bounds the bandwidth too.
+ */
+export const MAX_VIDEO_TILES = 9;
+
+/** Columns of the grid for `count` participants. */
+export const gridColumns = (count: number, landscape: boolean): number => {
+  if (count <= 1) return 1;
+  if (count <= 4) return landscape ? Math.min(count, 4) : 2;
+  return landscape ? 4 : 3;
+};
+
+/**
+ * Which participants get a live video surface. Whoever is speaking comes
+ * first, then us, then everyone else in grid order, until the budget is
+ * used. Participants without a live camera never take a slot.
+ */
+export const pickVideoTiles = (
+  participants: CallParticipantView[],
+  max: number = MAX_VIDEO_TILES
+): Set<string> => {
+  const withVideo = participants.filter((p) => !!p.video);
+  const ranked = [
+    ...withVideo.filter((p) => p.speaking),
+    ...withVideo.filter((p) => !p.speaking && p.isLocal),
+    ...withVideo.filter((p) => !p.speaking && !p.isLocal),
+  ];
+  return new Set(ranked.slice(0, Math.max(0, max)).map((p) => p.identity));
+};
+
+/** Names of the people currently speaking, for the header line. */
+export const speakingNames = (
+  participants: CallParticipantView[],
+  youLabel: string
+): string[] =>
+  participants
+    .filter((p) => p.speaking)
+    .map((p) => (p.isLocal ? youLabel : p.name));

package/src/components/VideoCalls/p2pCallSession.ts

@@ -0,0 +1,291 @@
+import { useSyncExternalStore } from 'react';
+import { Platform } from 'react-native';
+import type {
+  P2PCallController,
+  P2PSnapshot,
+} from '../../calls/p2p/P2PCallController';
+import { loadLiveKit } from './livekitRuntime';
+import { translateCallString } from './callActions';
+import { CallSessionSnapshot, IDLE_SESSION } from './callSessionTypes';
+
+/**
+ * The peer to peer call, seen through the same snapshot the LiveKit session
+ * produces (callSessionController.ts), so the call screen, the minimized
+ * strip, CallKit and the ongoing-call notification serve both transports.
+ *
+ * Like the LiveKit session it is owned outside React: P2PCallRunner binds the
+ * controller of the current call here and unbinds it when the call stops.
+ * Video is handed to the UI as a `{ streamURL, key }` handle for RTCView;
+ * remote audio needs nothing, react-native-webrtc plays it on its own.
+ */
+
+// The controller words its failures in English (it is shared with the web
+// SDK); the strings the user can see are mapped to the translated tables here.
+const MESSAGE_KEYS: Record<string, string> = {
+  'Camera or microphone permission denied': 'call.error.deviceBlocked',
+  'No camera or microphone found on this device': 'call.error.deviceNotFound',
+  'Your camera or microphone is already in use by another app':
+    'call.error.deviceInUse',
+  'Could not access your camera or microphone': 'call.error.deviceGeneric',
+  'The other person could not access their camera or microphone':
+    'call.error.p2pPeerMedia',
+  'The call could not be connected': 'call.error.p2pConnect',
+  'Could not connect the call': 'call.error.p2pConnect',
+  'Could not start the call': 'call.error.p2pSetup',
+  'Could not set up the call': 'call.error.p2pSetup',
+  'Connection lost': 'call.error.p2pConnectionLost',
+};
+
+/** Translated version of a message the p2p controller produced. */
+export const localizeP2PMessage = (message: string): string => {
+  const key = MESSAGE_KEYS[message];
+  return key ? translateCallString(key) : message;
+};
+
+interface Bound {
+  controller: P2PCallController;
+  kind: 'audio' | 'video';
+  unsubscribe: () => void;
+  /** First time media flowed; kept across reconnects. */
+  connectedAt: number | null;
+}
+
+let bound: Bound | null = null;
+let snapshot: CallSessionSnapshot = IDLE_SESSION;
+let speakerOn = false;
+let facingMode: 'user' | 'environment' = 'user';
+let remoteHandle: any = null;
+let localHandle: any = null;
+const listeners = new Set<() => void>();
+
+const emit = (next: CallSessionSnapshot) => {
+  snapshot = next;
+  listeners.forEach((listener) => listener());
+};
+
+const subscribe = (listener: () => void) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+export const getP2PSessionSnapshot = (): CallSessionSnapshot => snapshot;
+
+export const isP2PSessionActive = (): boolean => bound !== null;
+
+export const useP2PSession = (): CallSessionSnapshot =>
+  useSyncExternalStore(subscribe, getP2PSessionSnapshot, getP2PSessionSnapshot);
+
+// A video handle for RTCView. RTCView binds to the stream's video track when
+// the stream URL is set, so the key carries the track ids: a camera that is
+// turned off and on again, or a remote video that arrives late, remounts the
+// view onto the stream as it is now.
+const videoHandle = (
+  stream: MediaStream | null,
+  previous: any
+): { handle: any } => {
+  const tracks = stream?.getVideoTracks?.() || [];
+  if (!stream || tracks.length === 0) return { handle: null };
+  const streamURL = String((stream as any).toURL?.() ?? '');
+  if (!streamURL) return { handle: null };
+  const key = `${streamURL}|${tracks.map((t) => t.id).join(',')}`;
+  if (previous && previous.key === key) return { handle: previous };
+  return { handle: { streamURL, key } };
+};
+
+const connectedStatus = (status: P2PSnapshot['status']): boolean =>
+  status === 'waiting' || status === 'connected';
+
+const build = (current: Bound, p2p: P2PSnapshot): CallSessionSnapshot => {
+  const hasMedia = p2p.status === 'connected' || p2p.status === 'reconnecting';
+  if (hasMedia && current.connectedAt === null) {
+    current.connectedAt = Date.now();
+  }
+
+  const remote = videoHandle(
+    p2p.remoteVideoLive ? p2p.remoteStream : null,
+    remoteHandle
+  );
+  remoteHandle = remote.handle;
+  const local = videoHandle(
+    current.kind === 'video' && p2p.camEnabled ? p2p.localStream : null,
+    localHandle
+  );
+  localHandle = local.handle;
+
+  return {
+    ...IDLE_SESSION,
+    active: true,
+    // "Connected" here means the offer is out or media flows, i.e. the
+    // screen may say "waiting for the other person" instead of "connecting".
+    connected: connectedStatus(p2p.status),
+    deviceError: p2p.notice ? localizeP2PMessage(p2p.notice) : null,
+    micOn: p2p.micEnabled,
+    cameraOn: current.kind === 'video' && p2p.camEnabled,
+    speakerOn,
+    facingMode,
+    remoteVideo: remoteHandle,
+    localVideo: localHandle,
+    remoteJoined: hasMedia,
+    anchorAt: current.connectedAt,
+    reconnecting: p2p.status === 'reconnecting',
+  };
+};
+
+const refresh = () => {
+  if (!bound) return;
+  emit(build(bound, bound.controller.getSnapshot()));
+};
+
+/**
+ * Show `controller`'s call through the session snapshot. Returns the unbind
+ * function. Only one call is ever bound; binding another replaces it.
+ */
+export const bindP2PSession = (
+  controller: P2PCallController,
+  kind: 'audio' | 'video'
+): (() => void) => {
+  if (bound?.controller === controller) return unbindFor(controller);
+  if (bound) unbindP2PSession();
+  speakerOn = kind === 'video';
+  facingMode = 'user';
+  remoteHandle = null;
+  localHandle = null;
+  const current: Bound = {
+    controller,
+    kind,
+    unsubscribe: controller.subscribe(refresh),
+    connectedAt: null,
+  };
+  bound = current;
+  refresh();
+  return unbindFor(controller);
+};
+
+const unbindFor = (controller: P2PCallController) => () => {
+  if (bound?.controller === controller) unbindP2PSession();
+};
+
+export const unbindP2PSession = (): void => {
+  const current = bound;
+  if (!current) return;
+  bound = null;
+  current.unsubscribe();
+  remoteHandle = null;
+  localHandle = null;
+  try {
+    void loadLiveKit()?.AudioSession?.stopAudioSession();
+  } catch {
+    // Never let teardown throw.
+  }
+  emit(IDLE_SESSION);
+};
+
+/**
+ * Claim the native audio session before the connection comes up. Without
+ * this the first seconds route to the earpiece on Android even for a video
+ * call (the LiveKit session does the same before `room.connect`). Best
+ * effort: a call answered from CallKit already owns the iOS session.
+ */
+export const prepareP2PAudio = async (
+  kind: 'audio' | 'video'
+): Promise<void> => {
+  const audio = loadLiveKit()?.AudioSession;
+  if (!audio) return;
+  try {
+    await audio.startAudioSession();
+  } catch {
+    // CallKit activates the iOS audio session itself.
+  }
+  try {
+    await audio.setAppleAudioConfiguration?.({
+      audioCategory: 'playAndRecord',
+      audioCategoryOptions: kind === 'video' ? ['defaultToSpeaker'] : [],
+      audioMode: kind === 'video' ? 'videoChat' : 'voiceChat',
+    });
+  } catch {
+    // iOS-only helper.
+  }
+};
+
+/** Audio session first, then media and the offer / answer. */
+export const startP2PController = async (
+  controller: P2PCallController,
+  kind: 'audio' | 'video'
+): Promise<void> => {
+  await prepareP2PAudio(kind);
+  if (bound?.controller !== controller) {
+    // The call was cancelled while the audio session was coming up.
+    try {
+      void loadLiveKit()?.AudioSession?.stopAudioSession();
+    } catch {
+      // Never let teardown throw.
+    }
+    return;
+  }
+  await controller.start();
+};
+
+// ---- controls -----------------------------------------------------------
+
+export const setP2PMicEnabled = (next: boolean): void => {
+  const current = bound;
+  if (!current || current.controller.getSnapshot().micEnabled === next) return;
+  current.controller.toggleMic();
+};
+
+export const toggleP2PCamera = async (): Promise<void> => {
+  const current = bound;
+  if (!current) return;
+  await current.controller.toggleCamera();
+};
+
+/** Front / back camera of the live local video track. */
+export const switchP2PCamera = (): void => {
+  const current = bound;
+  if (!current) return;
+  const track: any = current.controller.getSnapshot().localStream?.getVideoTracks?.()[0];
+  if (!track || typeof track._switchCamera !== 'function') return;
+  try {
+    track._switchCamera();
+    facingMode = facingMode === 'user' ? 'environment' : 'user';
+    refresh();
+  } catch {
+    // The camera stays where it was.
+  }
+};
+
+export const toggleP2PSpeaker = async (): Promise<void> => {
+  const current = bound;
+  const audio = loadLiveKit()?.AudioSession;
+  if (!current || !audio) return;
+  const next = !speakerOn;
+  speakerOn = next;
+  refresh();
+  try {
+    if (Platform.OS === 'android') {
+      await audio.selectAudioOutput(next ? 'speaker' : 'earpiece');
+    } else {
+      await audio.setAppleAudioConfiguration?.({
+        audioCategory: 'playAndRecord',
+        audioCategoryOptions: next ? ['defaultToSpeaker'] : [],
+        audioMode: next ? 'videoChat' : 'voiceChat',
+      });
+    }
+  } catch {
+    speakerOn = !next;
+    refresh();
+  }
+};
+
+export const dismissP2PDeviceError = (): void => {
+  bound?.controller.dismissNotice();
+};
+
+/** Reset module state. Test seam only. */
+export const __resetP2PCallSessionForTests = (): void => {
+  unbindP2PSession();
+  speakerOn = false;
+  facingMode = 'user';
+};

package/src/components/VideoCalls/useCallKeep.ts

@@ -6,6 +6,7 @@ import { acceptIncomingCall } from '../../roomStore/callSlice';
 import { declineActiveCallWhenOnline, terminateActiveCall } from './callActions';
 import { setCallMicEnabled, useCallSession } from './callSessionController';
 import { loadLiveKit } from './livekitRuntime';
+import { loadWebRTC } from '../../calls/p2p/webrtcRuntime';
 import { setCallSystemRinging } from './callUiStore';
 import {
   callKitUuid,
@@ -42,6 +43,12 @@ import {
 
 export { loadCallKeep };
 
+// WebRTC's view of the iOS audio session. The LiveKit bridge and the p2p one
+// load the same class from the same fork; a p2p-only host may have no
+// LiveKit JS at all.
+const rtcAudioSession = () =>
+  loadLiveKit()?.RTCAudioSession ?? loadWebRTC()?.RTCAudioSession ?? null;
+
 const trace = (...args: unknown[]) => {
   if (__DEV__) {console.log('[calls] CallKit:', ...args);}
 };
@@ -183,14 +190,14 @@ export const useCallKeep = (): void => {
     // unit once CallKit has activated the session.
     const onAudioActivated = () => {
       try {
-        loadLiveKit()?.RTCAudioSession?.audioSessionDidActivate?.();
+        rtcAudioSession()?.audioSessionDidActivate?.();
       } catch {
         // Older webrtc builds manage the session on their own.
       }
     };
     const onAudioDeactivated = () => {
       try {
-        loadLiveKit()?.RTCAudioSession?.audioSessionDidDeactivate?.();
+        rtcAudioSession()?.audioSessionDidDeactivate?.();
       } catch {
         // noop
       }

package/src/components/VideoCalls/useOngoingCallNotification.ts

@@ -9,6 +9,7 @@ import type {
 import { terminateActiveCall } from './callActions';
 import { toggleCallCamera, toggleCallMic, useCallSession } from './callSessionController';
 import { setCallMinimized } from './callUiStore';
+import { callCanRenderSession } from './callLive';
 
 /**
  * Drives the host's ongoing-call notification (`videoCalls.
@@ -25,8 +26,7 @@ export const useOngoingCallNotification = (
   const session = useCallSession();
   const shownRef = useRef(false);
 
-  const live =
-    !!call.token && (call.phase === 'connecting' || call.phase === 'in-call');
+  const live = callCanRenderSession(call);
 
   useEffect(() => {
     if (!adapter) {return;}

package/src/context/xmppProvider.tsx

@@ -11,6 +11,7 @@ import React, {
 import { AppState, DeviceEventEmitter } from 'react-native';
 import NetInfo from '@react-native-community/netinfo';
 import { VideoCallOverlay } from '../components/VideoCalls/VideoCallOverlay';
+import { ScheduledCallHost } from '../components/Booking/ScheduledCallHost';
 import XmppClient, {
   XmppCredentialsProvider,
 } from '../networking/xmppClient';
@@ -976,6 +977,8 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
           config and call state from Redux itself, so it needs nothing
           passed in, and renders null whenever no call is in flight. */}
       <VideoCallOverlay />
+      {/* Schedule / edit sheet and the pre-join screen of a scheduled call. */}
+      <ScheduledCallHost />
     </XmppContext.Provider>
   );
 };

package/src/helpers/callPush.ts

@@ -9,7 +9,10 @@
 
 export interface ParsedCallPush {
   callId: string | null;
-  /** LiveKit token, if the push carried one (lets us ring + accept offline). */
+  /**
+   * LiveKit token, if the push carried one (lets us ring + accept offline).
+   * Empty for a peer to peer call: there is no room to join with it.
+   */
   token: string | null;
   kind: 'audio' | 'video';
   /** Bare room name (JID localpart) the call belongs to. */
@@ -20,6 +23,13 @@ export interface ParsedCallPush {
   callerName: string | null;
   /** Caller's xmpp localpart, when provided. */
   callerXmppUsername: string | null;
+  /**
+   * How the call is carried. `p2p` pushes carry an empty token; an older push
+   * service sends no `mode`, which means `livekit`.
+   */
+  mode: 'p2p' | 'livekit';
+  /** The call is for a group room (always LiveKit). */
+  isGroup: boolean;
 }
 
 const pick = (data: Record<string, any>, keys: string[]): string => {
@@ -86,5 +96,7 @@ export const parseCallPush = (
     callerXmppUsername:
       pick(d, ['callerXmppUsername', 'callerUsername', 'userJid', 'senderJid'])
         .split('@')[0] || null,
+    mode: pick(d, ['mode', 'callMode']).toLowerCase() === 'p2p' ? 'p2p' : 'livekit',
+    isGroup: ['true', '1'].includes(pick(d, ['group', 'isGroup']).toLowerCase()),
   };
 };

package/src/helpers/incomingCallFromPush.ts

@@ -2,6 +2,10 @@ import { store } from '../roomStore';
 import { acceptIncomingCall, setIncomingCallToken } from '../roomStore/callSlice';
 import { endSystemIncomingCall } from '../components/VideoCalls/systemCall';
 import { declineActiveCallWhenOnline } from '../components/VideoCalls/callActions';
+import { reportCallDeclined, reportCallEnded } from '../networking/api-requests/callState.api';
+import { sendCallStateSignal } from '../networking/callTokenStanza';
+import { decideIncomingWhileBusy } from '../calls/callMode';
+import { busySnapshot } from '../calls/callBusy';
 import { isCallPush, parseCallPush } from './callPush';
 import { normalizeRoomJid } from './normalizeRoomJid';
 
@@ -58,11 +62,53 @@ const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolea
     return false;
   }
 
+  const isP2P = parsed.mode === 'p2p';
+
+  // A peer to peer call is correlated by its callId alone (there is no room
+  // token), and one call at a time: decided the way the call-token stanza
+  // decides it. The caller is told when we cannot take it.
+  if (isP2P) {
+    if (!parsed.callId) {
+      trace('p2p call push without a callId, dropping');
+      endSystemIncomingCall(parsed.callId);
+      return false;
+    }
+    const decision = decideIncomingWhileBusy(busySnapshot(state.call), {
+      mode: 'p2p',
+      callId: parsed.callId,
+      roomBareName: parsed.roomBareName,
+    });
+    if (decision === 'duplicate') {
+      applyIntent(intent);
+      return true;
+    }
+    if (decision === 'busy' || decision === 'replace') {
+      trace('busy, declining p2p call', parsed.callId);
+      reportCallDeclined(parsed.callId);
+      sendCallStateSignal('declined', {
+        peerXmppUsername: parsed.callerXmppUsername,
+        callId: parsed.callId,
+        roomBareName: parsed.roomBareName,
+      });
+      endSystemIncomingCall(parsed.callId);
+      return false;
+    }
+    if (decision === 'glare-keep') {
+      endSystemIncomingCall(parsed.callId);
+      return false;
+    }
+    if (decision === 'glare-yield') {
+      // Both sides dialled at once and theirs has the smaller id: drop ours.
+      sendCallStateSignal('cancelled');
+      reportCallEnded(state.call.callId);
+    }
+  }
+
   // Already ringing or in this exact call (the push raced the stanza, or
   // two pushes arrived). Re-dispatching would reset startedAt and restart
   // the ring, so leave the existing call alone.
   const current = state.call;
-  if (current.phase !== 'idle') {
+  if (!isP2P && current.phase !== 'idle') {
     const sameCall =
       (!!parsed.callId && parsed.callId === current.callId) ||
       (!!parsed.roomBareName && parsed.roomBareName === current.roomBareName);
@@ -70,8 +116,9 @@ const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolea
       applyIntent(intent);
       return true;
     }
-    if (current.phase === 'in-call') {
-      // Busy with another call: no second ring.
+    if (current.phase === 'in-call' || current.mode === 'p2p') {
+      // Busy with another call: no second ring. (A p2p call is never
+      // replaced by a LiveKit one, whatever phase it is in.)
       endSystemIncomingCall(parsed.callId);
       return false;
     }
@@ -81,7 +128,8 @@ const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolea
   // an alert. Ringing anyway would give the user an Accept button that
   // 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) {
+  // A p2p call carries no token by design: it is answered over XMPP.
+  if (!parsed.token && !isP2P) {
     endSystemIncomingCall(parsed.callId);
     return false;
   }
@@ -107,15 +155,25 @@ const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolea
     return false;
   }
 
+  // In a group the call is the ROOM and the caller is a separate line; a
+  // 1:1 call is named after the caller.
+  const roomTitle = resolved?.title || resolved?.name || null;
   store.dispatch(
     setIncomingCallToken({
       roomJid,
-      roomName: parsed.callerName || resolved?.title || resolved?.name || null,
+      roomName: parsed.isGroup
+        ? roomTitle
+        : parsed.callerName || roomTitle,
       roomBareName: parsed.roomBareName,
-      token: parsed.token,
+      token: parsed.token || '',
       kind: parsed.kind,
       callId: parsed.callId,
-      peerXmppUsername: parsed.callerXmppUsername,
+      // A group has no single peer to signal.
+      peerXmppUsername: parsed.isGroup ? null : parsed.callerXmppUsername,
+      mode: parsed.mode,
+      isGroup: parsed.isGroup,
+      callerName: parsed.callerName,
+      callerXmppUsername: parsed.callerXmppUsername,
     })
   );
   trace('ringing', parsed.callId, intent);

package/src/helpers/pushPayload.ts

@@ -7,8 +7,14 @@ import {
 } from '../roomStore/roomsSlice';
 import { handleCallPush } from './incomingCallFromPush';
 import { normalizeRoomJid } from './normalizeRoomJid';
+import { handleScheduledCallPush } from '../booking/pendingScheduledCall';
 
-export type PushPayloadOutcome = 'call' | 'room' | 'pending' | 'unknown';
+export type PushPayloadOutcome =
+  | 'call'
+  | 'scheduledCall'
+  | 'room'
+  | 'pending'
+  | 'unknown';
 
 export const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
 export const PENDING_NOTIFICATION_TTL_MS = 5 * 60 * 1000;
@@ -54,6 +60,8 @@ export const handlePushPayload = (
 ): PushPayloadOutcome => {
   if (!data) {return 'unknown';}
   if (handleCallPush(data as Record<string, any>)) {return 'call';}
+  // The reminder before a scheduled call opens the same flow as its link.
+  if (handleScheduledCallPush(data)) {return 'scheduledCall';}
   const jid = data.jid ?? data.chatJid ?? data.roomJid ?? data.roomJID;
   if (typeof jid === 'string' && jid) {
     return openRoomFromPush(jid);