@ethora/chat-component-rn 26.10.9 → 26.10.11

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/components/styled/MessageImage.tsx

@@ -11,6 +11,7 @@ import {
   setActiveModal,
 } from '../../roomStore/chatSettingsSlice';
 import { MODAL_TYPES } from '../../helpers/constants/MODAL_TYPES';
+import { useMediaSource } from '../../context/MediaSourceContext';
 import { ActivityIndicator, Image, TouchableOpacity, View } from 'react-native';
 import {
   defaultMediaDims,
@@ -72,6 +73,7 @@ const CustomMessageImage: React.FC<CustomMessageImageProps> = ({
   const dims: MediaDims = tile ?? measured;
 
   const dispatch = useDispatch();
+  const source = useMediaSource();
 
   useEffect(() => {
     if (!displayURL || tile) {
@@ -105,7 +107,7 @@ const CustomMessageImage: React.FC<CustomMessageImageProps> = ({
       onOpen();
       return;
     }
-    dispatch(setActiveFile({ fileName, fileURL, mimetype, originalName }));
+    dispatch(setActiveFile({ fileName, fileURL, mimetype, originalName, source }));
     dispatch(setActiveModal(MODAL_TYPES.FILE_PREVIEW));
   };
 

package/src/components/styled/VideoMessage.tsx

@@ -10,6 +10,7 @@ import {
   setActiveModal,
 } from '../../roomStore/chatSettingsSlice';
 import { MODAL_TYPES } from '../../helpers/constants/MODAL_TYPES';
+import { useMediaSource } from '../../context/MediaSourceContext';
 import { PlayIcon } from '../../assets/icons';
 import {
   defaultMediaDims,
@@ -155,6 +156,7 @@ const CustomMessageVideo: React.FC<CustomMessageVideoProps> = ({
   onOpen,
 }) => {
   const dispatch = useDispatch();
+  const source = useMediaSource();
   const [posterFailed, setPosterFailed] = useState(false);
 
   const handleOpen = () => {
@@ -162,7 +164,9 @@ const CustomMessageVideo: React.FC<CustomMessageVideoProps> = ({
       onOpen();
       return;
     }
-    dispatch(setActiveFile({ fileName, fileURL, mimetype, originalName }));
+    dispatch(
+      setActiveFile({ fileName, fileURL, mimetype, originalName, previewURL, source })
+    );
     dispatch(setActiveModal(MODAL_TYPES.FILE_PREVIEW));
   };
 

package/src/context/MediaSourceContext.tsx

@@ -0,0 +1,14 @@
+import { createContext, useContext } from 'react';
+import type { ModalFileSource } from '../types/types';
+
+/**
+ * The message a bubble's pictures and videos belong to. MediaMessage provides
+ * it, and the image / video / album components that open the viewer read it,
+ * so the viewer knows what its Reply and Delete act on without every card in
+ * between passing the message along.
+ */
+const MediaSourceContext = createContext<ModalFileSource | undefined>(undefined);
+
+export const MediaSourceProvider = MediaSourceContext.Provider;
+
+export const useMediaSource = () => useContext(MediaSourceContext);

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/constants/MODAL_COMPONENTS.tsx

@@ -7,7 +7,9 @@ import React from 'react';
 import { MODAL_TYPES } from './MODAL_TYPES';
 import ChatProfileModal from '../../components/Modals/ChatProfileModal/ChatProfileModal';
 import FilePreviewModal from '../../components/Modals/FilePreviewModal/FilePreviewModal';
-import MessageSearchModal from '../../components/Modals/MessageSearchModal/MessageSearchModal';
+import MessageSearchModal, {
+  ChatMessageSearchModal,
+} from '../../components/Modals/MessageSearchModal/MessageSearchModal';
 import PublicChatsModal from '../../components/Modals/PublicChatsModal/PublicChatsModal';
 import NewChatModal from '../../components/Modals/NewChatModal/NewChatModal';
 import BlockedUsersModal from '../../components/Modals/SettingsModals/BlockedUsers/BlockedUsersModal';
@@ -37,5 +39,6 @@ export const MODAL_COMPONENTS: Record<
   [MODAL_TYPES.BLOCKED_USERS]: BlockedUsersModal,
   [MODAL_TYPES.FILE_PREVIEW]: FilePreviewModal,
   [MODAL_TYPES.MESSAGE_SEARCH]: MessageSearchModal,
+  [MODAL_TYPES.CHAT_MESSAGE_SEARCH]: ChatMessageSearchModal,
   [MODAL_TYPES.PUBLIC_CHATS]: PublicChatsModal,
 };

package/src/helpers/constants/MODAL_TYPES.ts

@@ -28,5 +28,7 @@ export const MODAL_TYPES = {
   NEW_CHAT: 'new_chat',
 
   MESSAGE_SEARCH: 'message_search',
+  /** Message search locked to the open chat, reached from its profile. */
+  CHAT_MESSAGE_SEARCH: 'chat_message_search',
   PUBLIC_CHATS: 'public_chats',
 };

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/publicChatsEntry.ts

@@ -2,14 +2,15 @@ import type { IConfig } from '../types/types';
 
 /**
  * "Discover chats" lives in the room list menu sheet. A host that takes the
- * burger over (`headerMenu` as a function) or hides the menu
- * (`chatHeaderSettings.disableMenu`) would otherwise have no obvious way to
- * reach the directory, so it also gets a button of its own in the room list
- * header. `disableRoomMenu` removes the menu entry point, and with it the
- * button; `disablePublicChatsDirectory` removes the feature altogether.
+ * burger over (`headerMenu` as a function) would otherwise have no obvious
+ * way to reach the directory, so it also gets a button of its own in the
+ * room list header. `chatHeaderSettings.disableMenu` does not count: the
+ * header avatar still opens the sheet, Discover included, and a second
+ * compass next to it was a duplicate. `disableRoomMenu` removes the menu
+ * entry point, and with it the button; `disablePublicChatsDirectory`
+ * removes the feature altogether.
  */
 export const showsStandaloneDiscoverButton = (config?: IConfig): boolean =>
   !config?.disablePublicChatsDirectory &&
   !config?.disableRoomMenu &&
-  (Boolean(config?.chatHeaderSettings?.disableMenu) ||
-    typeof config?.headerMenu === 'function');
+  typeof config?.headerMenu === 'function';

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);