@stream-io/video-react-native-sdk 1.29.0-beta.3 → 1.29.1

package/src/hooks/push/useIosCallkeepWithCallingStateEffect.ts

@@ -0,0 +1,235 @@
+import {
+  CallingState,
+  RxUtils,
+  videoLoggerSystem,
+} from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+import { NativeModules, Platform } from 'react-native';
+import { useEffect, useState } from 'react';
+import { StreamVideoRN } from '../../utils';
+import { getCallKeepLib } from '../../utils/push/libs';
+import {
+  voipCallkeepAcceptedCallOnNativeDialerMap$,
+  voipCallkeepCallOnForegroundMap$,
+  voipPushNotificationCallCId$,
+} from '../../utils/push/internal/rxSubjects';
+
+const isNonActiveCallingState = (callingState: CallingState) => {
+  return (
+    callingState === CallingState.IDLE ||
+    callingState === CallingState.UNKNOWN ||
+    callingState === CallingState.LEFT
+  );
+};
+
+const isAcceptedCallingState = (callingState: CallingState) => {
+  return (
+    callingState === CallingState.JOINING ||
+    callingState === CallingState.JOINED
+  );
+};
+
+const unsubscribeCallkeepEvents = async (activeCallCid: string | undefined) => {
+  const voipPushNotificationCallCId = RxUtils.getCurrentValue(
+    voipPushNotificationCallCId$,
+  );
+  if (activeCallCid && activeCallCid === voipPushNotificationCallCId) {
+    // callkeep events should not be listened anymore so clear the call cid
+    voipPushNotificationCallCId$.next(undefined);
+  }
+  return await NativeModules.StreamVideoReactNative?.removeIncomingCall(
+    activeCallCid,
+  );
+};
+
+const logger = videoLoggerSystem.getLogger(
+  'useIosCallkeepWithCallingStateEffect',
+);
+const log = (message: string) => {
+  logger.warn(message);
+};
+
+/**
+ * This hook is used to inform the callkeep library that the call has been joined or ended.
+ */
+export const useIosCallkeepWithCallingStateEffect = () => {
+  const activeCall = useCall();
+  const { useCallCallingState } = useCallStateHooks();
+  const callingState = useCallCallingState();
+  const [acceptedForegroundCallkeepMap, setAcceptedForegroundCallkeepMap] =
+    useState<{
+      uuid: string;
+      cid: string;
+    }>();
+
+  useEffect(() => {
+    return () => {
+      const pushConfig = StreamVideoRN.getConfig().push;
+      if (
+        Platform.OS !== 'ios' ||
+        !pushConfig ||
+        !pushConfig.ios?.pushProviderName
+      ) {
+        return;
+      }
+      if (!pushConfig.android.incomingCallChannel) {
+        // TODO: remove this check and find a better way once we have telecom integration for android
+        return;
+      }
+
+      const callkeep = getCallKeepLib();
+      // if the component is unmounted and the callID was not reported to callkeep, then report it now
+      if (acceptedForegroundCallkeepMap) {
+        log(
+          `Ending call in callkeep: ${acceptedForegroundCallkeepMap.cid}, reason: component unmounted and call was present in acceptedForegroundCallkeepMap`,
+        );
+        unsubscribeCallkeepEvents(acceptedForegroundCallkeepMap.cid).then(() =>
+          callkeep.endCall(acceptedForegroundCallkeepMap.uuid),
+        );
+      }
+    };
+  }, [acceptedForegroundCallkeepMap]);
+
+  const activeCallCid = activeCall?.cid;
+
+  useEffect(() => {
+    return () => {
+      const pushConfig = StreamVideoRN.getConfig().push;
+      if (
+        Platform.OS !== 'ios' ||
+        !pushConfig ||
+        !pushConfig.ios?.pushProviderName ||
+        !activeCallCid
+      ) {
+        return;
+      }
+      if (!pushConfig.android.incomingCallChannel) {
+        // TODO: remove this check and find a better way once we have telecom integration for android
+        return;
+      }
+      const nativeDialerAcceptedCallMap = RxUtils.getCurrentValue(
+        voipCallkeepAcceptedCallOnNativeDialerMap$,
+      );
+      const foregroundIncomingCallkeepMap = RxUtils.getCurrentValue(
+        voipCallkeepCallOnForegroundMap$,
+      );
+      const callkeep = getCallKeepLib();
+      if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+        log(
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in nativeDialerAcceptedCallMap`,
+        );
+        unsubscribeCallkeepEvents(activeCallCid).then(() =>
+          callkeep.endCall(nativeDialerAcceptedCallMap.uuid),
+        );
+        // no need to keep this reference anymore
+        voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
+      } else if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+        log(
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in foregroundIncomingCallkeepMap`,
+        );
+        unsubscribeCallkeepEvents(activeCallCid).then(() =>
+          callkeep.endCall(foregroundIncomingCallkeepMap.uuid),
+        );
+      }
+    };
+  }, [activeCallCid]);
+
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (
+    Platform.OS !== 'ios' ||
+    !pushConfig ||
+    !pushConfig.ios.pushProviderName ||
+    !activeCallCid
+  ) {
+    return;
+  }
+  if (!pushConfig.android.incomingCallChannel) {
+    // TODO: remove this check and find a better way once we have telecom integration for android
+    return;
+  }
+
+  /**
+   * Check if current call is still needed to be accepted in callkeep
+   */
+  if (
+    isAcceptedCallingState(callingState) &&
+    acceptedForegroundCallkeepMap?.cid !== activeCallCid
+  ) {
+    const callkeep = getCallKeepLib();
+    // push notification was displayed
+    // but the call has been accepted through the app and not through the native dialer
+    const foregroundCallkeepMap = RxUtils.getCurrentValue(
+      voipCallkeepCallOnForegroundMap$,
+    );
+    if (foregroundCallkeepMap && foregroundCallkeepMap.cid === activeCallCid) {
+      log(
+        // @ts-expect-error - types issue
+        `Accepting call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundCallkeepMap`,
+      );
+      // no need to keep this reference anymore
+      voipCallkeepCallOnForegroundMap$.next(undefined);
+      NativeModules.StreamVideoReactNative?.removeIncomingCall(
+        activeCallCid,
+      ).then(() => callkeep.answerIncomingCall(foregroundCallkeepMap.uuid));
+      // this call should be accepted in callkeep
+      setAcceptedForegroundCallkeepMap(foregroundCallkeepMap);
+    }
+  }
+
+  /**
+   * Check if current call is still needed to be ended in callkeep
+   */
+  if (isNonActiveCallingState(callingState)) {
+    const callkeep = getCallKeepLib();
+
+    // this was a previously joined call which had push notification displayed
+    // the call was accepted through the app and not through native dialer
+    // the call was left using the leave button in the app and not through native dialer
+    if (activeCallCid === acceptedForegroundCallkeepMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in acceptedForegroundCallkeepMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(acceptedForegroundCallkeepMap.uuid),
+      );
+      setAcceptedForegroundCallkeepMap(undefined);
+      return;
+    }
+    // this was a call which had push notification displayed but never joined
+    // the user rejected in the app and not from native dialer
+    const foregroundIncomingCallkeepMap = RxUtils.getCurrentValue(
+      voipCallkeepCallOnForegroundMap$,
+    );
+    if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundIncomingCallkeepMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(foregroundIncomingCallkeepMap.uuid),
+      );
+      // no need to keep this reference anymore
+      voipCallkeepCallOnForegroundMap$.next(undefined);
+      return;
+    }
+    // this was a previously joined call
+    // it was an accepted call from native dialer and not from the app
+    // the user left using the leave button in the app
+    const nativeDialerAcceptedCallMap = RxUtils.getCurrentValue(
+      voipCallkeepAcceptedCallOnNativeDialerMap$,
+    );
+    if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in nativeDialerAcceptedCallMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(nativeDialerAcceptedCallMap.uuid),
+      );
+      // no need to keep this reference anymore
+      voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
+      return;
+    }
+  }
+};

package/src/hooks/push/useIosVoipPushEventsSetupEffect.ts

@@ -1,4 +1,6 @@
 import { type MutableRefObject, useEffect, useRef, useState } from 'react';
+import { getVoipPushNotificationLib } from '../../utils/push/libs';
+
 import { Platform } from 'react-native';
 import { StreamVideoRN } from '../../utils';
 import { onVoipNotificationReceived } from '../../utils/push/internal/ios';
@@ -8,7 +10,6 @@ import {
 } from '@stream-io/video-react-bindings';
 import { setPushLogoutCallback } from '../../utils/internal/pushLogoutCallback';
 import { StreamVideoClient, videoLoggerSystem } from '@stream-io/video-client';
-import { getCallingxLibIfAvailable } from '../../utils/push/libs';
 
 const logger = videoLoggerSystem.getLogger('useIosVoipPushEventsSetupEffect');
 
@@ -27,7 +28,6 @@ function setLogoutCallback(
     lastVoipTokenRef.current = { token: '', userId: '' };
     try {
       await client.removeDevice(token);
-      logger.debug('PushLogoutCallback - Removed voip token', token);
     } catch (err) {
       logger.warn('PushLogoutCallback - Failed to remove voip token', err);
     }
@@ -89,12 +89,24 @@ export const useIosVoipPushEventsSetupEffect = () => {
   useEffect(() => {
     const pushConfig = StreamVideoRN.getConfig().push;
     const pushProviderName = pushConfig?.ios.pushProviderName;
-    const callingx = getCallingxLibIfAvailable();
-
-    if (Platform.OS !== 'ios' || !client || !pushProviderName || !callingx) {
+    if (Platform.OS !== 'ios' || !client || !pushProviderName) {
+      return;
+    }
+    if (!pushConfig.android.incomingCallChannel) {
+      // TODO: remove this check and find a better way once we have telecom integration for android
+      logger.debug(
+        'android incomingCallChannel is not defined, so skipping the useIosVoipPushEventsSetupEffect',
+      );
       return;
     }
 
+    const voipPushNotification = getVoipPushNotificationLib();
+
+    // even though we do this natively, we have to still register here again
+    // natively this will make sure "register" event for JS is sent with the last push token
+    // Necessary if client changed before we got the event here or user logged out and logged in again
+    voipPushNotification.registerVoipToken();
+
     const onTokenReceived = (token: string) => {
       const userId = client.streamClient._user?.id ?? '';
       if (client.streamClient.anonymous || !token || !userId) {
@@ -133,24 +145,24 @@ export const useIosVoipPushEventsSetupEffect = () => {
         });
     };
     // fired when PushKit give us the latest token
-    const voipRegisterListener = callingx.addEventListener(
-      'voipNotificationsRegistered',
-      ({ token }) => {
-        onTokenReceived(token);
-      },
-    );
+    voipPushNotification.addEventListener('register', (token) => {
+      onTokenReceived(token);
+    });
 
-    // this will return events that were fired before js bridge initialized
-    callingx.getInitialVoipEvents().forEach(({ eventName, params }) => {
-      if (eventName === 'voipNotificationsRegistered' && 'token' in params) {
-        onTokenReceived(params.token);
-      } else if (eventName === 'voipNotificationReceived') {
-        onVoipNotificationReceived(params, pushConfig);
+    // this will fire when there are events occured before js bridge initialized
+    voipPushNotification.addEventListener('didLoadWithEvents', (events) => {
+      if (!events || !Array.isArray(events) || events.length < 1) {
+        return;
+      }
+      for (const voipPushEvent of events) {
+        const { name, data } = voipPushEvent;
+        if (name === 'RNVoipPushRemoteNotificationsRegisteredEvent') {
+          onTokenReceived(data);
+        } else if (name === 'RNVoipPushRemoteNotificationReceivedEvent') {
+          onVoipNotificationReceived(data, pushConfig);
+        }
       }
     });
-
-    callingx.registerVoipToken();
-
     lastListener.count += 1;
     const currentListenerCount = lastListener.count;
 
@@ -163,7 +175,8 @@ export const useIosVoipPushEventsSetupEffect = () => {
         return;
       }
       logger.debug(`Voip event listeners are removed for user: ${userId}`);
-      voipRegisterListener.remove();
+      voipPushNotification.removeEventListener('didLoadWithEvents');
+      voipPushNotification.removeEventListener('register');
     };
   }, [client]);
 };

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`