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

package/src/utils/push/android.ts

@@ -1,16 +1,8 @@
-import {
-  CallingState,
-  StreamVideoClient,
-  videoLoggerSystem,
-} from '@stream-io/video-client';
-import { AppState, Platform } from 'react-native';
+import { StreamVideoClient, videoLoggerSystem } from '@stream-io/video-client';
+import { Platform } from 'react-native';
 import type { StreamVideoConfig } from '../StreamVideoRN/types';
-import { type FirebaseMessagingTypes, getFirebaseMessagingLib } from './libs';
-import { pushUnsubscriptionCallbacks } from './internal/constants';
-import { canListenToWS, shouldCallBeClosed } from './internal/utils';
+import { getFirebaseMessagingLib } from './libs';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
-import { StreamVideoRN } from '../StreamVideoRN';
-import { getCallingxLib } from './libs/callingx';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
@@ -66,234 +58,17 @@ export async function initAndroidPushToken(
   await setDeviceToken(token);
 }
 
+let firebaseDataHandlerDeprecationLogged = false;
 /**
- * Creates notification from the push message data.
- * For Ringing and Non-Ringing calls.
+ * @deprecated Ring notifications are now handled by the SDK internally. This method is a no-op;
+ * you can safely remove `firebaseDataHandler(...)` wiring from your Firebase messaging handlers.
  */
-
-export const firebaseDataHandler = async (
-  data: FirebaseMessagingTypes.RemoteMessage['data'],
-) => {
-  /* Example data from firebase
-    "message": {
-        "data": {
-          call_cid: 'audio_room:dcc1638c-e90d-4dcb-bf3b-8fa7767bfbb0',
-          call_display_name: '',
-          created_by_display_name: 'tommaso',
-          created_by_id: 'tommaso-03dcddb7-e9e2-42ec-b2f3-5043aac666ee',
-          receiver_id: 'martin-21824f17-319b-401b-a61b-fcab646f0d3f',
-          sender: 'stream.video',
-          type: 'call.live_started',
-          version: 'v2'
-        },
-        // other stuff
-    }
-  */
-  if (Platform.OS !== 'android') return;
-
-  const logger = videoLoggerSystem.getLogger('firebaseDataHandler');
-  const pushConfig = StreamVideoRN.getConfig().push;
-  if (!pushConfig || !data || data.sender !== 'stream.video') {
-    return;
-  }
-
-  if (data.type === 'call.ring') {
-    const call_cid = data.call_cid as string;
-    const callingx = getCallingxLib();
-
-    const client = await pushConfig.createStreamVideoClient();
-    if (!client) {
-      logger.debug(
-        `video client not found, skipping the call.ring notification`,
-      );
-      await callingx.stopService();
-      return;
-    }
-
-    const asForegroundService = canListenToWS();
-
-    if (asForegroundService) {
-      // Listen to call events from WS with headless task, bound to call service.
-      // By this moment the call service is already running, so we can acquire the background task.
-      const backgroundTaskOwner = `push:${call_cid}`;
-      await callingx.acquireBackgroundTask(backgroundTaskOwner).catch((e) => {
-        logger.error(
-          `Failed to acquire background task for callCid: ${call_cid} error: ${e}`,
-        );
-      });
-
-      const finishBackgroundTask = () => {
-        callingx.log(
-          `Finishing background task for callCid: ${call_cid}`,
-          'debug',
-        );
-        callingx.releaseBackgroundTask(backgroundTaskOwner);
-      };
-
-      (async () => {
-        try {
-          const _client = await pushConfig.createStreamVideoClient();
-          if (!_client) {
-            logger.debug(
-              `Closing fg service as there is no client to create from push config`,
-            );
-            finishBackgroundTask();
-            return;
-          }
-
-          const callFromPush = await _client.onRingingCall(call_cid);
-          const { mustEndCall, endCallReason } = shouldCallBeClosed(
-            callFromPush,
-            data,
-          );
-          if (mustEndCall) {
-            logger.debug(
-              `Closing fg service callCid: ${call_cid} endCallReason: ${endCallReason}`,
-            );
-
-            callingx.log(
-              `Ending call with callCid: ${call_cid} endCallReason: ${endCallReason}`,
-              'debug',
-            );
-            callingx.endCallWithReason(call_cid, endCallReason);
-            callFromPush.leave({ reject: false }).catch((error) => {
-              logger.error(
-                `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
-              );
-            });
-            finishBackgroundTask();
-            return;
-          }
-
-          const unsubscribeFunctions: Array<() => void> = [];
-          // check if service needs to be closed if accept/decline event was done on another device
-          const unsubscribe = callFromPush.on('all', (event) => {
-            const _canListenToWS = canListenToWS();
-            if (!_canListenToWS) {
-              logger.debug(
-                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
-                { event },
-              );
-              unsubscribeFunctions.forEach((fn) => fn());
-
-              finishBackgroundTask();
-              return;
-            }
-
-            const {
-              mustEndCall: mustEndCallFromEvent,
-              endCallReason: endCallReasonFromEvent,
-            } = shouldCallBeClosed(callFromPush, data);
-            if (mustEndCallFromEvent) {
-              logger.debug(
-                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed`,
-                { event },
-              );
-              unsubscribeFunctions.forEach((fn) => fn());
-
-              callingx.endCallWithReason(call_cid, endCallReasonFromEvent);
-              finishBackgroundTask();
-            }
-          });
-
-          // check if service needs to be closed if call was left
-          const stateSubscription = callFromPush.state.callingState$.subscribe(
-            (callingState) => {
-              if (
-                callingState === CallingState.IDLE ||
-                callingState === CallingState.LEFT
-              ) {
-                logger.debug(
-                  `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
-                );
-                unsubscribeFunctions.forEach((fn) => fn());
-                callingx.log(
-                  `Ending call with callCid: ${call_cid} callingState: ${callingState}`,
-                  'debug',
-                );
-                finishBackgroundTask();
-              }
-            },
-          );
-
-          const endCallSubscription = callingx.addEventListener(
-            'endCall',
-            async ({ callId }: { callId: string }) => {
-              unsubscribeFunctions.forEach((fn) => fn());
-              try {
-                await callFromPush.leave({
-                  reject:
-                    callFromPush.state.callingState === CallingState.RINGING,
-                  reason: 'decline',
-                });
-              } catch (error) {
-                logger.error(
-                  `Failed to leave call with callCid: ${call_cid} error: ${error}`,
-                );
-              } finally {
-                callingx.log(
-                  `Ending call with callCid: ${call_cid} callId: ${callId}`,
-                  'debug',
-                );
-                finishBackgroundTask();
-              }
-            },
-          );
-
-          //stop background task when app comes to foreground
-          const appStateSubscription = AppState.addEventListener(
-            'change',
-            (nextAppState) => {
-              const _canListenToWS = canListenToWS();
-              callingx.log(
-                `AppState changed to: ${nextAppState} for callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
-                'debug',
-              );
-              if (!_canListenToWS) {
-                unsubscribeFunctions.forEach((fn) => fn());
-                finishBackgroundTask();
-                return;
-              }
-            },
-          );
-
-          unsubscribeFunctions.push(unsubscribe);
-          unsubscribeFunctions.push(() => stateSubscription.unsubscribe());
-          unsubscribeFunctions.push(() => endCallSubscription.remove());
-          unsubscribeFunctions.push(() => appStateSubscription.remove());
-          pushUnsubscriptionCallbacks.get(call_cid)?.forEach((cb) => cb());
-          pushUnsubscriptionCallbacks.set(call_cid, unsubscribeFunctions);
-        } catch (error) {
-          callingx.log(
-            `Failed to start background task with callCid: ${call_cid} error: ${error}`,
-            'error',
-          );
-          finishBackgroundTask();
-        }
-      })();
-    }
-
-    if (asForegroundService) {
-      // no need to check if call has be closed as that will be handled by the fg service
-      return;
-    }
-
-    const callFromPush = await client.onRingingCall(call_cid);
-
-    const { mustEndCall, endCallReason } = shouldCallBeClosed(
-      callFromPush,
-      data,
+export const firebaseDataHandler = async (data?: any) => {
+  void data;
+  if (!firebaseDataHandlerDeprecationLogged) {
+    firebaseDataHandlerDeprecationLogged = true;
+    console.warn(
+      '[@stream-io/video-react-native-sdk] `firebaseDataHandler` is deprecated. Ring notifications are now handled by the SDK internally — you can remove calls to it from your Firebase messaging handlers.',
     );
-    if (mustEndCall) {
-      logger.debug(
-        `Removing incoming call notification immediately with callCid: ${call_cid} as it should be closed`,
-      );
-      callingx.endCallWithReason(call_cid, endCallReason);
-      callFromPush.leave({ reject: false }).catch((error) => {
-        logger.error(
-          `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
-        );
-      });
-    }
   }
 };

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

@@ -0,0 +1,273 @@
+import {
+  AllCallEvents,
+  AllClientEventTypes,
+  CallingState,
+  StreamVideoClient,
+} from '@stream-io/video-client';
+import { AppState, Platform } from 'react-native';
+import {
+  type FirebaseRemoteMessage,
+  getCallingxLib,
+  getCallingxLibIfAvailable,
+} from '../libs';
+import { StreamVideoRN } from '../../StreamVideoRN';
+import { pushUnsubscriptionCallbacks } from './constants';
+import { canListenToWS, shouldCallBeClosed } from './utils';
+
+/**
+ * Handles a Stream Video `call.ring` push payload: connects the WS to watch the ringing call
+ * and auto-dismisses it if it has already ended/been handled elsewhere. Non-ringing types are
+ * ignored (their display is app responsibility). Android-only; a no-op on other platforms.
+ */
+export const onRingNotificationReceived = async (
+  data: FirebaseRemoteMessage['data'],
+) => {
+  /* Example data from firebase
+    "message": {
+        "data": {
+          call_cid: 'audio_room:dcc1638c-e90d-4dcb-bf3b-8fa7767bfbb0',
+          call_display_name: '',
+          created_by_display_name: 'tommaso',
+          created_by_id: 'tommaso-03dcddb7-e9e2-42ec-b2f3-5043aac666ee',
+          receiver_id: 'martin-21824f17-319b-401b-a61b-fcab646f0d3f',
+          sender: 'stream.video',
+          type: 'call.live_started',
+          version: 'v2'
+        },
+        // other stuff
+    }
+  */
+  if (Platform.OS !== 'android') return;
+
+  const nativeLog = (
+    message: string,
+    level: 'debug' | 'info' | 'warn' | 'error' = 'debug',
+  ) =>
+    getCallingxLibIfAvailable()?.log(
+      `[callingx - onRingNotificationReceived]: ${message}`,
+      level,
+    );
+
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (
+    !pushConfig ||
+    !data ||
+    data.sender !== 'stream.video' ||
+    data.type !== 'call.ring'
+  ) {
+    return;
+  }
+
+  const call_cid = data.call_cid as string;
+  const callingx = getCallingxLib();
+
+  if (pushUnsubscriptionCallbacks.has(call_cid)) {
+    nativeLog(
+      `call_cid ${call_cid} is already being watched, skipping the duplicate call.ring notification`,
+    );
+    return;
+  }
+
+  const asForegroundService = canListenToWS();
+  const backgroundTaskOwner = `push:${call_cid}`;
+  nativeLog(
+    `call.ring for callCid: ${call_cid} asForegroundService=${asForegroundService}`,
+  );
+
+  const finishBackgroundTask = () => {
+    nativeLog(`Finishing background task for callCid: ${call_cid}`);
+    callingx.releaseBackgroundTask(backgroundTaskOwner);
+  };
+
+  /**
+   * Gives up on this push: dismisses the call the native push path already displayed, then asks
+   * the call service to stop. `stopService` is only a request — it no-ops while any other call is
+   * registered or being registered — so this call must be ended explicitly rather than relying on
+   * the service teardown to wipe it.
+   */
+  const abandonPush = async () => {
+    if (asForegroundService) {
+      finishBackgroundTask();
+    }
+    // Each step is contained on its own: failing to dismiss the call must not skip the stop
+    // request, and neither may skip the unsubscription cleanup — a stale entry makes every later
+    // push for this cid look like a duplicate and get discarded.
+    try {
+      await callingx.endCallWithReason(call_cid, 'error');
+    } catch (error) {
+      nativeLog(`Failed to end call ${call_cid}: ${error}`, 'error');
+    }
+    try {
+      await callingx.stopService();
+    } catch (error) {
+      nativeLog(
+        `Failed to stop the call service for ${call_cid}: ${error}`,
+        'error',
+      );
+    }
+    pushUnsubscriptionCallbacks.delete(call_cid);
+  };
+
+  if (asForegroundService) {
+    // initialize the callback array immediately to avoid race condition
+    pushUnsubscriptionCallbacks.set(call_cid, []);
+    // The owner is added synchronously inside acquireBackgroundTask (before its own await), so it
+    // is registered immediately even though we don't await the returned promise here.
+    nativeLog(`acquiring background task for callCid: ${call_cid}`);
+    callingx.acquireBackgroundTask(backgroundTaskOwner).catch((e) => {
+      nativeLog(
+        `Failed to acquire background task for callCid: ${call_cid} error: ${e}`,
+        'error',
+      );
+    });
+  }
+
+  let client: StreamVideoClient | undefined;
+  try {
+    client = await pushConfig.createStreamVideoClient();
+    if (!client) {
+      nativeLog(`video client not found, skipping the call.ring notification`);
+      await abandonPush();
+      return;
+    }
+  } catch (error) {
+    //we need to release the background task and stop the service to avoid stale owner
+    nativeLog(`Failed to create video client: ${error}`, 'error');
+    await abandonPush();
+    return;
+  }
+
+  if (asForegroundService) {
+    // Listen to call events from WS with the keep-alive headless task, bound to the call service.
+    (async () => {
+      try {
+        nativeLog(`onRingingCall (fg service) for callCid: ${call_cid}`);
+        const callFromPush = await client.onRingingCall(call_cid);
+        const { mustEndCall, endCallReason } = shouldCallBeClosed(
+          callFromPush,
+          data,
+        );
+        if (mustEndCall) {
+          nativeLog(
+            `Closing fg service callCid: ${call_cid} endCallReason: ${endCallReason}`,
+          );
+          callingx.endCallWithReason(call_cid, endCallReason);
+          callFromPush.leave({ reject: false }).catch((error) => {
+            nativeLog(
+              `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
+              'error',
+            );
+          });
+          finishBackgroundTask();
+          pushUnsubscriptionCallbacks.delete(call_cid);
+          return;
+        }
+
+        // prevent subscriptions in case of call being left and subscriptions being already cleared
+        const unsubscribeFunctions = pushUnsubscriptionCallbacks.get(call_cid);
+        if (!unsubscribeFunctions) {
+          nativeLog(
+            `ring cancelled during onRingingCall for callCid: ${call_cid}, releasing background task`,
+          );
+          finishBackgroundTask();
+          return;
+        }
+        nativeLog(`watching WS for ringing callCid: ${call_cid}`);
+        // check if service needs to be closed if accept/decline event was done on another device
+        const unsubscribe = callFromPush.on(
+          'all',
+          (event: AllCallEvents[AllClientEventTypes]) => {
+            const _canListenToWS = canListenToWS();
+            if (!_canListenToWS) {
+              nativeLog(
+                `Closing fg service from event ${event.type} callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+              );
+              unsubscribeFunctions.forEach((fn) => fn());
+              return;
+            }
+
+            const {
+              mustEndCall: mustEndCallFromEvent,
+              endCallReason: endCallReasonFromEvent,
+            } = shouldCallBeClosed(callFromPush, data);
+            if (mustEndCallFromEvent) {
+              nativeLog(
+                `Closing fg service from event ${event.type} callCid: ${call_cid} shouldCallBeClosed`,
+              );
+              callingx.endCallWithReason(call_cid, endCallReasonFromEvent);
+              unsubscribeFunctions.forEach((fn) => fn());
+            }
+          },
+        );
+
+        // check if service needs to be closed if call was left
+        const stateSubscription = callFromPush.state.callingState$.subscribe(
+          (callingState) => {
+            if (
+              callingState === CallingState.IDLE ||
+              callingState === CallingState.LEFT
+            ) {
+              nativeLog(
+                `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
+              );
+              unsubscribeFunctions.forEach((fn) => fn());
+            }
+          },
+        );
+
+        //stop background task when app comes to foreground
+        const appStateSubscription = AppState.addEventListener(
+          'change',
+          (nextAppState) => {
+            const _canListenToWS = canListenToWS();
+            nativeLog(
+              `AppState changed to: ${nextAppState} for callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+            );
+            if (!_canListenToWS) {
+              unsubscribeFunctions.forEach((fn) => fn());
+              return;
+            }
+          },
+        );
+
+        unsubscribeFunctions.push(unsubscribe);
+        unsubscribeFunctions.push(() => stateSubscription.unsubscribe());
+        unsubscribeFunctions.push(() => appStateSubscription.remove());
+        unsubscribeFunctions.push(finishBackgroundTask);
+        unsubscribeFunctions.push(() =>
+          pushUnsubscriptionCallbacks.delete(call_cid),
+        );
+        nativeLog(`WS subscriptions registered for callCid: ${call_cid}`);
+      } catch (error) {
+        nativeLog(
+          `Failed to start background task with callCid: ${call_cid} error: ${error}`,
+          'error',
+        );
+        pushUnsubscriptionCallbacks.delete(call_cid);
+        finishBackgroundTask();
+      }
+    })();
+  }
+
+  if (asForegroundService) {
+    // no need to check if call has be closed as that will be handled by the fg service
+    return;
+  }
+
+  nativeLog(`onRingingCall (foreground) for callCid: ${call_cid}`);
+  const callFromPush = await client.onRingingCall(call_cid);
+
+  const { mustEndCall, endCallReason } = shouldCallBeClosed(callFromPush, data);
+  if (mustEndCall) {
+    nativeLog(
+      `Removing incoming call notification immediately with callCid: ${call_cid} as it should be closed`,
+    );
+    callingx.endCallWithReason(call_cid, endCallReason);
+    callFromPush.leave({ reject: false }).catch((error) => {
+      nativeLog(
+        `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
+        'error',
+      );
+    });
+  }
+};

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

@@ -1,12 +1,13 @@
-import { lib, type Type } from './lib';
-
-export type { FirebaseMessagingTypes } from '@react-native-firebase/messaging';
-export type FirebaseMessagingType = Type;
+import { lib, type MessagingModule } from './lib';
 
 const INSTALLATION_INSTRUCTION =
   'Please see https://rnfirebase.io/messaging/usage#installation for installation instructions';
 
-export function getFirebaseMessagingLib(): FirebaseMessagingType {
+export type FirebaseRemoteMessage = NonNullable<
+  Awaited<ReturnType<MessagingModule['getInitialNotification']>>
+>;
+
+function getFirebaseMessagingModule() {
   if (!lib) {
     throw Error(
       '@react-native-firebase/messaging is not installed. ' +
@@ -15,3 +16,13 @@ export function getFirebaseMessagingLib(): FirebaseMessagingType {
   }
   return lib;
 }
+
+export function getFirebaseMessagingLib() {
+  const messagingModule = getFirebaseMessagingModule();
+  const messaging = messagingModule.getMessaging();
+  return () => ({
+    getToken: () => messagingModule.getToken(messaging),
+    onTokenRefresh: (listener: (token: string) => void) =>
+      messagingModule.onTokenRefresh(messaging, listener),
+  });
+}

package/src/utils/push/libs/firebaseMessaging/lib.ts

@@ -1,9 +1,9 @@
-export type Type = typeof import('@react-native-firebase/messaging').default;
+export type MessagingModule = typeof import('@react-native-firebase/messaging');
 
-let lib: Type | undefined;
+let lib: MessagingModule | undefined;
 
 try {
-  lib = require('@react-native-firebase/messaging').default;
+  lib = require('@react-native-firebase/messaging');
 } catch {}
 
 export { lib };

package/src/utils/push/setupAndroidPushEvents.ts

@@ -0,0 +1,25 @@
+import { Platform } from 'react-native';
+import { videoLoggerSystem } from '@stream-io/video-client';
+import { StreamVideoConfig } from '../StreamVideoRN/types';
+import { getCallingxLib } from './libs';
+import { onRingNotificationReceived } from './internal/android';
+
+export function setupAndroidPushEvents(
+  pushConfig: NonNullable<StreamVideoConfig['push']>,
+) {
+  const logger = videoLoggerSystem.getLogger('setupAndroidPushEvents');
+  if (Platform.OS !== 'android' || !pushConfig.android?.pushProviderName) {
+    logger.debug(
+      `setupAndroidPushEvents skipped: platform=${Platform.OS} pushProviderName=${pushConfig.android?.pushProviderName}`,
+    );
+    return;
+  }
+
+  const callingx = getCallingxLib();
+  callingx.addEventListener('ringCallPushReceived', (params) => {
+    logger.debug(`ringCallPushReceived event call_cid: ${params?.call_cid}`);
+    onRingNotificationReceived(params).catch((error) => {
+      logger.error(`Error in onRingNotificationReceived: ${error}`);
+    });
+  });
+}

package/src/utils/push/setupCallingExpEvents.ts

@@ -14,6 +14,7 @@ import {
   type EventParams,
 } from './libs/callingx';
 import { Platform } from 'react-native';
+import { onRingNotificationReceived } from './internal/android';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
@@ -62,11 +63,10 @@ export function setupCallingExpEvents(pushConfig: NonNullable<PushConfig>) {
   const events = callingx.getInitialEvents();
   events.forEach((event: EventData) => {
     const { eventName, params } = event;
+    logger.debug(`${eventName} delayed event`);
     if (eventName === 'answerCall') {
-      logger.debug(`answerCall delayed event callId: ${params?.callId}`);
       onAcceptCall(pushConfig)(params as EventParams['answerCall']);
     } else if (eventName === 'endCall') {
-      logger.debug(`endCall delayed event callId: ${params?.callId}`);
       onEndCall(pushConfig)(params as EventParams['endCall']);
     } else if (eventName === 'didActivateAudioSession') {
       onDidActivateAudioSession();
@@ -74,6 +74,10 @@ export function setupCallingExpEvents(pushConfig: NonNullable<PushConfig>) {
       onDidDeactivateAudioSession();
     } else if (eventName === 'providerReset') {
       onProviderReset(pushConfig)(params as EventParams['providerReset']);
+    } else if (eventName === 'ringCallPushReceived') {
+      onRingNotificationReceived(params).catch((error) => {
+        logger.error(`Error in onRingNotificationReceived: ${error}`);
+      });
     }
   });
 }
@@ -128,7 +132,6 @@ const onAcceptCall =
 
     const callingx = getCallingxLib();
     clearPushWSEventSubscriptions(call_cid);
-
     processCallFromPushInBackground(
       pushConfig,
       call_cid,

package/src/utils/push/setupIosVoipPushEvents.ts

@@ -9,20 +9,21 @@ import { getCallingxLib } from './libs';
 export function setupIosVoipPushEvents(
   pushConfig: NonNullable<StreamVideoConfig['push']>,
 ) {
-  if (Platform.OS !== 'ios' || !pushConfig.ios?.pushProviderName) {
-    return;
-  }
   const logger = videoLoggerSystem.getLogger('setupIosVoipPushEvents');
-  if (!pushConfig.ios.pushProviderName) {
-    // TODO: remove this check and find a better way once we have telecom integration for android
+  if (Platform.OS !== 'ios' || !pushConfig.ios?.pushProviderName) {
     logger.debug(
-      'ios pushProviderName is not defined, so skipping the setupIosVoipPushEvents',
+      `setupIosVoipPushEvents skipped: platform=${Platform.OS} pushProviderName=${pushConfig.ios?.pushProviderName}`,
     );
     return;
   }
 
   const callingx = getCallingxLib();
   callingx.addEventListener('voipNotificationReceived', (params) => {
-    onVoipNotificationReceived(params, pushConfig);
+    logger.debug(
+      `voipNotificationReceived event call_cid: ${params?.stream?.call_cid}`,
+    );
+    onVoipNotificationReceived(params, pushConfig).catch((error) => {
+      logger.error(`Error in onVoipNotificationReceived: ${error}`);
+    });
   });
 }