@stream-io/video-react-native-sdk 1.30.5 → 1.31.1-beta.0

package/src/utils/StreamVideoRN/types.ts

@@ -5,6 +5,18 @@ import {
 } from '@stream-io/video-client';
 import type { AndroidChannel } from '@notifee/react-native';
 
+export type AndroidChannelConfig = {
+  id: string;
+  name: string;
+  sound?: string;
+  vibration?: boolean;
+};
+
+export type KeepAliveAndroidNotificationTexts = {
+  title: string;
+  body: string;
+};
+
 export type NonRingingPushEvent =
   | 'call.live_started'
   | 'call.notification'
@@ -32,6 +44,27 @@ export type StreamVideoConfig = {
        * @example "production-apn-video" or "staging-apn-video" based on the environment
        */
       pushProviderName?: string;
+      supportsVideo?: boolean;
+      /**
+       * Sound to play when an incoming call is received. Must be a valid sound resource name in the project.
+       * @default '' (no sound)
+       */
+      sound?: string;
+      /**
+       * Image to display when an incoming call is received. Must be a valid image resource name in the project.
+       * @default '' (no image)
+       */
+      imageName?: string;
+      /**
+       * Enable calls history. When enabled, the call will be added to the calls history.
+       * @default false
+       */
+      callsHistory?: boolean;
+      /**
+       * Timeout to display an incoming call. When the call is displayed for more than the timeout, the call will be rejected.
+       * @default 60000 (1 minute)
+       */
+      displayCallTimeout?: number;
     };
     android: {
       /**
@@ -61,28 +94,30 @@ export type StreamVideoConfig = {
        * The notification channel to be used for incoming calls for Android.
        * @example
        * {
-       *  id: 'stream_incoming_call',
-       *  name: 'Incoming call notifications',
-       *  importance: AndroidImportance.HIGH,
+       *  id: 'incoming_calls_channel',
+       *  name: 'Incoming calls',
+       *  sound?: string;
+       *  vibration?: boolean;
        * }
        */
-      incomingCallChannel?: AndroidChannel;
+      incomingChannel?: AndroidChannelConfig;
       /**
-       * Functions to create the texts shown in the notification for incoming calls in Android.
+       * Texts used for call state notifications while the system is connecting or declining the call.
+       * If not provided, platform defaults will be used.
        * @example
        * {
-       *  getTitle: (createdUserName: string) => `Incoming call from ${createdUserName}`,
-       *  getBody: (createdUserName: string) => `Tap to answer the call`
-       *  getAcceptButtonTitle?: () => `Accept`,
-       *  getDeclineButtonTitle?: () => `Decline`,
+       *  accepting: 'Connecting...',
+       *  rejecting: 'Declining...',
        * }
        */
-      incomingCallNotificationTextGetters?: {
-        getTitle: (createdUserName: string) => string;
-        getBody: (createdUserName: string) => string;
-        getAcceptButtonTitle?: () => string;
-        getDeclineButtonTitle?: () => string;
+      notificationTexts?: {
+        accepting?: string;
+        rejecting?: string;
       };
+      /**
+       * The transformer to be used to transform the call title in the notification for ringing and ongoing calls for Android.
+       */
+      titleTransformer?: (memberName: string, incoming: boolean) => string;
       /**
        * Functions to create the texts shown in the notification for non ringing calls in Android.
        * @example
@@ -111,6 +146,16 @@ export type StreamVideoConfig = {
         getBody: (type: NonRingingPushEvent, createdUserName: string) => string;
       };
     };
+    /**
+     * Whether to enable ongoing calls.
+     * @default false
+     */
+    enableOngoingCalls?: boolean;
+    /**
+     * Whether to reject calls when the user is busy.
+     * @default false
+     */
+    shouldRejectCallWhenBusy?: boolean;
     /**
      * This function is used to create a custom video client.
      * This is used create a video client for incoming calls in the background and inform call events to the server.
@@ -130,12 +175,6 @@ export type StreamVideoConfig = {
      * }
      */
     createStreamVideoClient: () => Promise<StreamVideoClient | undefined>;
-    /** @deprecated This method will be removed in the future. Please watch for incoming and outgoing calls in the root component of your app.
-        Please see https://getstream.io/video/docs/react-native/advanced/ringing-calls/#watch-for-incoming-and-outgoing-calls for more information */
-    navigateAcceptCall?: () => void;
-    /** @deprecated This method will be removed in the future. Please watch for incoming and outgoing calls in the root component of your app.
-        Please see https://getstream.io/video/docs/react-native/advanced/ringing-calls/#watch-for-incoming-and-outgoing-calls for more information */
-    navigateToIncomingCall?: () => void;
     /** Callback that is called when a non ringing push notification was tapped */
     onTapNonRingingCallNotification?: (
       call_cid: string,
@@ -147,14 +186,11 @@ export type StreamVideoConfig = {
       /**
        * The notification channel to keep call alive in the background for Android using a foreground service.
        */
-      channel: AndroidChannel;
+      channel: Omit<AndroidChannelConfig, 'sound' | 'vibration'>;
       /**
        * The texts shown in the notification to keep call alive in the background
        */
-      notificationTexts: {
-        title: string;
-        body: string;
-      };
+      notificationTexts: KeepAliveAndroidNotificationTexts;
       /**
        * The task to run in the foreground service
        * The task must resolve a promise once complete

package/src/utils/internal/callingx/audioSessionPromise.ts

@@ -0,0 +1,65 @@
+/**
+ * Module to manage pending promise for audio session activation.
+ * Used to wait for iOS CallKit's didActivateAudioSession event after starting a call.
+ */
+
+import { videoLoggerSystem } from '@stream-io/video-client';
+
+const logger = videoLoggerSystem.getLogger('callingx');
+
+let pendingResolve: (() => void) | null = null;
+let pendingTimeout: ReturnType<typeof setTimeout> | null = null;
+let resolveSetTime: number | null = null;
+/**
+ * Flag to check if the audio session is already activated.
+ * This solves race condition for a cold start case, when the audio session is activated before the promise is created.
+ */
+let isAudioSessionAlreadyActivated = false;
+
+const AUDIO_SESSION_TIMEOUT_MS = 5000;
+
+/**
+ * Creates a promise that resolves when the audio session is activated,
+ * or after a timeout to prevent hanging indefinitely.
+ * @returns Promise that resolves when audio session is activated or timeout occurs
+ */
+export function waitForAudioSessionActivation(): Promise<void> {
+  if (isAudioSessionAlreadyActivated) {
+    isAudioSessionAlreadyActivated = false;
+    return Promise.resolve();
+  }
+
+  resolveSetTime = Date.now();
+  return new Promise((resolve) => {
+    pendingResolve = resolve;
+    pendingTimeout = setTimeout(() => {
+      // Resolve on timeout to prevent hanging
+      logger.debug('audioSessionPromise timed out');
+      resolvePendingAudioSession();
+    }, AUDIO_SESSION_TIMEOUT_MS);
+  });
+}
+
+/**
+ * Resolves the pending audio session activation promise.
+ * Called when the didActivateAudioSession event fires or on timeout.
+ */
+export function resolvePendingAudioSession(): void {
+  if (pendingTimeout) {
+    clearTimeout(pendingTimeout);
+    pendingTimeout = null;
+  }
+
+  if (pendingResolve) {
+    pendingResolve();
+    if (resolveSetTime) {
+      const elapsedTime = Date.now() - resolveSetTime;
+      resolveSetTime = null;
+      logger.debug(`audioSessionPromise resolved in ${elapsedTime}ms`);
+    }
+    pendingResolve = null;
+    isAudioSessionAlreadyActivated = false;
+  } else {
+    isAudioSessionAlreadyActivated = true;
+  }
+}

package/src/utils/internal/callingx/callingx.ts

@@ -0,0 +1,194 @@
+/***
+ * Internal utils for callingx library usage from video-client.
+ * See @./registerSDKGlobals.ts for more usage details.
+ */
+import { Platform } from 'react-native';
+import type { EndCallReason } from '@stream-io/react-native-callingx';
+import { getCallingxLibIfAvailable } from '../../push/libs/callingx';
+import { waitForAudioSessionActivation } from './audioSessionPromise';
+import type {
+  Call,
+  MemberResponse,
+  StreamVideoParticipant,
+} from '@stream-io/video-client';
+import { CallingState, videoLoggerSystem } from '@stream-io/video-client';
+const CallingxModule = getCallingxLibIfAvailable();
+
+/**
+ * Gets the call display name. To be used for display in native call screen.
+ */
+export function getCallDisplayName(
+  callMembers: MemberResponse[] | undefined,
+  participants: StreamVideoParticipant[] | undefined,
+  currentUserId: string | undefined,
+): string {
+  if (!callMembers || !participants || !currentUserId) {
+    return 'Call';
+  }
+
+  let names: string[] = [];
+
+  if (callMembers.length > 0) {
+    // for ringing calls, members array contains all call members from the very early state and participants array is empty in the beginning
+    names = callMembers
+      .filter((member) => member.user.id !== currentUserId)
+      .map((member) => member.user.name)
+      .filter((name): name is string => name !== undefined);
+  } else if (participants.length > 0) {
+    // for non-ringing calls, members array is empty and we rely on participants array there
+    names = participants
+      .filter((participant) => participant.userId !== currentUserId)
+      .map((participant) => participant.name)
+      .filter(Boolean);
+  }
+
+  // if no names are found, we use the name of the current user
+  if (names.length === 0) {
+    names = [
+      participants.find((participant) => participant.userId === currentUserId)
+        ?.name ?? 'Call',
+    ];
+  }
+
+  return names.sort().join(', ');
+}
+
+function getCallDisplayNameFromCall(call: Call): string {
+  return getCallDisplayName(
+    call.state.members,
+    call.state.participants,
+    call.currentUserId,
+  );
+}
+
+export async function registerOutgoingCall(call: Call) {
+  if (!CallingxModule || !CallingxModule.isSetup) {
+    return;
+  }
+
+  const isOutcomingCall = call.ringing && call.isCreatedByMe;
+  if (!isOutcomingCall) {
+    return;
+  }
+
+  const logger = videoLoggerSystem.getLogger('callingx');
+
+  try {
+    logger.debug(`registerOutgoingCall: Registering outgoing call ${call.cid}`);
+    await CallingxModule.startCall(
+      call.cid, // unique id for call
+      call.id, // phone number for display in dialer (we use call id as phone number)
+      getCallDisplayNameFromCall(call), // display name for display in call screen
+      call.state.settings?.video?.enabled ?? false, // is video call?
+    );
+  } catch (error) {
+    logger.error(
+      `registerOutgoingCall: Error registering outgoing call in callingx: ${call.cid}`,
+      error,
+    );
+  }
+}
+
+/**
+ * Starts the call in the callingx library.
+ * It is done by client on every join
+ * Does either of the following:
+ * 1. Sets the state for outgoing calls in the callingx library
+ * 2. Displays the incoming call in the callingx library
+ * 3. Optionally for non-ringing calls also when ongoing calls are enabled.
+ */
+export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
+  if (!CallingxModule || !CallingxModule.isSetup) {
+    return;
+  }
+
+  const logger = videoLoggerSystem.getLogger('callingx');
+  const isOutcomingCall = call.ringing && call.isCreatedByMe;
+  const isIncomingCall = call.ringing && !call.isCreatedByMe;
+
+  if (
+    isOutcomingCall ||
+    (!call.ringing && CallingxModule.isOngoingCallsEnabled)
+  ) {
+    logger.debug(`joinCallingxCall: Joining call ${call.cid}`);
+    try {
+      await CallingxModule.startCall(
+        call.cid, // unique id for call
+        call.id, // phone number for display in dialer (we use call id as phone number)
+        getCallDisplayNameFromCall(call), // display name for display in call screen
+        call.state.settings?.video?.enabled ?? false, // is video call?
+      );
+
+      // Wait for audio session activation on iOS only
+      if (Platform.OS === 'ios') {
+        await waitForAudioSessionActivation();
+      }
+    } catch (error) {
+      logger.error(
+        `startCallingxCall: Error starting call in callingx: ${call.cid}`,
+        error,
+      );
+    }
+  } else if (isIncomingCall) {
+    logger.debug(`joinCallingxCall: Joining incoming call ${call.cid}`);
+    try {
+      // Leave any existing active ringing calls before joining a new ringing call
+      const activeCallsToLeave = activeCalls.filter(
+        (c) =>
+          c.cid !== call.cid &&
+          c.ringing &&
+          c.state.callingState !== CallingState.LEFT,
+      );
+      for (const activeCall of activeCallsToLeave) {
+        logger.debug(
+          `leaving active call ${activeCall.cid} before joining ${call.cid}`,
+        );
+        await activeCall.leave({ reason: 'cancel' }).catch((e) => {
+          logger.error(`failed to leave active call ${activeCall.cid}`, e);
+        });
+      }
+
+      // Awaits native CallKit/Telecom registration before answering.
+      // Safe to call even if the call is already registered (e.g. from VoIP push) --
+      // iOS early-returns with no error, Android sends the registered broadcast.
+      await CallingxModule.displayIncomingCall(
+        call.cid, // unique id for call
+        call.id, // phone number for display in dialer (we use call id as phone number)
+        getCallDisplayNameFromCall(call), // display name for display in call screen
+        call.state.settings?.video?.enabled ?? false, // is video call?
+      );
+
+      await CallingxModule.answerIncomingCall(call.cid);
+
+      if (Platform.OS === 'ios') {
+        await waitForAudioSessionActivation();
+      }
+    } catch (error) {
+      logger.error(
+        `Error displaying incoming call in callingx: ${call.cid}`,
+        error,
+      );
+    }
+  }
+}
+
+export async function endCallingxCall(call: Call, reason?: EndCallReason) {
+  if (
+    !CallingxModule ||
+    !CallingxModule.isSetup ||
+    !CallingxModule.isCallTracked(call.cid)
+  ) {
+    return;
+  }
+
+  const logger = videoLoggerSystem.getLogger('callingx');
+  try {
+    logger.debug(`endCallingxCall: Ending call ${call.cid}`);
+    await CallingxModule.endCallWithReason(call.cid, reason ?? 'local');
+  } catch (error) {
+    logger.error(
+      `endCallingxCall: Error ending call in callingx: ${call.cid}`,
+      error,
+    );
+  }
+}

package/src/utils/internal/registerSDKGlobals.ts

@@ -1,23 +1,71 @@
-import type { StreamRNVideoSDKGlobals } from '@stream-io/video-client';
+import { StreamRNVideoSDKGlobals } from '@stream-io/video-client';
 import { NativeModules, PermissionsAndroid, Platform } from 'react-native';
+import { getCallingxLibIfAvailable } from '../push/libs/callingx';
+import {
+  endCallingxCall,
+  registerOutgoingCall,
+  joinCallingxCall,
+} from './callingx/callingx';
 
 const StreamInCallManagerNativeModule = NativeModules.StreamInCallManager;
 const StreamVideoReactNativeModule = NativeModules.StreamVideoReactNative as {
   checkPermission: StreamRNVideoSDKGlobals['permissions']['check'] | undefined;
 };
 
+const CallingxModule = getCallingxLibIfAvailable();
+
+/**
+ * Checks if StreamInCallManager should be bypassed because CallKit is handling
+ * the audio session via CallingX.
+ *
+ * On iOS, when CallingX is set up and has a registered call, the audio session
+ * is managed by CallKit through CallingxImpl.swift.
+ * In this case, StreamInCallManager should not run to avoid conflicting audio
+ * session configurations.
+ */
+const shouldBypassForCallKit = ({
+  isRingingTypeCall,
+}: {
+  isRingingTypeCall: boolean;
+}): boolean => {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  if (!CallingxModule) {
+    return false;
+  }
+  const bypass =
+    CallingxModule.isSetup &&
+    (isRingingTypeCall || CallingxModule.isOngoingCallsEnabled);
+  return bypass;
+};
+
 const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
+  callingX: {
+    joinCall: joinCallingxCall,
+    endCall: endCallingxCall,
+    registerOutgoingCall: registerOutgoingCall,
+  },
   callManager: {
-    setup: ({ defaultDevice }) => {
+    setup: ({ defaultDevice, isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
         defaultDevice,
       );
       StreamInCallManagerNativeModule.setup();
     },
-    start: () => {
+    start: ({ isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.start();
     },
-    stop: () => {
+    stop: ({ isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.stop();
     },
   },

package/src/utils/keepCallAliveHeadlessTask.ts

@@ -0,0 +1,54 @@
+import { AppRegistry, Platform } from 'react-native';
+import type { Call } from '@stream-io/video-client';
+import { videoLoggerSystem } from '@stream-io/video-client';
+import { StreamVideoRN } from './StreamVideoRN';
+
+export const KEEP_CALL_ALIVE_HEADLESS_TASK_NAME = 'StreamVideoKeepCallAlive';
+
+/**
+ * The keep-alive headless task needs access to the active `Call` instance.
+ * The keep-alive hook will set this reference before starting the native service.
+ */
+export const keepCallAliveCallRef: { current: Call | undefined } = {
+  current: undefined,
+};
+
+function registerKeepCallAliveHeadlessTaskOnce() {
+  if (Platform.OS !== 'android') return;
+
+  AppRegistry.registerHeadlessTask(
+    KEEP_CALL_ALIVE_HEADLESS_TASK_NAME,
+    () => async (data: { callCid?: string } | undefined) => {
+      const logger = videoLoggerSystem.getLogger(
+        'KEEP_CALL_ALIVE_HEADLESS_TASK',
+      );
+      const callCid = data?.callCid;
+
+      const call = keepCallAliveCallRef.current;
+      if (!call) {
+        logger.warn(
+          'No active call instance available for keep-alive task; skipping.',
+          { callCid },
+        );
+        return;
+      }
+      if (callCid && call.cid && call.cid !== callCid) {
+        logger.warn(
+          'Keep-alive task callCid does not match active call; skipping.',
+          { callCid, activeCallCid: call.cid },
+        );
+        return;
+      }
+
+      const config = StreamVideoRN.getConfig();
+      const taskToRun = config.foregroundService.android.taskToRun;
+      try {
+        await taskToRun(call);
+      } catch (e) {
+        logger.error('Keep-alive headless task failed', e);
+      }
+    },
+  );
+}
+
+registerKeepCallAliveHeadlessTaskOnce();