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

package/src/utils/push/internal/ios.ts

@@ -1,10 +1,9 @@
-import { AppState, NativeModules, Platform } from 'react-native';
-import { getCallKeepLib, getVoipPushNotificationLib } from '../libs';
-import { voipPushNotificationCallCId$ } from './rxSubjects';
+import { Platform } from 'react-native';
 import { pushUnsubscriptionCallbacks } from './constants';
-import { canAddPushWSSubscriptionsRef, shouldCallBeEnded } from './utils';
+import { canListenToWS, shouldCallBeClosed } from './utils';
 import { StreamVideoConfig } from '../../StreamVideoRN/types';
 import { videoLoggerSystem } from '@stream-io/video-client';
+import { getCallingxLib } from '../libs/callingx';
 
 export const onVoipNotificationReceived = async (
   notification: any,
@@ -32,71 +31,57 @@ export const onVoipNotificationReceived = async (
         "version": "v2"
       }
     } */
+  const logger = videoLoggerSystem.getLogger(
+    'callingx - onVoipNotificationReceived',
+  );
+
   const sender = notification?.stream?.sender;
   const type = notification?.stream?.type;
   // do not process any other notifications other than stream.video or ringing
   if (sender !== 'stream.video' && type !== 'call.ring') {
     return;
   }
+
   const call_cid = notification?.stream?.call_cid;
   if (!call_cid || Platform.OS !== 'ios' || !pushConfig.ios.pushProviderName) {
     return;
   }
-  const logger = videoLoggerSystem.getLogger('setupIosVoipPushEvents');
-  const client = await pushConfig.createStreamVideoClient();
 
-  if (!client) {
+  const callingx = getCallingxLib();
+  if (callingx.isCallTracked(call_cid)) {
+    //same call_cid is already tracked, so we skip the notification
     logger.debug(
-      'client not found, not processing call.ring voip push notification',
+      `the same call_cid ${call_cid} is already tracked, skipping the call.ring notification`,
     );
     return;
   }
-  const shouldRejectCallWhenBusy = client['rejectCallWhenBusy'] ?? false;
-  if (shouldRejectCallWhenBusy) {
-    // inform the iOS native module that we should reject call when busy
-    NativeModules.StreamVideoReactNative.setShouldRejectCallWhenBusy(
-      shouldRejectCallWhenBusy,
-    );
-  }
-  const callFromPush = await client.onRingingCall(call_cid);
-  let uuid = '';
-  try {
-    uuid =
-      await NativeModules?.StreamVideoReactNative?.getIncomingCallUUid(
-        call_cid,
-      );
-  } catch (error) {
-    logger.error('Error in getting call uuid from native module', error);
-  }
-  if (!uuid) {
-    logger.error(
-      `Not processing call.ring push notification, as no uuid found for call_cid: ${call_cid}`,
+
+  const client = await pushConfig.createStreamVideoClient();
+  if (!client) {
+    logger.debug(
+      'client not found, not processing call.ring voip push notification',
     );
     return;
   }
-  const created_by_id = notification?.stream?.created_by_id;
-  const receiver_id = notification?.stream?.receiver_id;
+
+  const callFromPush = await client.onRingingCall(call_cid);
+
   function closeCallIfNecessary() {
-    const { mustEndCall, callkeepReason } = shouldCallBeEnded(
+    const { mustEndCall, endCallReason } = shouldCallBeClosed(
       callFromPush,
-      created_by_id,
-      receiver_id,
+      notification?.stream,
     );
     if (mustEndCall) {
-      const callkeep = getCallKeepLib();
       logger.debug(
-        `callkeep.reportEndCallWithUUID for uuid: ${uuid}, call_cid: ${call_cid}, reason: ${callkeepReason}`,
+        `callingx.endCallWithReason for call_cid: ${call_cid} endCallReason: ${endCallReason}`,
       );
-      callkeep.reportEndCallWithUUID(uuid, callkeepReason);
-      const voipPushNotification = getVoipPushNotificationLib();
-      voipPushNotification.onVoipNotificationCompleted(uuid);
+      callingx.endCallWithReason(call_cid, endCallReason);
       return true;
     }
     return false;
   }
+
   const closed = closeCallIfNecessary();
-  const canListenToWS = () =>
-    canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
   if (!closed && canListenToWS()) {
     const unsubscribe = callFromPush.on('all', (event) => {
       const _canListenToWS = canListenToWS();
@@ -121,10 +106,9 @@ export const onVoipNotificationReceived = async (
     pushUnsubscriptionCallbacks.get(call_cid)?.forEach((cb) => cb());
     pushUnsubscriptionCallbacks.set(call_cid, [unsubscribe]);
   }
-  // send the info to this subject, it is listened by callkeep events
-  // callkeep events will then accept/reject the call
+
+  // callingx event listeners (setupCallingExpEvents) will handle accept/reject
   logger.debug(
-    `call_cid:${call_cid} uuid:${uuid} received and processed from call.ring push notification`,
+    `call_cid:${call_cid} received and processed from call.ring push notification`,
   );
-  voipPushNotificationCallCId$.next(call_cid);
 };

package/src/utils/push/internal/rxSubjects.ts

@@ -8,64 +8,3 @@ import type { NonRingingPushEvent } from '../../StreamVideoRN/types';
 export const pushNonRingingCallData$ = new BehaviorSubject<
   { cid: string; type: NonRingingPushEvent } | undefined
 >(undefined);
-
-/**
- * This rxjs subject is used to store the call cid of the accepted incoming call from push notification
- * Note: it is should be subscribed only when a user has connected to the websocket of Stream
- */
-export const pushAcceptedIncomingCallCId$ = new BehaviorSubject<
-  string | undefined
->(undefined);
-
-/**
- * This rxjs subject is used to store the call cid of the tapped incoming call from push notification it is neither accepted nor rejected yet
- * Note: it should be subscribed only when a user has connected to the websocket of Stream
- */
-export const pushTappedIncomingCallCId$ = new BehaviorSubject<
-  string | undefined
->(undefined);
-
-/**
- * This rxjs subject is used to store the call cid of the delivered incoming call from push notification it is neither accepted nor rejected yet
- * Used so that the call is navigated to when app is open from being killed
- * Note: it should be subscribed only when a user has connected to the websocket of Stream
- */
-export const pushAndroidBackgroundDeliveredIncomingCallCId$ =
-  new BehaviorSubject<string | undefined>(undefined);
-
-/**
- * This rxjs subject is used to store the call cid of the accepted incoming call from push notification
- * Note: it should be subscribed only when a user has connected to the websocket of Stream
- */
-export const pushRejectedIncomingCallCId$ = new BehaviorSubject<
-  string | undefined
->(undefined);
-
-/**
- * This rxjs subject is used to store the call cid of the incoming call from ios voip pushkit notification
- */
-export const voipPushNotificationCallCId$ = new BehaviorSubject<
-  string | undefined
->(undefined);
-
-/** The pair of cid of a call and its corresponding uuid created in the native side */
-type CallkeepMap = {
-  uuid: string;
-  cid: string;
-};
-
-/*
- * This rxjs subject should only used to store the CallkeepMap
- * for the incoming call when on foreground
- * or in other words, when we get didDisplayIncomingCall from callkeep lib
- */
-export const voipCallkeepCallOnForegroundMap$ = new BehaviorSubject<
-  CallkeepMap | undefined
->(undefined);
-
-/*
- * This rxjs subject should only used to store the CallkeepMap when it was accepted in the native dialer
- */
-export const voipCallkeepAcceptedCallOnNativeDialerMap$ = new BehaviorSubject<
-  CallkeepMap | undefined
->(undefined);

package/src/utils/push/internal/utils.ts

@@ -10,6 +10,8 @@ import type {
 } from '../../StreamVideoRN/types';
 import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
 import { pushUnsubscriptionCallbacks } from './constants';
+import { AppState } from 'react-native';
+import type { EndCallReason } from '@stream-io/react-native-callingx';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
@@ -24,44 +26,37 @@ export const shouldCallBeEnded = (
   created_by_id: string | undefined,
   receiver_id: string | undefined,
 ) => {
-  /* callkeep reasons for ending a call
-    FAILED: 1,
-    REMOTE_ENDED: 2,
-    UNANSWERED: 3,
-    ANSWERED_ELSEWHERE: 4,
-    DECLINED_ELSEWHERE: 5,
-    MISSED: 6
-  */
   const callSession = callFromPush.state.session;
   const rejected_by = callSession?.rejected_by;
   const accepted_by = callSession?.accepted_by;
   let mustEndCall = false;
-  let callkeepReason = 0;
+  let endCallReason: EndCallReason = 'unknown';
+
   if (created_by_id && rejected_by) {
     if (rejected_by[created_by_id]) {
-      // call was cancelled by the caller
+      // call was cancelled by the caller before the receiver could answer
       mustEndCall = true;
-      callkeepReason = 2;
+      endCallReason = 'canceled';
     }
   } else if (receiver_id && rejected_by) {
     if (rejected_by[receiver_id]) {
       // call was rejected by the receiver in some other device
       mustEndCall = true;
-      callkeepReason = 5;
+      endCallReason = 'rejected';
     }
   } else if (receiver_id && accepted_by) {
     if (accepted_by[receiver_id]) {
       // call was accepted by the receiver in some other device
       mustEndCall = true;
-      callkeepReason = 4;
+      endCallReason = 'answeredElsewhere';
     }
   }
   videoLoggerSystem
     .getLogger('shouldCallBeEnded')
     .debug(
-      `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} callkeepReason: ${callkeepReason}`,
+      `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} endCallReason: ${endCallReason}`,
     );
-  return { mustEndCall, callkeepReason };
+  return { mustEndCall, endCallReason };
 };
 
 /* An action for the notification or callkeep and app does not have JS context setup yet, so we need to do two steps:
@@ -104,10 +99,10 @@ export const processCallFromPush = async (
   pushConfig: PushConfig,
 ) => {
   let callFromPush: Call;
+  const logger = videoLoggerSystem.getLogger('Callingx - processCallFromPush');
   try {
     callFromPush = await client.onRingingCall(call_cid);
   } catch (e) {
-    const logger = videoLoggerSystem.getLogger('processCallFromPush');
     logger.error('failed to fetch call from push notification', e);
     return;
   }
@@ -117,24 +112,30 @@ export const processCallFromPush = async (
       if (pushConfig.publishOptions) {
         callFromPush.updatePublishOptions(pushConfig.publishOptions);
       }
-      videoLoggerSystem
-        .getLogger('processCallFromPush')
-        .debug(
-          `joining call from push notification with callCid: ${callFromPush.cid}`,
+      logger.debug(
+        `joining call from push notification with callCid: ${callFromPush.cid}`,
+      );
+      const callingState = callFromPush.state.callingState;
+      if (
+        callingState !== CallingState.RINGING &&
+        callingState !== CallingState.IDLE
+      ) {
+        logger.debug(
+          `skipping join call as it is not in ringing or idle state from push notification. callCid: ${callFromPush.cid}`,
         );
+        return;
+      }
+
       await callFromPush.join();
     } else if (action === 'decline') {
       const canReject =
         callFromPush.state.callingState === CallingState.RINGING;
-      videoLoggerSystem
-        .getLogger('processCallFromPush')
-        .debug(
-          `declining call from push notification with callCid: ${callFromPush.cid} reject: ${canReject}`,
-        );
+      logger.debug(
+        `declining call from push notification with callCid: ${callFromPush.cid} reject: ${canReject}`,
+      );
       await callFromPush.leave({ reject: canReject, reason: 'decline' });
     }
   } catch (e) {
-    const logger = videoLoggerSystem.getLogger('processCallFromPush');
     logger.warn(`failed to process ${action} call from push notification`, e);
   }
 };
@@ -191,3 +192,21 @@ export const clearPushWSEventSubscriptions = (call_cid: string) => {
 export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
   current: true,
 };
+
+export const canListenToWS = () =>
+  canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
+
+export const shouldCallBeClosed = (
+  call: Call,
+  pushData: { [key: string]: string | object },
+) => {
+  const created_by_id = pushData?.created_by_id as string;
+  const receiver_id = pushData?.receiver_id as string;
+
+  const { mustEndCall, endCallReason } = shouldCallBeEnded(
+    call,
+    created_by_id,
+    receiver_id,
+  );
+  return { mustEndCall, endCallReason };
+};

package/src/utils/push/ios.ts

@@ -62,12 +62,7 @@ export const oniOSExpoNotificationEvent = (event: ExpoNotification) => {
   }
 };
 
-export const oniOSNotifeeEvent = ({
-  event,
-}: {
-  event: Event;
-  isBackground: boolean;
-}) => {
+export const oniOSNotifeeEvent = ({ event }: { event: Event }) => {
   if (Platform.OS !== 'ios') return;
   const pushConfig = StreamVideoRN.getConfig().push;
   const { type, detail } = event;

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

@@ -0,0 +1,90 @@
+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.subtitleTransformer) {
+      androidOptions.subtitleTransformer =
+        pushConfig.android.subtitleTransformer;
+    }
+  }
+
+  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;
+}

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

@@ -1,9 +1,8 @@
 export * from './expoNotifications';
 export * from './firebaseMessaging';
 export * from './iosPushNotification';
-export * from './voipPushNotification';
-export * from './callkeep';
 export * from './notifee';
+export * from './callingx';
 
 /*
     NOTE: must keep each libs in different files

package/src/utils/push/libs/notifee/index.ts

@@ -1,6 +1,4 @@
-import { PermissionsAndroid } from 'react-native';
 import { lib, type Type } from './lib';
-import { videoLoggerSystem } from '@stream-io/video-client';
 
 export type NotifeeLib = Type;
 
@@ -36,34 +34,9 @@ export function getNotifeeLibThrowIfNotInstalledForPush() {
 }
 
 export function getNotifeeLibNoThrowForKeepCallAlive() {
-  if (!lib) {
-    const logger = videoLoggerSystem.getLogger('getNotifeeLibNoThrow');
-    logger.info(
-      `${'@notifee/react-native library not installed. It is required to keep call alive in the background for Android. '}${INSTALLATION_INSTRUCTION}`,
-    );
-  }
   return lib;
 }
 
-export async function getKeepCallAliveForegroundServiceTypes() {
-  const types: AndroidForegroundServiceType[] = [
-    AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK,
-  ];
-  const hasCameraPermission = await PermissionsAndroid.check(
-    PermissionsAndroid.PERMISSIONS.CAMERA!,
-  );
-  if (hasCameraPermission) {
-    types.push(AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_CAMERA);
-  }
-  const hasMicrophonePermission = await PermissionsAndroid.check(
-    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO!,
-  );
-  if (hasMicrophonePermission) {
-    types.push(AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_MICROPHONE);
-  }
-  return types;
-}
-
 export function getIncomingCallForegroundServiceTypes() {
   const types: AndroidForegroundServiceType[] = [
     AndroidForegroundServiceType.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,

package/src/utils/push/setupCallingExpEvents.ts

@@ -0,0 +1,130 @@
+import { videoLoggerSystem } from '@stream-io/video-client';
+import type { StreamVideoConfig } from '../StreamVideoRN/types';
+import {
+  clearPushWSEventSubscriptions,
+  processCallFromPushInBackground,
+} from './internal/utils';
+import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
+import { resolvePendingAudioSession } from '../internal/callingx/audioSessionPromise';
+import {
+  getCallingxLib,
+  type EventData,
+  type EventParams,
+} from './libs/callingx';
+import { Platform } from 'react-native';
+
+type PushConfig = NonNullable<StreamVideoConfig['push']>;
+
+const logger = videoLoggerSystem.getLogger('callingx');
+
+/**
+ * Sets up callingx event listeners for handling call actions from the native calling UI.
+ */
+export function setupCallingExpEvents(pushConfig: NonNullable<PushConfig>) {
+  const hasPushProvider =
+    (Platform.OS === 'android' && pushConfig.android?.pushProviderName) ||
+    (Platform.OS === 'ios' && pushConfig.ios?.pushProviderName);
+
+  if (!hasPushProvider) {
+    return;
+  }
+
+  const callingx = getCallingxLib();
+
+  const { remove: removeAnswerCall } = callingx.addEventListener(
+    'answerCall',
+    (params) => {
+      onAcceptCall(pushConfig)(params).catch((err) => {
+        logger.error('Failed to process answerCall event', err);
+      });
+    },
+  );
+
+  const { remove: removeEndCall } = callingx.addEventListener(
+    'endCall',
+    (params) => {
+      onEndCall(pushConfig)(params).catch((err) => {
+        logger.error('Failed to process endCall event', err);
+      });
+    },
+  );
+
+  const { remove: removeDidActivateAudioSession } = callingx.addEventListener(
+    'didActivateAudioSession',
+    onDidActivateAudioSession,
+  );
+  const { remove: removeDidDeactivateAudioSession } = callingx.addEventListener(
+    'didDeactivateAudioSession',
+    onDidDeactivateAudioSession,
+  );
+
+  //NOTE: until getInitialEvents invocation, events are delayed and won't be sent to event listeners, this is a way to make sure none of required events are missed
+  //in most cases there will be no delayed answers or ends, but it we don't want to miss any of them
+  const events = callingx.getInitialEvents();
+  events.forEach((event: EventData) => {
+    const { eventName, params } = event;
+    if (eventName === 'answerCall') {
+      logger.debug(`answerCall delayed event callId: ${params?.callId}`);
+      onAcceptCall(pushConfig)(params as EventParams['answerCall']).catch(
+        (err) => {
+          logger.error('Failed to process delayed answerCall event', err);
+        },
+      );
+    } else if (eventName === 'endCall') {
+      logger.debug(`endCall delayed event callId: ${params?.callId}`);
+      onEndCall(pushConfig)(params as EventParams['endCall']).catch((err) => {
+        logger.error('Failed to process delayed endCall event', err);
+      });
+    } else if (eventName === 'didActivateAudioSession') {
+      onDidActivateAudioSession();
+    } else if (eventName === 'didDeactivateAudioSession') {
+      onDidDeactivateAudioSession();
+    }
+  });
+
+  setPushLogoutCallback(async () => {
+    removeAnswerCall();
+    removeEndCall();
+    removeDidActivateAudioSession();
+    removeDidDeactivateAudioSession();
+  });
+}
+
+const onDidActivateAudioSession = () => {
+  logger.debug('callingExpDidActivateAudioSession');
+  resolvePendingAudioSession();
+};
+
+const onDidDeactivateAudioSession = () => {
+  logger.debug('callingExpDidDeactivateAudioSession');
+};
+
+const onAcceptCall =
+  (pushConfig: PushConfig) =>
+  async ({ callId: call_cid, source }: EventParams['answerCall']) => {
+    logger.debug(`onAcceptCall event callId: ${call_cid} source: ${source}`);
+
+    if (source === 'app' || !call_cid) {
+      //we only need to process the call if the call was answered from the system
+      return;
+    }
+
+    clearPushWSEventSubscriptions(call_cid);
+    // to process the call in the app
+    await processCallFromPushInBackground(pushConfig, call_cid, 'accept');
+  };
+
+const onEndCall =
+  (pushConfig: PushConfig) =>
+  async ({ callId: call_cid, source }: EventParams['endCall']) => {
+    logger.debug(`onEndCall event callId: ${call_cid} source: ${source}`);
+
+    if (source === 'app' || !call_cid) {
+      //we only need to process the call if the call was rejected from the system
+      return;
+    }
+
+    clearPushWSEventSubscriptions(call_cid);
+
+    await processCallFromPushInBackground(pushConfig, call_cid, 'decline');
+  };

package/src/utils/push/setupIosVoipPushEvents.ts

@@ -1,10 +1,11 @@
-import { getVoipPushNotificationLib } from './libs';
+// import { getVoipPushNotificationLib } from './libs';
 
 import { Platform } from 'react-native';
 import { onVoipNotificationReceived } from './internal/ios';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
 import { StreamVideoConfig } from '../StreamVideoRN/types';
 import { videoLoggerSystem } from '@stream-io/video-client';
+import { getCallingxLib } from './libs';
 
 export function setupIosVoipPushEvents(
   pushConfig: NonNullable<StreamVideoConfig['push']>,
@@ -20,16 +21,19 @@ export function setupIosVoipPushEvents(
     );
     return;
   }
-  const voipPushNotification = getVoipPushNotificationLib();
 
-  logger.debug('notification event listener added');
-  voipPushNotification.addEventListener('notification', (notification) => {
-    onVoipNotificationReceived(notification, pushConfig);
-  });
+  const callingx = getCallingxLib();
+  const voipNotificationReceivedListener = callingx.addEventListener(
+    'voipNotificationReceived',
+    (params) => {
+      onVoipNotificationReceived(params, pushConfig);
+    },
+  );
+
   setPushLogoutCallback(async () => {
     videoLoggerSystem
       .getLogger('setPushLogoutCallback')
       .debug('notification event listener removed');
-    voipPushNotification.removeEventListener('notification');
+    voipNotificationReceivedListener.remove();
   });
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.29.3';
+export const version = '1.29.4-beta.0';