@ethora/chat-component-rn 26.10.3 → 26.10.5

package/src/components/VideoCalls/callSessionController.ts

@@ -31,6 +31,13 @@ export interface CallSessionSnapshot {
   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;
   /** `{ participant, publication, source }` for `<VideoTrack />`, live and unmuted only. */
   remoteVideo: any;
   localVideo: any;
@@ -53,6 +60,8 @@ const IDLE: CallSessionSnapshot = {
   micOn: true,
   cameraOn: false,
   speakerOn: false,
+  facingMode: 'user',
+  localVideoEpoch: 0,
   remoteVideo: null,
   localVideo: null,
   remoteName: null,
@@ -224,12 +233,24 @@ export const startCallSession = ({
   }
 
   ensureLiveKitGlobals(runtime);
-  const { Room, RoomEvent, AudioSession } = runtime;
-
-  // adaptiveStream + dynacast keep mobile data and battery sane: the SDK
-  // drops resolution for a small tile and stops publishing layers nobody
-  // subscribes to. Both are safe defaults for 1:1.
-  const room = new Room({ adaptiveStream: true, dynacast: true });
+  const { Room, RoomEvent, AudioSession, VideoPresets } = runtime;
+
+  // The web session's options, verbatim. `pixelDensity: 'screen'` matters:
+  // with a plain `adaptiveStream: true` the subscriber asks for a layer
+  // sized to the view in POINTS, i.e. 2-3x below the phone's real pixels,
+  // and the peer's video arrived visibly blurry next to web.
+  const room = new Room({
+    adaptiveStream: { pixelDensity: 'screen' },
+    dynacast: true,
+    ...(VideoPresets
+      ? {
+          publishDefaults: {
+            videoSimulcastLayers: [VideoPresets.h540, VideoPresets.h216],
+          },
+          videoCaptureDefaults: { resolution: VideoPresets.h720.resolution },
+        }
+      : {}),
+  });
   const current: Session = { key, room, kind, disposed: false, everJoined: false };
   session = current;
   snapshot = {
@@ -284,7 +305,14 @@ export const startCallSession = ({
       // Claims audio focus and sets the right native audio mode. Must
       // start BEFORE connecting or the first seconds route to the earpiece
       // on Android even for a video call.
-      await AudioSession.startAudioSession();
+      try {
+        await AudioSession.startAudioSession();
+      } catch {
+        // A call answered from the CallKit banner: CallKit owns the iOS
+        // audio session and activates it itself (useCallKeep forwards that
+        // to WebRTC), so our own activation is refused. Not a reason to
+        // fail the call.
+      }
       await room.connect(livekitUrl, token);
     } catch (error: any) {
       if (current.disposed) {return;}
@@ -335,10 +363,12 @@ export const startCallSession = ({
 
 // ---- controls -----------------------------------------------------------
 
-export const toggleCallMic = async (): Promise<void> => {
+export const toggleCallMic = (): Promise<void> => setCallMicEnabled(!snapshot.micOn);
+
+/** Set the mic to a given state (system call UI reports absolute values). */
+export const setCallMicEnabled = async (next: boolean): Promise<void> => {
   const current = session;
-  if (!current) {return;}
-  const next = !snapshot.micOn;
+  if (!current || snapshot.micOn === next) {return;}
   emit({ micOn: next });
   try {
     await current.room.localParticipant.setMicrophoneEnabled(next);
@@ -364,26 +394,45 @@ export const toggleCallCamera = async (): Promise<void> => {
   }
 };
 
+let switchingCamera = false;
+
 export const switchCallCamera = async (): Promise<void> => {
   const current = session;
   const runtime = loadLiveKit();
-  if (!current || !runtime) {return;}
+  if (!current || !runtime || switchingCamera) {return;}
+  const track = current.room.localParticipant.getTrackPublication?.(
+    runtime.Track.Source.Camera
+  )?.track;
+  if (!track?.restartTrack) {return;}
+  const next = snapshot.facingMode === 'user' ? 'environment' : 'user';
+  switchingCamera = true;
   try {
-    const publication = current.room.localParticipant.getTrackPublication?.(
-      runtime.Track.Source.Camera
-    );
-    const track = publication?.track;
-    // `restartTrack` with the flipped facingMode is the portable way to
-    // switch cameras; the RN SDK's `_switchCamera` helper is internal.
-    await track?.restartTrack?.({
-      facingMode:
-        track?.mediaStreamTrack?.getSettings?.().facingMode === 'environment'
-          ? 'user'
-          : 'environment',
+    // A real device change needs a new capture: react-native-webrtc's
+    // native applyConstraints only applies width/height/frameRate and
+    // ignores facingMode on both platforms, so the old approach kept the
+    // front camera and merely flipped our mirror flag (the picture looked
+    // swapped left to right). restartTrack re-acquires the camera with
+    // the new facing mode and swaps it into the published sender; the
+    // <VideoTrack /> view follows it through TrackEvent.Restarted.
+    await track.restartTrack({
+      facingMode: next,
+      ...(runtime.VideoPresets
+        ? { resolution: runtime.VideoPresets.h720.resolution }
+        : {}),
+    });
+    if (current.disposed) {return;}
+    // Trust what the camera reports: a device with a single camera stays
+    // on it, and the mirror must follow the real camera, not the request.
+    const actual = track.mediaStreamTrack?.getSettings?.()?.facingMode;
+    emit({
+      facingMode: actual === 'user' || actual === 'environment' ? actual : next,
+      localVideoEpoch: snapshot.localVideoEpoch + 1,
     });
     resync();
-  } catch {
-    // Single camera, or the track is mid-restart.
+  } catch (error) {
+    if (!current.disposed) {emit({ deviceError: humanizeDeviceError(error) });}
+  } finally {
+    switchingCamera = false;
   }
 };
 

package/src/components/VideoCalls/callUiStore.ts

@@ -0,0 +1,106 @@
+import { useSyncExternalStore } from 'react';
+import { store } from '../../roomStore';
+
+/**
+ * UI state of the call shared between the overlay and the header bar:
+ * whether the call is minimized, and which header (if any) currently hosts
+ * the minimized bar.
+ *
+ * Minimized, the call is a strip under the visible header (ChatHeader or
+ * HeaderRoomList), Telegram-style, instead of a floating panel. Each header
+ * registers itself while mounted; the most recently mounted one shows the
+ * strip (on an iPad split view both are mounted, and only one strip should
+ * appear). With no header mounted (the user is on a host-app screen) the
+ * overlay docks the same strip to the top of the screen.
+ */
+
+interface CallUiState {
+  minimized: boolean;
+  /**
+   * iOS shows this incoming call in its own CallKit UI (banner / full
+   * screen), so the in-app ring card stays hidden instead of doubling it.
+   */
+  systemRinging: boolean;
+  /** Id of the header that shows the strip, or null when none is mounted. */
+  barHost: number | null;
+  /**
+   * Window y of the top of the strip slot under the hosting header, so the
+   * collapse animation can land exactly on the strip. Null: no header.
+   */
+  barAnchorY: number | null;
+}
+
+let state: CallUiState = {
+  minimized: false,
+  systemRinging: false,
+  barHost: null,
+  barAnchorY: null,
+};
+const hosts: number[] = [];
+let nextHostId = 1;
+const listeners = new Set<() => void>();
+let storeUnsubscribe: (() => void) | null = null;
+
+const emit = (patch: Partial<CallUiState>) => {
+  state = { ...state, ...patch };
+  listeners.forEach((listener) => listener());
+};
+
+// The next call always opens full-screen.
+const ensureStoreWatcher = () => {
+  if (storeUnsubscribe) {return;}
+  storeUnsubscribe = store.subscribe(() => {
+    const phase = store.getState().call.phase;
+    if (state.minimized && phase === 'idle') {
+      emit({ minimized: false });
+    }
+    if (state.systemRinging && phase !== 'ringing-incoming') {
+      emit({ systemRinging: false });
+    }
+  });
+};
+
+const subscribe = (listener: () => void) => {
+  ensureStoreWatcher();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+const getSnapshot = () => state;
+
+/** Current state, for non-React code and tests. */
+export const getCallUiState = (): CallUiState => state;
+
+export const useCallUi = (): CallUiState =>
+  useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+export const setCallMinimized = (minimized: boolean): void => {
+  if (state.minimized !== minimized) {emit({ minimized });}
+};
+
+export const setCallSystemRinging = (systemRinging: boolean): void => {
+  if (state.systemRinging !== systemRinging) {emit({ systemRinging });}
+};
+
+export const registerCallBarHost = (
+  onId?: (id: number) => void
+): (() => void) => {
+  const id = nextHostId++;
+  hosts.push(id);
+  onId?.(id);
+  emit({ barHost: id });
+  return () => {
+    const index = hosts.indexOf(id);
+    if (index >= 0) {hosts.splice(index, 1);}
+    const next = hosts.length ? hosts[hosts.length - 1] : null;
+    emit({ barHost: next, barAnchorY: next === null ? null : state.barAnchorY });
+  };
+};
+
+/** The hosting header reports where its strip slot is on screen. */
+export const setCallBarAnchor = (hostId: number, y: number): void => {
+  if (state.barHost !== hostId || state.barAnchorY === y) {return;}
+  emit({ barAnchorY: y });
+};

package/src/components/VideoCalls/livekitRuntime.ts

@@ -26,12 +26,19 @@ export interface LiveKitRuntime {
   Track: any;
   /** livekit-client `ConnectionState` enum. */
   ConnectionState: any;
+  /** livekit-client `VideoPresets` (h540, h216...). */
+  VideoPresets: any;
   /** RN `<VideoTrack trackRef={...} />` renderer. */
   VideoTrack: any;
   /** Native audio session control (routing, speaker, focus). */
   AudioSession: any;
   /** Installs the WebRTC globals livekit-client expects. */
   registerGlobals: () => void;
+  /**
+   * `@livekit/react-native-webrtc` RTCAudioSession: tells WebRTC when
+   * CallKit activates/deactivates the iOS audio session.
+   */
+  RTCAudioSession: any;
 }
 
 let cached: LiveKitRuntime | null | undefined;
@@ -57,15 +64,24 @@ export const loadLiveKit = (): LiveKitRuntime | null => {
     // moving subset across versions, the core package does not.
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const core = require('livekit-client');
+    let webrtc: any = null;
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      webrtc = require('@livekit/react-native-webrtc');
+    } catch {
+      // Only needed for CallKit; calls work without it.
+    }
 
     cached = {
       Room: core.Room,
       RoomEvent: core.RoomEvent,
       Track: core.Track,
       ConnectionState: core.ConnectionState,
+      VideoPresets: core.VideoPresets,
       VideoTrack: rn.VideoTrack,
       AudioSession: rn.AudioSession,
       registerGlobals: rn.registerGlobals,
+      RTCAudioSession: webrtc?.RTCAudioSession ?? null,
     };
   } catch {
     cached = null;

package/src/components/VideoCalls/useCallKeep.ts

@@ -1,9 +1,13 @@
-import { useEffect, useMemo, useRef } from 'react';
+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 { setCallMicEnabled, useCallSession } from './callSessionController';
+import { loadLiveKit } from './livekitRuntime';
+import { setCallSystemRinging } from './callUiStore';
 
 /**
  * Native incoming-call UI (Android ConnectionService / iOS CallKit) via
@@ -14,6 +18,12 @@ import { sendCallStateSignal } from '../../networking/callTokenStanza';
  * loaded lazily exactly like the LiveKit packages, so hosts that don't
  * install it get the plain in-app ring screen and nothing breaks.
  *
+ * On iOS every call, incoming or outgoing, is also reported to CallKit for
+ * as long as it lasts. That is what puts it in the Dynamic Island / the
+ * green status-bar pill when the app is in the background, with the
+ * system's own mute and end buttons, and what keeps the call's audio
+ * running in the background.
+ *
  * Platform reality, stated plainly:
  *  - Android: full value. A ConnectionService call shows the system
  *    incoming-call screen over the lock screen.
@@ -35,6 +45,18 @@ interface CallKeepModule {
   ) => 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;
@@ -95,16 +117,32 @@ const toUuid = (seed: string): string => {
   ].join('-');
 };
 
+const trace = (...args: unknown[]) => {
+  if (__DEV__) {console.log('[calls] CallKit:', ...args);}
+};
+
 export const useCallKeep = (): void => {
   const dispatch = useDispatch();
   const call = useSelector((state: RootState) => state.call);
+  const session = useCallSession();
   const callKeep = useMemo(() => loadCallKeep(), []);
+  const [ready, setReady] = useState(false);
   const activeUuidRef = useRef<string | null>(null);
-  const readyRef = useRef(false);
+  // The CallKit call has been answered (from the system screen or in-app).
+  const answeredRef = useRef(false);
+  const outgoingReportedRef = useRef<'none' | 'connecting' | 'connected'>('none');
+  const isIOS = Platform.OS === 'ios';
 
   // One-time native setup.
   useEffect(() => {
-    if (!callKeep) {return;}
+    if (!callKeep) {
+      if (isIOS) {
+        // The usual reason for "no Dynamic Island": the JS package is there
+        // but the binary was built without the RNCallKeep pod.
+        trace('unavailable (react-native-callkeep is not linked in this build)');
+      }
+      return;
+    }
     let cancelled = false;
 
     (async () => {
@@ -113,6 +151,11 @@ export const useCallKeep = (): void => {
           ios: {
             appName: 'Ethora',
             supportsVideo: true,
+            maximumCallGroups: '1',
+            maximumCallsPerCallGroup: '1',
+            // Our calls are not phone calls: keep them out of the Phone
+            // app's Recents, whose entries would dial back into nowhere.
+            includesCallsInRecents: false,
           },
           android: {
             alertTitle: 'Permissions required',
@@ -130,28 +173,35 @@ export const useCallKeep = (): void => {
         });
         if (cancelled) {return;}
         callKeep.setAvailable?.(true);
-        readyRef.current = true;
-      } catch {
+        trace('ready');
+        setReady(true);
+      } catch (error) {
+        trace('setup failed', error);
         // Host didn't grant phone-account permission, or the module isn't
         // linked. The in-app ring screen still works, so stay quiet.
-        readyRef.current = false;
+        setReady(false);
       }
     })();
 
     return () => {
       cancelled = true;
     };
-  }, [callKeep]);
+  }, [callKeep, isIOS]);
 
-  // Bridge native answer/end actions back into Redux.
+  // Bridge native actions back into the call.
   useEffect(() => {
     if (!callKeep) {return;}
 
     const onAnswer = () => {
+      answeredRef.current = true;
       // The user answered from the system screen, which on Android may
       // mean the app was not even in the foreground.
       callKeep.backToForeground?.();
-      if (store.getState().call.direction === 'incoming') {
+      // Only from the ring: CallKit also reports the answer we make on its
+      // behalf after an in-app accept, and re-accepting then would drop an
+      // in-progress call back to 'connecting'.
+      const current = store.getState().call;
+      if (current.direction === 'incoming' && current.phase === 'ringing-incoming') {
         dispatch(acceptIncomingCall());
       }
     };
@@ -165,73 +215,198 @@ export const useCallKeep = (): void => {
       ) {
         sendCallStateSignal('declined');
         dispatch(declineIncomingCall());
+        return;
+      }
+      // Ended from the Dynamic Island, the lock screen or a headset.
+      if (snapshot.phase === 'error') {return;}
+      terminateActiveCall(snapshot.phase === 'requesting' ? 'cancelled' : 'ended');
+    };
+
+    // The system mute button (Dynamic Island, lock screen, CarPlay).
+    const onMuted = ({ muted }: { muted: boolean }) => {
+      void setCallMicEnabled(!muted);
+    };
+
+    // Another call (e.g. a phone call) put ours on hold: stop sending audio.
+    const onHold = ({ hold }: { hold: boolean }) => {
+      if (hold) {void setCallMicEnabled(false);}
+    };
+
+    // CallKit owns the iOS audio session: WebRTC may only start its audio
+    // unit once CallKit has activated the session.
+    const onAudioActivated = () => {
+      try {
+        loadLiveKit()?.RTCAudioSession?.audioSessionDidActivate?.();
+      } catch {
+        // Older webrtc builds manage the session on their own.
+      }
+    };
+    const onAudioDeactivated = () => {
+      try {
+        loadLiveKit()?.RTCAudioSession?.audioSessionDidDeactivate?.();
+      } catch {
+        // noop
       }
     };
 
     callKeep.addEventListener('answerCall', onAnswer);
     callKeep.addEventListener('endCall', onEnd);
+    callKeep.addEventListener('didPerformSetMutedCallAction', onMuted);
+    callKeep.addEventListener('didToggleHoldCallAction', onHold);
+    callKeep.addEventListener('didActivateAudioSession', onAudioActivated);
+    // CallKit rejected or dropped our calls (e.g. a build without the voip
+    // background mode): there is nothing to end any more.
+    const onReset = () => {
+      trace('provider reset');
+    };
+    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');
+      // 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);}
+    };
+    callKeep.addEventListener('didDisplayIncomingCall', onDisplayed);
+    callKeep.addEventListener('didDeactivateAudioSession', onAudioDeactivated);
 
     return () => {
       callKeep.removeEventListener('answerCall');
       callKeep.removeEventListener('endCall');
+      callKeep.removeEventListener('didPerformSetMutedCallAction');
+      callKeep.removeEventListener('didToggleHoldCallAction');
+      callKeep.removeEventListener('didActivateAudioSession');
+      callKeep.removeEventListener('didDeactivateAudioSession');
+      callKeep.removeEventListener('didResetProvider');
+      callKeep.removeEventListener('didDisplayIncomingCall');
     };
   }, [callKeep, dispatch]);
 
-  // Show / dismiss the native screen as the call state changes.
+  const displayName = call.roomName || 'Ethora';
+  const isRinging =
+    call.direction === 'incoming' && call.phase === 'ringing-incoming';
+  const isLive = call.phase === 'connecting' || call.phase === 'in-call';
+  const isOutgoing = call.direction === 'outgoing';
+  const peerConnected = session.anchorAt !== null;
+
+  // Report the call to the system as its state changes.
   useEffect(() => {
-    if (!callKeep || !readyRef.current) {return;}
+    if (!callKeep || !ready) {return;}
 
-    const isRinging =
-      call.direction === 'incoming' && call.phase === 'ringing-incoming';
+    const release = () => {
+      if (!activeUuidRef.current) {return;}
+      try {
+        callKeep.endCall(activeUuidRef.current);
+      } catch {
+        // Screen already gone.
+      }
+      activeUuidRef.current = null;
+      answeredRef.current = false;
+      outgoingReportedRef.current = 'none';
+    };
 
-    if (isRinging && !activeUuidRef.current) {
+    if (call.phase === 'idle' || call.phase === 'error') {
+      release();
+      return;
+    }
+
+    if (isRinging) {
+      if (activeUuidRef.current) {return;}
       const uuid = toUuid(call.callId || call.roomJid || String(Date.now()));
       activeUuidRef.current = uuid;
+      answeredRef.current = false;
+      // 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(
           uuid,
-          call.peerXmppUsername || call.roomName || 'Ethora',
-          call.roomName || undefined,
+          displayName,
+          displayName,
           'generic',
           call.kind === 'video'
         );
       } catch {
         activeUuidRef.current = null;
+        setCallSystemRinging(false);
       }
       return;
     }
 
-    // Any exit from ringing (answered in-app, declined, peer cancelled)
-    // must tear the system screen down or it hangs around ringing.
-    if (!isRinging && activeUuidRef.current && call.phase !== 'connecting' && call.phase !== 'in-call') {
+    // iOS: an outgoing call is a CallKit call from the first ring, so it
+    // shows in the Dynamic Island even before the peer answers.
+    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()}`);
+      activeUuidRef.current = uuid;
+      outgoingReportedRef.current = 'none';
+      trace('startCall', uuid);
       try {
-        callKeep.endCall(activeUuidRef.current);
+        callKeep.startCall(uuid, displayName, displayName, 'generic', call.kind === 'video');
       } catch {
-        // Screen already gone.
+        activeUuidRef.current = null;
       }
-      activeUuidRef.current = null;
+      return;
+    }
+
+    const uuid = activeUuidRef.current;
+    if (!uuid) {return;}
+
+    if (isIOS && isOutgoing) {
+      if (peerConnected && outgoingReportedRef.current !== 'connected') {
+        outgoingReportedRef.current = 'connected';
+        callKeep.reportConnectedOutgoingCallWithUUID?.(uuid);
+      } else if (
+        isLive &&
+        !peerConnected &&
+        outgoingReportedRef.current === 'none'
+      ) {
+        outgoingReportedRef.current = 'connecting';
+        callKeep.reportConnectingOutgoingCallWithUUID?.(uuid);
+      }
+      return;
     }
 
-    if (call.phase === 'idle' && activeUuidRef.current) {
+    // Incoming, accepted with the in-app button: tell CallKit, or its
+    // screen keeps ringing on top of the call.
+    if (isIOS && isLive && !answeredRef.current) {
+      answeredRef.current = true;
       try {
-        callKeep.endCall(activeUuidRef.current);
+        callKeep.answerIncomingCall?.(uuid);
       } catch {
         // noop
       }
-      activeUuidRef.current = null;
     }
   }, [
     callKeep,
-    call.direction,
+    ready,
+    isIOS,
+    isRinging,
+    isLive,
+    isOutgoing,
+    peerConnected,
+    displayName,
     call.phase,
     call.callId,
     call.roomJid,
-    call.roomName,
-    call.peerXmppUsername,
+    call.startedAt,
     call.kind,
   ]);
 
-  // Nothing to clean up on unmount beyond the active screen: this hook
+  // Keep the system mute button in step with ours.
+  useEffect(() => {
+    const uuid = activeUuidRef.current;
+    if (!callKeep || !ready || !isIOS || !uuid || !isLive) {return;}
+    try {
+      callKeep.setMutedCall?.(uuid, !session.micOn);
+    } catch {
+      // noop
+    }
+  }, [callKeep, ready, isIOS, isLive, session.micOn]);
+
+  // Nothing to clean up on unmount beyond the active call: this hook
   // lives for the lifetime of the provider.
   useEffect(
     () => () => {
@@ -245,8 +420,4 @@ export const useCallKeep = (): void => {
     },
     [callKeep]
   );
-
-  // iOS-only note kept as a runtime no-op so the import isn't unused when
-  // the platform check is tree-shaken in release builds.
-  void Platform.OS;
 };