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

package/src/hooks/push/useCallingExpWithCallingStateEffect.ts

@@ -1,189 +0,0 @@
-import { Call, CallingState, videoLoggerSystem } from '@stream-io/video-client';
-import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
-import { useEffect, useMemo } from 'react';
-import { filter, take } from 'rxjs/operators';
-import { getCallDisplayName } from '../../utils/internal/callingx/callingx';
-import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
-
-const logger = videoLoggerSystem.getLogger('callingx');
-
-/**
- * This hook is used to inform sync call state with CallKit/Telecom (i.e. start call, end call, mute/unmute call).
- */
-export const useCallingExpWithCallingStateEffect = () => {
-  const { useMicrophoneState, useParticipants, useCallMembers } =
-    useCallStateHooks();
-
-  const activeCall = useCall();
-  const { isMute, microphone } = useMicrophoneState();
-  const callMembers = useCallMembers();
-  const participants = useParticipants();
-
-  const activeCallCid = activeCall?.cid;
-  const currentUserId = activeCall?.currentUserId;
-  const isIncoming =
-    (activeCall?.ringing && !activeCall?.isCreatedByMe) || false;
-
-  const callDisplayName = useMemo(
-    () => getCallDisplayName(callMembers, participants, currentUserId),
-    [callMembers, participants, currentUserId],
-  );
-
-  useEffect(() => {
-    const callingx = getCallingxLibIfAvailable();
-    if (!callingx?.isSetup || !activeCall) {
-      return;
-    }
-    // need to capture RINGING -> Joining -> Joined state change for the first time
-    // and inform callingx that the call is active
-    const shouldMakeCallActive = (call: Call): boolean => {
-      // only for outgoing calls or non-ringing ongoing calls in callingx
-      // Note: incoming calls are handled by callingx pending states instead
-      return (
-        (call.ringing && call.isCreatedByMe) ||
-        (!call.ringing && callingx.isOngoingCallsEnabled)
-      );
-    };
-    const subscription = activeCall.state.callingState$
-      .pipe(
-        filter(
-          (callingState) =>
-            shouldMakeCallActive(activeCall) &&
-            callingState === CallingState.JOINED &&
-            callingx.isCallTracked(activeCall.cid),
-        ),
-        take(1), // only need to capture the first joined state for outgoing calls
-        // then subscription completes and is automatically unsubscribed
-      )
-      .subscribe(() => {
-        callingx.setCurrentCallActive(activeCall.cid);
-      });
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, [activeCall]);
-
-  useEffect(() => {
-    return () => {
-      const callingx = getCallingxLibIfAvailable();
-      if (!callingx?.isSetup || !activeCallCid) {
-        return;
-      }
-
-      const isCallTracked = callingx.isCallTracked(activeCallCid);
-      if (!isCallTracked) {
-        logger.debug(
-          `useCallingExpWithCallingStateEffect:No active call cid to end in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked}`,
-        );
-        return;
-      }
-      //if incoming stream call was unmounted, we need to end the call in CallKit/Telecom
-      logger.debug(
-        `useCallingExpWithCallingStateEffect: Ending call in callingx: ${activeCallCid}`,
-      );
-      callingx
-        .endCallWithReason(activeCallCid, 'local')
-        .catch((error: unknown) => {
-          logger.error(
-            `useCallingExpWithCallingStateEffect: Error ending call in callingx: ${activeCallCid}`,
-            error,
-          );
-        });
-    };
-  }, [activeCallCid]);
-
-  useEffect(() => {
-    const callingx = getCallingxLibIfAvailable();
-    if (!callingx?.isSetup || !activeCallCid) {
-      return;
-    }
-
-    const isCallTracked = callingx.isCallTracked(activeCallCid);
-    if (!isCallTracked) {
-      logger.debug(
-        `useCallingExpWithCallingStateEffect:No active call cid to update callingx: ${activeCallCid} isCallTracked: ${isCallTracked}`,
-      );
-      return;
-    }
-
-    callingx.updateDisplay(
-      activeCallCid,
-      activeCallCid,
-      callDisplayName,
-      isIncoming,
-    );
-  }, [activeCallCid, callDisplayName, isIncoming]);
-
-  // Sync microphone mute state from app → CallKit
-  useEffect(() => {
-    const callingx = getCallingxLibIfAvailable();
-    if (!callingx?.isSetup || !activeCallCid) {
-      return;
-    }
-
-    const isCallTracked = callingx.isCallTracked(activeCallCid);
-    if (!isCallTracked) {
-      logger.debug(
-        `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked}`,
-      );
-      return;
-    }
-
-    callingx.setMutedCall(activeCallCid, isMute);
-  }, [activeCallCid, isMute]);
-
-  // Sync mute state from CallKit → app (only for system-initiated mute actions)
-  useEffect(() => {
-    const callingx = getCallingxLibIfAvailable();
-    if (!callingx?.isSetup || !activeCallCid) {
-      logger.debug(
-        `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} callingx isSetup: ${callingx?.isSetup}`,
-      );
-      return;
-    }
-
-    // Listen to mic toggle events from CallKit/Telecom and update stream call microphone state.
-    // Only system-initiated mute actions (e.g. user tapped mute on the native CallKit UI)
-    // are sent here — app-initiated actions are filtered out on the native side to prevent
-    // the feedback loop: app mutes mic → setMutedCall → CallKit delegate → event to JS → loop.
-    const subscription = callingx.addEventListener(
-      'didPerformSetMutedCallAction',
-      async (event: { callId: string; muted: boolean }) => {
-        const { callId, muted } = event;
-
-        const isCallTracked = callingx.isCallTracked(activeCallCid);
-        if (!isCallTracked || callId !== activeCallCid) {
-          logger.debug(
-            `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked} callId: ${callId}`,
-          );
-          return;
-        }
-
-        const isCurrentlyMuted = microphone.state.status === 'disabled';
-        if (isCurrentlyMuted === muted) {
-          logger.debug(
-            `useCallingExpWithCallingStateEffect: Mic toggle is already in the desired state: ${muted} for call: ${activeCallCid}`,
-          );
-          return;
-        }
-
-        try {
-          if (muted) {
-            await microphone.disable();
-          } else {
-            await microphone.enable();
-          }
-        } catch (error: unknown) {
-          logger.error(
-            `useCallingExpWithCallingStateEffect: Error toggling mic in calling exp: ${activeCallCid}`,
-            error,
-          );
-        }
-      },
-    );
-
-    return () => {
-      subscription.remove();
-    };
-  }, [activeCallCid, microphone]);
-};

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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,194 +0,0 @@
-/***
- * 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/keepCallAliveHeadlessTask.ts

@@ -1,54 +0,0 @@
-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();

package/src/utils/push/libs/callingx.ts

@@ -1,89 +0,0 @@
-import { StreamVideoConfig } from '../../StreamVideoRN/types';
-
-export type RNCallingxType =
-  import('@stream-io/react-native-callingx').ICallingxModule;
-export type EventData = import('@stream-io/react-native-callingx').EventData;
-export type EventParams =
-  import('@stream-io/react-native-callingx').EventParams;
-export type CallingExpOptions =
-  import('@stream-io/react-native-callingx').CallingExpOptions;
-
-let callingx: RNCallingxType | undefined;
-
-try {
-  callingx = require('@stream-io/react-native-callingx').CallingxModule;
-} catch {}
-
-export function getCallingxLib() {
-  if (!callingx) {
-    throw Error('react-native-callingx library is not installed.');
-  }
-  return callingx;
-}
-
-export function getCallingxLibIfAvailable() {
-  return callingx ?? undefined;
-}
-
-export function extractCallingExpOptions(
-  config: StreamVideoConfig,
-): CallingExpOptions {
-  const { push: pushConfig, foregroundService: foregroundServiceConfig } =
-    config;
-  const callingExpOptions: CallingExpOptions = {};
-
-  if (pushConfig?.ios) {
-    const iosOptions: CallingExpOptions['ios'] = {};
-    if (pushConfig.ios.supportsVideo !== undefined) {
-      iosOptions.supportsVideo = pushConfig.ios.supportsVideo;
-    }
-    if (pushConfig.ios.sound !== undefined) {
-      iosOptions.sound = pushConfig.ios.sound;
-    }
-    if (pushConfig.ios.imageName !== undefined) {
-      iosOptions.imageName = pushConfig.ios.imageName;
-    }
-    if (pushConfig.ios.callsHistory !== undefined) {
-      iosOptions.callsHistory = pushConfig.ios.callsHistory;
-    }
-    if (pushConfig.ios.displayCallTimeout !== undefined) {
-      iosOptions.displayCallTimeout = pushConfig.ios.displayCallTimeout;
-    }
-
-    if (Object.keys(iosOptions).length > 0) {
-      callingExpOptions.ios = iosOptions;
-    }
-  }
-
-  const androidOptions: CallingExpOptions['android'] = {};
-  if (pushConfig?.android) {
-    if (pushConfig.android.incomingChannel) {
-      androidOptions.incomingChannel = pushConfig.android.incomingChannel;
-    }
-    if (pushConfig.android.titleTransformer) {
-      androidOptions.titleTransformer = pushConfig.android.titleTransformer;
-    }
-    if (pushConfig.android.notificationTexts) {
-      androidOptions.notificationTexts = pushConfig.android.notificationTexts;
-    }
-  }
-
-  if (foregroundServiceConfig.android.channel) {
-    androidOptions.ongoingChannel = foregroundServiceConfig.android.channel;
-  }
-
-  if (Object.keys(androidOptions).length > 0) {
-    callingExpOptions.android = androidOptions;
-  }
-
-  if (pushConfig?.shouldRejectCallWhenBusy !== undefined) {
-    callingExpOptions.shouldRejectCallWhenBusy =
-      pushConfig.shouldRejectCallWhenBusy;
-  }
-
-  if (pushConfig?.enableOngoingCalls !== undefined) {
-    callingExpOptions.enableOngoingCalls = pushConfig?.enableOngoingCalls;
-  }
-
-  return callingExpOptions;
-}