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

package/src/hooks/useAndroidKeepCallAliveEffect.ts

@@ -5,48 +5,76 @@ import {
   AppState,
   type AppStateStatus,
   NativeModules,
-  PermissionsAndroid,
   Platform,
 } from 'react-native';
-import { CallingState, videoLoggerSystem } from '@stream-io/video-client';
-import { keepCallAliveCallRef } from '../utils/keepCallAliveHeadlessTask';
-import { getNotifeeLibNoThrowForKeepCallAlive } from '../utils/push/libs/notifee';
-import { getCallingxLibIfAvailable } from '../utils/push/libs';
+import { Call, CallingState, videoLoggerSystem } from '@stream-io/video-client';
+import {
+  getKeepCallAliveForegroundServiceTypes,
+  getNotifeeLibNoThrowForKeepCallAlive,
+} from '../utils/push/libs/notifee';
 
 const notifeeLib = getNotifeeLibNoThrowForKeepCallAlive();
+const callToPassToForegroundService: { current: Call | undefined } = {
+  current: undefined,
+};
 
-async function stopForegroundServiceNoThrow() {
-  const logger = videoLoggerSystem.getLogger('stopForegroundServiceNoThrow');
-  try {
-    await NativeModules.StreamVideoReactNative.stopKeepCallAliveService();
-  } catch (e) {
-    logger.warn('Failed to stop keep-call-alive foreground service', e);
-  }
+function setForegroundService() {
+  if (Platform.OS === 'ios' || !notifeeLib) return;
+  NativeModules.StreamVideoReactNative.isCallAliveConfigured().then(
+    (isConfigured: boolean) => {
+      if (!isConfigured) {
+        const logger = videoLoggerSystem.getLogger(
+          'setForegroundService method',
+        );
+        logger.info(
+          'KeepCallAlive is not configured. Skipping foreground service setup.',
+        );
+        return;
+      }
+      notifeeLib.default.registerForegroundService(() => {
+        const task = new Promise((resolve) => {
+          const logger = videoLoggerSystem.getLogger(
+            'setForegroundService method',
+          );
+          logger.info('Foreground service running for call in progress');
+          // any task to run from SDK in the foreground service must be added
+          resolve(true);
+        });
+        const videoConfig = StreamVideoRN.getConfig();
+        const foregroundServiceConfig = videoConfig.foregroundService;
+        const { taskToRun } = foregroundServiceConfig.android;
+        const call = callToPassToForegroundService.current;
+        if (!call) {
+          const logger = videoLoggerSystem.getLogger(
+            'setForegroundService method',
+          );
+          logger.warn('No call to pass to foreground service');
+          return task.then(() => new Promise(() => {}));
+        }
+        callToPassToForegroundService.current = undefined;
+        return task.then(() => taskToRun(call));
+      });
+    },
+  );
 }
 
 async function startForegroundService(call_cid: string) {
-  const logger = videoLoggerSystem.getLogger('startForegroundService');
-  const isCallAliveConfigured = await (async () => {
-    try {
-      return await NativeModules.StreamVideoReactNative.isCallAliveConfigured();
-    } catch (e) {
-      logger.warn('Failed to check whether KeepCallAlive is configured', e);
-      return false;
-    }
-  })();
+  const isCallAliveConfigured =
+    await NativeModules.StreamVideoReactNative.isCallAliveConfigured();
   if (!isCallAliveConfigured) {
+    const logger = videoLoggerSystem.getLogger('startForegroundService');
     logger.info(
       'KeepCallAlive is not configured. Skipping foreground service setup.',
     );
     return;
   }
-  // Check for notification permission (Android 13+) before starting the service.
-  const hasPostNotificationsPermission =
-    Number(Platform.Version) < 33 ||
-    (await PermissionsAndroid.check(
-      PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS,
-    ));
-  if (!hasPostNotificationsPermission) {
+  // check for notification permission and then start the foreground service
+  if (!notifeeLib) return;
+  const settings = await notifeeLib.default.getNotificationSettings();
+  if (
+    settings.authorizationStatus !== notifeeLib.AuthorizationStatus.AUTHORIZED
+  ) {
+    const logger = videoLoggerSystem.getLogger('startForegroundService');
     logger.info(
       'Notification permission not granted, can not start foreground service to keep the call alive',
     );
@@ -55,28 +83,38 @@ async function startForegroundService(call_cid: string) {
   const videoConfig = StreamVideoRN.getConfig();
   const foregroundServiceConfig = videoConfig.foregroundService;
   const notificationTexts = foregroundServiceConfig.android.notificationTexts;
-  const channel = foregroundServiceConfig.android.channel;
-  const smallIconName = videoConfig.push?.android.smallIcon;
-
+  const channelId = foregroundServiceConfig.android.channel.id;
+  await notifeeLib.default.createChannel(
+    foregroundServiceConfig.android.channel,
+  );
+  const foregroundServiceTypes = await getKeepCallAliveForegroundServiceTypes();
   // NOTE: we use requestAnimationFrame to ensure that the foreground service is started after all the current UI operations are done
   // this is a workaround for the crash - android.app.RemoteServiceException$ForegroundServiceDidNotStartInTimeException: Context.startForegroundService() did not then call Service.startForeground()
   // this crash was reproducible only in some android devices
-  requestAnimationFrame(async () => {
-    try {
-      await NativeModules.StreamVideoReactNative.startKeepCallAliveService(
-        call_cid,
-        channel.id,
-        channel.name,
-        notificationTexts.title,
-        notificationTexts.body,
-        smallIconName ?? null,
-      );
-    } catch (e) {
-      logger.warn('Failed to start keep-call-alive foreground service', e);
-    }
+  requestAnimationFrame(() => {
+    notifeeLib.default.displayNotification({
+      id: call_cid,
+      title: notificationTexts.title,
+      body: notificationTexts.body,
+      android: {
+        channelId,
+        smallIcon: videoConfig.push?.android.smallIcon,
+        foregroundServiceTypes,
+        asForegroundService: true,
+        ongoing: true, // user cannot dismiss the notification
+        colorized: true,
+        pressAction: {
+          id: 'default',
+          launchActivity: 'default', // open the app when the notification is pressed
+        },
+      },
+    });
   });
 }
 
+// flag to check if setForegroundService has already been run once
+let isSetForegroundServiceRan = false;
+
 /**
  * This hook is used to keep the call alive in the background for Android.
  * It starts a foreground service to keep the call alive as soon as the call is joined
@@ -87,7 +125,7 @@ export const useAndroidKeepCallAliveEffect = () => {
   const foregroundServiceStartedRef = useRef(false);
 
   const call = useCall();
-  keepCallAliveCallRef.current = call;
+  callToPassToForegroundService.current = call;
   const activeCallCid = call?.cid;
   const { useCallCallingState } = useCallStateHooks();
   const callingState = useCallCallingState();
@@ -95,7 +133,6 @@ export const useAndroidKeepCallAliveEffect = () => {
   const isOutgoingCall =
     callingState === CallingState.RINGING && call?.isCreatedByMe;
   const isCallJoined = callingState === CallingState.JOINED;
-  const isRingingCall = call?.ringing;
 
   const shouldStartForegroundService =
     !foregroundServiceStartedRef.current && (isOutgoingCall || isCallJoined);
@@ -104,14 +141,7 @@ export const useAndroidKeepCallAliveEffect = () => {
     if (Platform.OS === 'ios' || !activeCallCid) {
       return undefined;
     }
-
-    const callingx = getCallingxLibIfAvailable();
-    if (
-      callingx?.isSetup &&
-      (isRingingCall || (!isRingingCall && callingx?.isOngoingCallsEnabled))
-    ) {
-      return undefined;
-    }
+    if (!notifeeLib) return undefined;
 
     // start foreground service as soon as the call is joined
     if (shouldStartForegroundService) {
@@ -119,21 +149,23 @@ export const useAndroidKeepCallAliveEffect = () => {
         if (foregroundServiceStartedRef.current) {
           return;
         }
-        // Optional compatibility cleanup: if the app uses Notifee for ringing push,
-        // we might have an incoming call notification running as a foreground service.
-        if (notifeeLib) {
-          const notifee = notifeeLib.default;
-          const displayedNotifications =
-            await notifee.getDisplayedNotifications();
-          const activeCallNotification = displayedNotifications.find(
-            (notification) => notification.id === activeCallCid,
-          );
-          if (activeCallNotification) {
-            // this means that we have a incoming call notification shown as foreground service and we must stop it
-            notifee.stopForegroundService();
-            notifee.cancelDisplayedNotification(activeCallCid);
-          }
+        if (!isSetForegroundServiceRan) {
+          isSetForegroundServiceRan = true;
+          setForegroundService();
+        }
+        const notifee = notifeeLib.default;
+        const displayedNotifications =
+          await notifee.getDisplayedNotifications();
+        const activeCallNotification = displayedNotifications.find(
+          (notification) => notification.id === activeCallCid,
+        );
+        if (activeCallNotification) {
+          callToPassToForegroundService.current = undefined;
+          // this means that we have a incoming call notification shown as foreground service and we must stop it
+          notifee.stopForegroundService();
+          notifee.cancelDisplayedNotification(activeCallCid);
         }
+        // check for notification permission and then start the foreground service
 
         await startForegroundService(activeCallCid);
         foregroundServiceStartedRef.current = true;
@@ -142,6 +174,7 @@ export const useAndroidKeepCallAliveEffect = () => {
       // ensure that app is active before running the function
       if (AppState.currentState === 'active') {
         run();
+        return undefined;
       }
       const sub = AppState.addEventListener(
         'change',
@@ -159,49 +192,42 @@ export const useAndroidKeepCallAliveEffect = () => {
       return () => {
         // cancel any notifee displayed notification when the call has transitioned out of ringing
         // NOTE: cancels only the non fg service notifications
-        if (notifeeLib) {
-          notifeeLib.default.cancelDisplayedNotification(activeCallCid);
-        }
+        notifeeLib.default.cancelDisplayedNotification(activeCallCid);
       };
     } else if (
       callingState === CallingState.IDLE ||
       callingState === CallingState.LEFT
     ) {
       if (foregroundServiceStartedRef.current) {
-        keepCallAliveCallRef.current = undefined;
+        callToPassToForegroundService.current = undefined;
         // stop foreground service when the call is not active
-        stopForegroundServiceNoThrow();
+        notifeeLib.default.stopForegroundService();
         foregroundServiceStartedRef.current = false;
       } else {
-        if (notifeeLib) {
-          notifeeLib.default
-            .getDisplayedNotifications()
-            .then((displayedNotifications) => {
-              const activeCallNotification = displayedNotifications.find(
-                (notification) => notification.id === activeCallCid,
-              );
-              if (activeCallNotification) {
-                // this means that we have a incoming call notification shown as foreground service and we must stop it
-                notifeeLib.default.stopForegroundService();
-              }
-            });
-        }
+        notifeeLib.default
+          .getDisplayedNotifications()
+          .then((displayedNotifications) => {
+            const activeCallNotification = displayedNotifications.find(
+              (notification) => notification.id === activeCallCid,
+            );
+            if (activeCallNotification) {
+              callToPassToForegroundService.current = undefined;
+              // this means that we have a incoming call notification shown as foreground service and we must stop it
+              notifeeLib.default.stopForegroundService();
+            }
+          });
       }
     }
     return undefined;
-  }, [
-    activeCallCid,
-    callingState,
-    shouldStartForegroundService,
-    isRingingCall,
-  ]);
+  }, [activeCallCid, callingState, shouldStartForegroundService]);
 
   useEffect(() => {
     return () => {
       // stop foreground service when this effect is unmounted
       if (foregroundServiceStartedRef.current) {
-        keepCallAliveCallRef.current = undefined;
-        stopForegroundServiceNoThrow();
+        if (!notifeeLib) return;
+        callToPassToForegroundService.current = undefined;
+        notifeeLib.default.stopForegroundService();
         foregroundServiceStartedRef.current = false;
       }
     };

package/src/index.ts

@@ -9,7 +9,6 @@ import { registerGlobals } from '@stream-io/react-native-webrtc';
 import Logger from '@stream-io/react-native-webrtc/src/Logger';
 import { Platform } from 'react-native';
 import { registerSDKGlobals } from './utils/internal/registerSDKGlobals';
-import './utils/keepCallAliveHeadlessTask';
 
 // We're registering globals, because our video JS client is serving SDKs that use browser based webRTC functions.
 // This will result in creation of 2 global objects: `window` and `navigator`

package/src/modules/call-manager/CallManager.ts

@@ -1,10 +1,7 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import { AudioDeviceStatus, StreamInCallManagerConfig } from './types';
-import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
-import { videoLoggerSystem } from '@stream-io/video-client';
 
 const NativeManager = NativeModules.StreamInCallManager;
-const CallingxModule = getCallingxLibIfAvailable();
 
 const invariant = (condition: boolean, message: string) => {
   if (!condition) throw new Error(message);
@@ -75,19 +72,6 @@ class SpeakerManager {
   };
 }
 
-const shouldBypassForCallKit = (): boolean => {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-  if (!CallingxModule) {
-    return false;
-  }
-  return (
-    CallingxModule.isSetup &&
-    (CallingxModule.hasRegisteredCall() || CallingxModule.isOngoingCallsEnabled)
-  );
-};
-
 export class CallManager {
   android = new AndroidCallManager();
   ios = new IOSCallManager();
@@ -111,14 +95,6 @@ export class CallManager {
    * @param config.enableStereoAudioOutput Whether to enable stereo audio output. Only supported for listener audio role.
    */
   start = (config?: StreamInCallManagerConfig): void => {
-    if (shouldBypassForCallKit()) {
-      videoLoggerSystem
-        .getLogger('CallManager')
-        .debug(
-          'start: skipping start as callkit is handling the audio session',
-        );
-      return;
-    }
     NativeManager.setAudioRole(config?.audioRole ?? 'communicator');
     if (config?.audioRole === 'communicator') {
       const type = config.deviceEndpointType ?? 'speaker';
@@ -134,12 +110,6 @@ export class CallManager {
    * Stops the in call manager.
    */
   stop = (): void => {
-    if (shouldBypassForCallKit()) {
-      videoLoggerSystem
-        .getLogger('CallManager')
-        .debug('stop: skipping stop as callkit is handling the audio session');
-      return;
-    }
     NativeManager.stop();
   };
 
@@ -148,10 +118,4 @@ export class CallManager {
    * in the native layer.
    */
   logAudioState = (): void => NativeManager.logAudioState();
-
-  /**
-   * For debugging purposes, returns the current audio state as a string.
-   * @returns A string containing the current audio state information.
-   */
-  getAudioStateLog = (): string => NativeManager.getAudioStateLog();
 }

package/src/modules/call-manager/native-module.d.ts

@@ -82,13 +82,6 @@ export interface CallManager extends NativeModule {
    * Meant for debugging purposes.
    */
   logAudioState: () => void;
-
-  /**
-   * Get the current audio state as a string.
-   * Meant for debugging purposes.
-   * @returns A string containing the current audio state information.
-   */
-  getAudioStateLog: () => string;
 }
 
 declare module 'react-native' {

package/src/providers/StreamCall/index.tsx

@@ -1,12 +1,12 @@
 import { StreamCallProvider } from '@stream-io/video-react-bindings';
 import React, { type PropsWithChildren, useEffect } from 'react';
 import { Call } from '@stream-io/video-client';
+import { useIosCallkeepWithCallingStateEffect } from '../../hooks/push/useIosCallkeepWithCallingStateEffect';
 import { canAddPushWSSubscriptionsRef } from '../../utils/push/internal/utils';
 import { useAndroidKeepCallAliveEffect } from '../../hooks/useAndroidKeepCallAliveEffect';
 import { AppStateListener } from './AppStateListener';
 import { DeviceStats } from './DeviceStats';
 import { pushUnsubscriptionCallbacks } from '../../utils/push/internal/constants';
-import { useCallingExpWithCallingStateEffect } from '../../hooks/push/useCallingExpWithCallingStateEffect';
 
 // const PIP_CHANGE_EVENT = 'StreamVideoReactNative_PIP_CHANGE_EVENT';
 
@@ -34,7 +34,7 @@ export const StreamCall = ({
     <StreamCallProvider call={call}>
       <AppStateListener />
       <AndroidKeepCallAlive />
-      <CallingExpWithCallingState />
+      <IosInformCallkeepCallEnd />
       <ClearPushWSSubscriptions />
       <DeviceStats />
       {children}
@@ -52,11 +52,11 @@ const AndroidKeepCallAlive = () => {
 };
 
 /**
- * This is a renderless component to sync state between stream call and CallKit/Telecom.
- * useCallingExpWithCallingStateEffect needs to called inside a child of StreamCallProvider.
+ * This is a renderless component to end the call in callkeep for ios.
+ * useAndroidKeepCallAliveEffect needs to called inside a child of StreamCallProvider.
  */
-const CallingExpWithCallingState = () => {
-  useCallingExpWithCallingStateEffect();
+const IosInformCallkeepCallEnd = () => {
+  useIosCallkeepWithCallingStateEffect();
   return null;
 };
 

package/src/utils/StreamVideoRN/index.ts

@@ -3,14 +3,9 @@ import pushLogoutCallbacks from '../internal/pushLogoutCallback';
 import newNotificationCallbacks, {
   type NewCallNotificationCallback,
 } from '../internal/newNotificationCallbacks';
+import { setupIosCallKeepEvents } from '../push/setupIosCallKeepEvents';
 import { setupIosVoipPushEvents } from '../push/setupIosVoipPushEvents';
-import { setupCallingExpEvents } from '../push/setupCallingExpEvents';
-import {
-  extractCallingExpOptions,
-  getCallingxLib,
-} from '../push/libs/callingx';
 import { NativeModules, Platform } from 'react-native';
-import { videoLoggerSystem } from '@stream-io/video-client';
 
 // Utility type for deep partial
 type DeepPartial<T> = {
@@ -52,7 +47,10 @@ const DEFAULT_STREAM_VIDEO_CONFIG: StreamVideoConfig = {
     android: {
       channel: {
         id: 'stream_call_foreground_service',
-        name: 'Ongoing calls',
+        name: 'To keep calls alive',
+        lights: false,
+        vibration: false,
+        importance: 3,
       },
       notificationTexts: {
         title: 'Call in progress',
@@ -78,6 +76,20 @@ export class StreamVideoRN {
     this.config = deepMerge(this.config, updateConfig);
   }
 
+  static updateAndroidIncomingCallChannel(
+    updateChannel: Partial<
+      NonNullable<StreamVideoConfig['push']>['android']['incomingCallChannel']
+    >,
+  ) {
+    const prevChannel = this.config.push?.android?.incomingCallChannel;
+    if (prevChannel) {
+      this.config.push!.android.incomingCallChannel = {
+        ...prevChannel,
+        ...updateChannel,
+      };
+    }
+  }
+
   /**
    * Set the push config for StreamVideoRN.
    * This method must be called **outside** of your application lifecycle, e.g. alongside your
@@ -90,26 +102,7 @@ export class StreamVideoRN {
    * import App from './App';
    * // Set push config
    * const pushConfig = {}; // construct your config
-   * // Set CallKit/Android Telecom API integration options. All params are optional. If not provided, the default values will be used.
-   * const callingExpOptions = {
-   *   ios: {
-   *     callsHistory: true,
-   *     displayCallTimeout: 60000,
-   *     sound: 'ringtone',
-   *     imageName: 'callkit_icon',
-   *   },
-   *   android: {
-   *     incomingChannel: {
-   *       id: 'stream_incoming_call_notifications',
-   *       name: 'Call notifications',
-   *       vibration: true,
-   *       sound: 'default',
-   *     },
-   *     titleTransformer: (text: string) => text,
-   *     subtitleTransformer: (text: string) => text,
-   *   },
-   * };
-   * StreamVideoRN.setPushConfig(pushConfig, callingExpOptions);
+   * StreamVideoRN.setPushConfig(pushConfig);
    * AppRegistry.registerComponent('app', () => App);
    */
   static setPushConfig(pushConfig: NonNullable<StreamVideoConfig['push']>) {
@@ -117,23 +110,20 @@ export class StreamVideoRN {
       // Ignoring this config as push config was already set
       return;
     }
-
-    this.config.push = pushConfig;
-
-    try {
-      const callingx = getCallingxLib();
-      videoLoggerSystem
-        .getLogger('StreamVideoRN.setPushConfig')
-        .info(JSON.stringify(this.config));
-      const options = extractCallingExpOptions(this.config);
-      callingx.setup(options);
-    } catch {
+    if (
+      __DEV__ &&
+      (pushConfig.navigateAcceptCall || pushConfig.navigateToIncomingCall)
+    ) {
       throw new Error(
-        'react-native-callingx library is not installed. Please check the installation instructions: https://getstream.io/video/docs/react-native/incoming-calls/ringing-setup/react-native/.',
+        `Support for navigateAcceptCall or navigateToIncomingCall in pushConfig has been removed.
+        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.`,
       );
     }
 
-    setupCallingExpEvents(pushConfig);
+    this.config.push = pushConfig;
+
+    setupIosCallKeepEvents(pushConfig);
     setupIosVoipPushEvents(pushConfig);
   }