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

package/src/hooks/useAndroidKeepCallAliveEffect.ts

@@ -5,76 +5,48 @@ import {
   AppState,
   type AppStateStatus,
   NativeModules,
+  PermissionsAndroid,
   Platform,
 } from 'react-native';
-import { Call, CallingState, videoLoggerSystem } from '@stream-io/video-client';
-import {
-  getKeepCallAliveForegroundServiceTypes,
-  getNotifeeLibNoThrowForKeepCallAlive,
-} from '../utils/push/libs/notifee';
+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';
 
 const notifeeLib = getNotifeeLibNoThrowForKeepCallAlive();
-const callToPassToForegroundService: { current: Call | undefined } = {
-  current: undefined,
-};
 
-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 stopForegroundServiceNoThrow() {
+  const logger = videoLoggerSystem.getLogger('stopForegroundServiceNoThrow');
+  try {
+    await NativeModules.StreamVideoReactNative.stopKeepCallAliveService();
+  } catch (e) {
+    logger.warn('Failed to stop keep-call-alive foreground service', e);
+  }
 }
 
 async function startForegroundService(call_cid: string) {
-  const isCallAliveConfigured =
-    await NativeModules.StreamVideoReactNative.isCallAliveConfigured();
+  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;
+    }
+  })();
   if (!isCallAliveConfigured) {
-    const logger = videoLoggerSystem.getLogger('startForegroundService');
     logger.info(
       'KeepCallAlive is not configured. Skipping foreground service setup.',
     );
     return;
   }
-  // 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');
+  // 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) {
     logger.info(
       'Notification permission not granted, can not start foreground service to keep the call alive',
     );
@@ -83,38 +55,28 @@ async function startForegroundService(call_cid: string) {
   const videoConfig = StreamVideoRN.getConfig();
   const foregroundServiceConfig = videoConfig.foregroundService;
   const notificationTexts = foregroundServiceConfig.android.notificationTexts;
-  const channelId = foregroundServiceConfig.android.channel.id;
-  await notifeeLib.default.createChannel(
-    foregroundServiceConfig.android.channel,
-  );
-  const foregroundServiceTypes = await getKeepCallAliveForegroundServiceTypes();
+  const channel = foregroundServiceConfig.android.channel;
+  const smallIconName = videoConfig.push?.android.smallIcon;
+
   // 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(() => {
-    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
-        },
-      },
-    });
+  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);
+    }
   });
 }
 
-// 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
@@ -125,7 +87,7 @@ export const useAndroidKeepCallAliveEffect = () => {
   const foregroundServiceStartedRef = useRef(false);
 
   const call = useCall();
-  callToPassToForegroundService.current = call;
+  keepCallAliveCallRef.current = call;
   const activeCallCid = call?.cid;
   const { useCallCallingState } = useCallStateHooks();
   const callingState = useCallCallingState();
@@ -133,6 +95,7 @@ export const useAndroidKeepCallAliveEffect = () => {
   const isOutgoingCall =
     callingState === CallingState.RINGING && call?.isCreatedByMe;
   const isCallJoined = callingState === CallingState.JOINED;
+  const isNonRingingCall = !call?.ringing;
 
   const shouldStartForegroundService =
     !foregroundServiceStartedRef.current && (isOutgoingCall || isCallJoined);
@@ -141,7 +104,15 @@ export const useAndroidKeepCallAliveEffect = () => {
     if (Platform.OS === 'ios' || !activeCallCid) {
       return undefined;
     }
-    if (!notifeeLib) return undefined;
+
+    const callingx = getCallingxLibIfAvailable();
+    if (
+      callingx?.isSetup &&
+      isNonRingingCall &&
+      callingx?.isOngoingCallsEnabled
+    ) {
+      return undefined;
+    }
 
     // start foreground service as soon as the call is joined
     if (shouldStartForegroundService) {
@@ -149,23 +120,21 @@ export const useAndroidKeepCallAliveEffect = () => {
         if (foregroundServiceStartedRef.current) {
           return;
         }
-        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);
+        // 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);
+          }
         }
-        // check for notification permission and then start the foreground service
 
         await startForegroundService(activeCallCid);
         foregroundServiceStartedRef.current = true;
@@ -174,7 +143,6 @@ export const useAndroidKeepCallAliveEffect = () => {
       // ensure that app is active before running the function
       if (AppState.currentState === 'active') {
         run();
-        return undefined;
       }
       const sub = AppState.addEventListener(
         'change',
@@ -192,42 +160,49 @@ 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
-        notifeeLib.default.cancelDisplayedNotification(activeCallCid);
+        if (notifeeLib) {
+          notifeeLib.default.cancelDisplayedNotification(activeCallCid);
+        }
       };
     } else if (
       callingState === CallingState.IDLE ||
       callingState === CallingState.LEFT
     ) {
       if (foregroundServiceStartedRef.current) {
-        callToPassToForegroundService.current = undefined;
+        keepCallAliveCallRef.current = undefined;
         // stop foreground service when the call is not active
-        notifeeLib.default.stopForegroundService();
+        stopForegroundServiceNoThrow();
         foregroundServiceStartedRef.current = false;
       } else {
-        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();
-            }
-          });
+        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();
+              }
+            });
+        }
       }
     }
     return undefined;
-  }, [activeCallCid, callingState, shouldStartForegroundService]);
+  }, [
+    activeCallCid,
+    callingState,
+    shouldStartForegroundService,
+    isNonRingingCall,
+  ]);
 
   useEffect(() => {
     return () => {
       // stop foreground service when this effect is unmounted
       if (foregroundServiceStartedRef.current) {
-        if (!notifeeLib) return;
-        callToPassToForegroundService.current = undefined;
-        notifeeLib.default.stopForegroundService();
+        keepCallAliveCallRef.current = undefined;
+        stopForegroundServiceNoThrow();
         foregroundServiceStartedRef.current = false;
       }
     };

package/src/index.ts

@@ -9,6 +9,7 @@ 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,7 +1,10 @@
 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);
@@ -72,6 +75,19 @@ 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();
@@ -95,6 +111,14 @@ 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';
@@ -110,6 +134,12 @@ 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();
   };
 

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 />
-      <IosInformCallkeepCallEnd />
+      <CallingExpWithCallingState />
       <ClearPushWSSubscriptions />
       <DeviceStats />
       {children}
@@ -52,11 +52,11 @@ const AndroidKeepCallAlive = () => {
 };
 
 /**
- * This is a renderless component to end the call in callkeep for ios.
- * useAndroidKeepCallAliveEffect needs to called inside a child of StreamCallProvider.
+ * This is a renderless component to sync state between stream call and CallKit/Telecom.
+ * useCallingExpWithCallingStateEffect needs to called inside a child of StreamCallProvider.
  */
-const IosInformCallkeepCallEnd = () => {
-  useIosCallkeepWithCallingStateEffect();
+const CallingExpWithCallingState = () => {
+  useCallingExpWithCallingStateEffect();
   return null;
 };
 

package/src/utils/StreamVideoRN/index.ts

@@ -3,9 +3,14 @@ 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> = {
@@ -47,10 +52,7 @@ const DEFAULT_STREAM_VIDEO_CONFIG: StreamVideoConfig = {
     android: {
       channel: {
         id: 'stream_call_foreground_service',
-        name: 'To keep calls alive',
-        lights: false,
-        vibration: false,
-        importance: 3,
+        name: 'Ongoing calls',
       },
       notificationTexts: {
         title: 'Call in progress',
@@ -76,20 +78,6 @@ 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
@@ -102,7 +90,26 @@ export class StreamVideoRN {
    * import App from './App';
    * // Set push config
    * const pushConfig = {}; // construct your config
-   * StreamVideoRN.setPushConfig(pushConfig);
+   * // 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);
    * AppRegistry.registerComponent('app', () => App);
    */
   static setPushConfig(pushConfig: NonNullable<StreamVideoConfig['push']>) {
@@ -110,20 +117,23 @@ export class StreamVideoRN {
       // Ignoring this config as push config was already set
       return;
     }
-    if (
-      __DEV__ &&
-      (pushConfig.navigateAcceptCall || pushConfig.navigateToIncomingCall)
-    ) {
+
+    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 {
       throw new Error(
-        `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.`,
+        '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/.',
       );
     }
 
-    this.config.push = pushConfig;
-
-    setupIosCallKeepEvents(pushConfig);
+    setupCallingExpEvents(pushConfig);
     setupIosVoipPushEvents(pushConfig);
   }
 

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,21 @@ 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.
-       * @example
-       * {
-       *  getTitle: (createdUserName: string) => `Incoming call from ${createdUserName}`,
-       *  getBody: (createdUserName: string) => `Tap to answer the call`
-       *  getAcceptButtonTitle?: () => `Accept`,
-       *  getDeclineButtonTitle?: () => `Decline`,
-       * }
+       * The transformer to be used to transform the call title in the notification for ringing and ongoing calls for Android.
        */
-      incomingCallNotificationTextGetters?: {
-        getTitle: (createdUserName: string) => string;
-        getBody: (createdUserName: string) => string;
-        getAcceptButtonTitle?: () => string;
-        getDeclineButtonTitle?: () => string;
-      };
+      titleTransformer?: (memberName: string, incoming: boolean) => string;
+      /**
+       * The transformer to be used to transform the call subtitle for ringing and ongoing calls for Android.
+       */
+      subtitleTransformer?: (call_cid: string, incoming: boolean) => string;
       /**
        * Functions to create the texts shown in the notification for non ringing calls in Android.
        * @example
@@ -111,6 +137,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 +166,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 +177,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