@stream-io/video-react-native-sdk 1.9.23 → 1.9.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.9.23",
+  "version": "1.9.24",
   "packageManager": "yarn@3.2.4",
   "main": "dist/commonjs/index.js",
   "module": "dist/module/index.js",
@@ -60,7 +60,7 @@
     "@react-native-community/push-notification-ios": ">=1.11.0",
     "@react-native-firebase/app": ">=17.5.0",
     "@react-native-firebase/messaging": ">=17.5.0",
-    "@stream-io/react-native-webrtc": ">=125.0.3",
+    "@stream-io/react-native-webrtc": ">=125.0.4",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
     "expo-build-properties": "*",
@@ -121,7 +121,7 @@
     "@react-native-firebase/app": "19.2.2",
     "@react-native-firebase/messaging": "19.2.2",
     "@react-native/eslint-config": "^0.74.84",
-    "@stream-io/react-native-webrtc": "125.0.3",
+    "@stream-io/react-native-webrtc": "^125.0.4",
     "@stream-io/video-filters-react-native": "^0.2.6",
     "@testing-library/jest-native": "^5.4.2",
     "@testing-library/react-native": "^12.1.2",

package/src/hooks/push/useIosCallKeepEventsSetupEffect.ts

@@ -3,7 +3,7 @@ import {
   voipCallkeepCallOnForegroundMap$,
   voipPushNotificationCallCId$,
 } from '../../utils/push/internal/rxSubjects';
-import { RxUtils } from '@stream-io/video-client';
+import { getLogger, RxUtils } from '@stream-io/video-client';
 import { getCallKeepLib } from '../../utils/push/libs';
 import { StreamVideoRN } from '../../utils/StreamVideoRN';
 import type { StreamVideoConfig } from '../../utils/StreamVideoRN/types';
@@ -19,6 +19,8 @@ import { Platform } from 'react-native';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
+const logger = getLogger(['useIosCallKeepEventsSetupEffect']);
+
 /**
  * This hook is used to listen to callkeep events and do the necessary actions
  */
@@ -34,6 +36,7 @@ export const useIosCallKeepEventsSetupEffect = () => {
       'answerCall',
       ({ callUUID }) => {
         const call_cid = RxUtils.getCurrentValue(voipPushNotificationCallCId$);
+        logger('debug', `answerCall event with call_cid: ${call_cid}`);
         iosCallkeepAcceptCall(call_cid, callUUID);
       }
     );
@@ -41,6 +44,7 @@ export const useIosCallKeepEventsSetupEffect = () => {
       'endCall',
       ({ callUUID }) => {
         const call_cid = RxUtils.getCurrentValue(voipPushNotificationCallCId$);
+        logger('debug', `endCall event with call_cid: ${call_cid}`);
         iosCallkeepRejectCall(call_cid, callUUID, pushConfig);
       }
     );
@@ -55,6 +59,10 @@ export const useIosCallKeepEventsSetupEffect = () => {
         if (!call_cid) {
           return;
         }
+        logger(
+          'debug',
+          `didDisplayIncomingCall event with call_cid: ${call_cid}`
+        );
         voipCallkeepCallOnForegroundMap$.next({
           uuid: callUUID,
           cid: call_cid,

package/src/hooks/push/useIosCallkeepWithCallingStateEffect.ts

@@ -1,4 +1,4 @@
-import { CallingState, RxUtils } from '@stream-io/video-client';
+import { CallingState, getLogger, RxUtils } from '@stream-io/video-client';
 import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
 import { Platform } from 'react-native';
 import { useEffect, useState } from 'react';
@@ -35,6 +35,8 @@ const unsubscribeCallkeepEvents = (activeCallCid: string | undefined) => {
   }
 };
 
+const logger = getLogger(['useIosCallkeepWithCallingStateEffect']);
+
 /**
  * This hook is used to inform the callkeep library that the call has been joined or ended.
  */
@@ -57,6 +59,10 @@ export const useIosCallkeepWithCallingStateEffect = () => {
       const callkeep = getCallKeepLib();
       // if the component is unmounted and the callID was not reported to callkeep, then report it now
       if (acceptedForegroundCallkeepMap) {
+        logger(
+          'debug',
+          `Ending call in callkeep: ${acceptedForegroundCallkeepMap.cid}, reason: component unmounted and call was present in acceptedForegroundCallkeepMap`
+        );
         unsubscribeCallkeepEvents(acceptedForegroundCallkeepMap.cid);
         // this call should be ended in callkeep
         callkeep.endCall(acceptedForegroundCallkeepMap.uuid);
@@ -80,11 +86,19 @@ export const useIosCallkeepWithCallingStateEffect = () => {
       );
       const callkeep = getCallKeepLib();
       if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+        logger(
+          'debug',
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in nativeDialerAcceptedCallMap`
+        );
         unsubscribeCallkeepEvents(activeCallCid);
         callkeep.endCall(nativeDialerAcceptedCallMap.uuid);
         // no need to keep this reference anymore
         voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
       } else if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+        logger(
+          'debug',
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in foregroundIncomingCallkeepMap`
+        );
         unsubscribeCallkeepEvents(activeCallCid);
         callkeep.endCall(foregroundIncomingCallkeepMap.uuid);
         // no need to keep this reference anymore
@@ -112,6 +126,11 @@ export const useIosCallkeepWithCallingStateEffect = () => {
       voipCallkeepCallOnForegroundMap$
     );
     if (foregroundCallkeepMap && foregroundCallkeepMap.cid === activeCallCid) {
+      logger(
+        'debug',
+        // @ts-ignore
+        `Accepting call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundCallkeepMap`
+      );
       // this call should be accepted in callkeep
       callkeep.answerIncomingCall(foregroundCallkeepMap.uuid);
       // no need to keep this reference anymore
@@ -131,6 +150,11 @@ export const useIosCallkeepWithCallingStateEffect = () => {
     // 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) {
+      logger(
+        'debug',
+        // @ts-ignore
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in acceptedForegroundCallkeepMap`
+      );
       callkeep.endCall(acceptedForegroundCallkeepMap.uuid);
       setAcceptedForegroundCallkeepMap(undefined);
       return;
@@ -141,6 +165,11 @@ export const useIosCallkeepWithCallingStateEffect = () => {
       voipCallkeepCallOnForegroundMap$
     );
     if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+      logger(
+        'debug',
+        // @ts-ignore
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundIncomingCallkeepMap`
+      );
       callkeep.endCall(foregroundIncomingCallkeepMap.uuid);
       // no need to keep this reference anymore
       voipCallkeepCallOnForegroundMap$.next(undefined);
@@ -153,6 +182,11 @@ export const useIosCallkeepWithCallingStateEffect = () => {
       voipCallkeepAcceptedCallOnNativeDialerMap$
     );
     if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+      logger(
+        'debug',
+        // @ts-ignore
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in nativeDialerAcceptedCallMap`
+      );
       callkeep.endCall(nativeDialerAcceptedCallMap.uuid);
       // no need to keep this reference anymore
       voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);

package/src/hooks/push/useIosVoipPushEventsSetupEffect.ts

@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+import { MutableRefObject, useEffect, useRef, useState } from 'react';
 import {
   getCallKeepLib,
   getVoipPushNotificationLib,
@@ -6,7 +6,10 @@ import {
 
 import { AppState, Platform } from 'react-native';
 import { StreamVideoRN } from '../../utils';
-import { useStreamVideoClient } from '@stream-io/video-react-bindings';
+import {
+  useConnectedUser,
+  useStreamVideoClient,
+} from '@stream-io/video-react-bindings';
 import { setPushLogoutCallback } from '../../utils/internal/pushLogoutCallback';
 import { NativeModules } from 'react-native';
 import {
@@ -17,9 +20,28 @@ import {
   pushUnsubscriptionCallbacks$,
   voipPushNotificationCallCId$,
 } from '../../utils/push/internal/rxSubjects';
-import { RxUtils, getLogger } from '@stream-io/video-client';
+import { RxUtils, StreamVideoClient, getLogger } from '@stream-io/video-client';
 
-let lastVoipToken = { token: '', userId: '' };
+const logger = getLogger(['useIosVoipPushEventsSetupEffect']);
+
+function setLogoutCallback(
+  client: StreamVideoClient,
+  token: string,
+  lastVoipTokenRef: MutableRefObject<{ token: string; userId: string }>
+) {
+  setPushLogoutCallback(async () => {
+    lastVoipTokenRef.current = { token: '', userId: '' };
+    try {
+      await client.removeDevice(token);
+    } catch (err) {
+      logger(
+        'warn',
+        'PushLogoutCallback - Failed to remove voip token from stream',
+        err
+      );
+    }
+  });
+}
 
 /**
  * This hook is used to do the initial setup of listeners
@@ -27,6 +49,45 @@ let lastVoipToken = { token: '', userId: '' };
  */
 export const useIosVoipPushEventsSetupEffect = () => {
   const client = useStreamVideoClient();
+  const connectedUserId = useConnectedUser()?.id;
+  const lastVoipTokenRef = useRef({ token: '', userId: '' });
+  const [unsentToken, setUnsentToken] = useState<string>();
+
+  useEffect(() => {
+    const pushConfig = StreamVideoRN.getConfig().push;
+    //  we need to wait for user to be connected before we can send the push token
+    if (
+      !pushConfig?.ios.pushProviderName ||
+      !client ||
+      !connectedUserId ||
+      !unsentToken
+    ) {
+      return;
+    }
+    logger(
+      'debug',
+      'Sending unsent voip token to stream as user logged in after token was received, token: ' +
+        unsentToken
+    );
+    client
+      .addVoipDevice(unsentToken, 'apn', pushConfig.ios.pushProviderName)
+      .then(() => {
+        setLogoutCallback(client, unsentToken, lastVoipTokenRef);
+        logger(
+          'debug',
+          'Sent unsent voip token to stream - token: ' + unsentToken
+        );
+        lastVoipTokenRef.current = {
+          token: unsentToken,
+          userId: connectedUserId,
+        };
+        setUnsentToken(undefined);
+      })
+      .catch((error) => {
+        logger('warn', 'Error in sending unsent voip token to stream', error);
+      });
+  }, [client, connectedUserId, unsentToken]);
+
   useEffect(() => {
     const pushConfig = StreamVideoRN.getConfig().push;
     if (Platform.OS !== 'ios' || !pushConfig || !client) {
@@ -35,28 +96,34 @@ export const useIosVoipPushEventsSetupEffect = () => {
     const voipPushNotification = getVoipPushNotificationLib();
     const onTokenReceived = (token: string) => {
       const userId = client.streamClient._user?.id ?? '';
+      if (!userId) {
+        setUnsentToken(token);
+        return;
+      }
+      const lastVoipToken = lastVoipTokenRef.current;
       if (lastVoipToken.token === token && lastVoipToken.userId === userId) {
+        logger(
+          'debug',
+          `Skipped sending voip token to stream as it is same as last token - token: ${token}, userId: ${userId}`
+        );
         return;
       }
-      lastVoipToken = { token, userId };
       const push_provider_name = pushConfig.ios.pushProviderName;
       if (!push_provider_name) {
         return;
       }
-      client.addVoipDevice(token, 'apn', push_provider_name).catch((err) => {
-        const logger = getLogger(['useIosVoipPushEventsSetupEffect']);
-        logger('warn', 'Failed to send voip token to stream', err);
-      });
-      // set the logout callback
-      setPushLogoutCallback(async () => {
-        lastVoipToken = { token: '', userId: '' };
-        try {
-          await client.removeDevice(token);
-        } catch (err) {
-          const logger = getLogger(['PushLogoutCallback']);
-          logger('warn', 'Failed to remove voip token from stream', err);
-        }
-      });
+      logger('debug', 'Sending voip token to stream, token: ' + token);
+      client
+        .addVoipDevice(token, 'apn', push_provider_name)
+        .then(() => {
+          logger('debug', 'Sent voip token to stream, token: ' + token);
+          setLogoutCallback(client, token, lastVoipTokenRef);
+          lastVoipTokenRef.current = { token, userId };
+        })
+        .catch((err) => {
+          setUnsentToken(token);
+          logger('warn', 'Failed to send voip token to stream', err);
+        });
     };
     // fired when PushKit give us the latest token
     voipPushNotification.addEventListener('register', (token) => {
@@ -145,7 +212,6 @@ const onNotificationReceived = async (notification: any) => {
         call_cid
       );
   } catch (error) {
-    const logger = getLogger(['useIosVoipPushEventsSetupEffect']);
     logger('error', 'Error in getting call uuid from native module', error);
   }
   if (!uuid) {
@@ -161,6 +227,10 @@ const onNotificationReceived = async (notification: any) => {
     );
     if (mustEndCall) {
       const callkeep = getCallKeepLib();
+      logger(
+        'debug',
+        `callkeep.reportEndCallWithUUID for uuid: ${uuid}, call_cid: ${call_cid}, reason: ${callkeepReason}`
+      );
       callkeep.reportEndCallWithUUID(uuid, callkeepReason);
       return true;
     }
@@ -170,13 +240,24 @@ const onNotificationReceived = async (notification: any) => {
   const canListenToWS = () =>
     canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
   if (!closed && canListenToWS()) {
-    const unsubscribe = callFromPush.on('all', () => {
-      if (!canListenToWS()) {
+    const unsubscribe = callFromPush.on('all', (event) => {
+      const _canListenToWS = canListenToWS();
+      if (!_canListenToWS) {
+        logger(
+          'debug',
+          `unsubscribe due to event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+          event
+        );
         unsubscribe();
         return;
       }
       const _closed = closeCallIfNecessary();
       if (_closed) {
+        logger(
+          'debug',
+          `unsubscribe due to event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed: ${_closed}`,
+          event
+        );
         unsubscribe();
       }
     });

package/src/hooks/push/useProcessPushCallEffect.ts

@@ -13,7 +13,7 @@ import {
 import { BehaviorSubject } from 'rxjs';
 import { filter, distinctUntilChanged } from 'rxjs/operators';
 import { processCallFromPush } from '../../utils/push/internal/utils';
-import { StreamVideoClient } from '@stream-io/video-client';
+import { getLogger, StreamVideoClient } from '@stream-io/video-client';
 import type { StreamVideoConfig } from '../../utils/StreamVideoRN/types';
 
 /**
@@ -32,6 +32,11 @@ export const useProcessPushCallEffect = () => {
       return;
     }
 
+    getLogger(['useProcessPushCallEffect'])(
+      'debug',
+      `Adding subscriptions to process incoming call from push notification`
+    );
+
     // if the user accepts the call from push notification we join the call
     const acceptedCallSubscription = createCallSubscription(
       pushAcceptedIncomingCallCId$,
@@ -91,6 +96,10 @@ const createCallSubscription = (
   return behaviourSubjectWithCallCid
     .pipe(filter(cidIsNotUndefined), distinctUntilChanged())
     .subscribe(async (callCId) => {
+      getLogger(['useProcessPushCallEffect'])(
+        'debug',
+        `Processing call from push notification with action: ${action} and callCId: ${callCId}`
+      );
       await processCallFromPush(client, callCId, action, pushConfig);
       behaviourSubjectWithCallCid.next(undefined); // remove the current call id to avoid processing again
     });

package/src/hooks/push/useProcessPushNonRingingCallEffect.ts

@@ -7,6 +7,7 @@ import {
 } from '@stream-io/video-react-bindings';
 import { filter } from 'rxjs/operators';
 import { processNonIncomingCallFromPush } from '../../utils/push/internal/utils';
+import { getLogger } from '@stream-io/video-client';
 
 /**
  * This hook is used to process the non ringing call data via push notifications using the relevant rxjs subject
@@ -26,6 +27,10 @@ export const useProcessPushNonRingingCallEffect = () => {
     const subscription = pushNonRingingCallData$
       .pipe(filter(NotUndefined))
       .subscribe(async ({ cid, type }) => {
+        getLogger(['useProcessPushNonRingingCallEffect'])(
+          'debug',
+          `processNonIncomingCallFromPush with callCId: ${cid} and type: ${type}`
+        );
         await processNonIncomingCallFromPush(client, cid, type);
         pushNonRingingCallData$.next(undefined); // remove the current data to avoid processing again
       });

package/src/utils/push/android.ts

@@ -64,12 +64,20 @@ export async function initAndroidPushToken(
       lastFirebaseToken.token === token &&
       lastFirebaseToken.userId === userId
     ) {
+      getLogger(['initAndroidPushToken'])(
+        'debug',
+        `Skipping setting the same token again for userId: ${userId} and token: ${token}`
+      );
       return;
     }
     lastFirebaseToken = { token, userId };
     setPushLogoutCallback(async () => {
       lastFirebaseToken = { token: '', userId: '' };
       try {
+        getLogger(['initAndroidPushToken'])(
+          'debug',
+          `Logout removeDeviceToken: ${token}`
+        );
         await client.removeDevice(token);
       } catch (err) {
         const logger = getLogger(['initAndroidPushToken']);
@@ -159,18 +167,44 @@ export const firebaseDataHandler = async (
         return new Promise(async () => {
           const client = await pushConfig.createStreamVideoClient();
           if (!client) {
+            getLogger(['firebaseMessagingOnMessageHandler'])(
+              'debug',
+              `Closing fg service as there is no client to create from push config`
+            );
             notifee.stopForegroundService();
             return;
           }
           const callFromPush = await client.onRingingCall(call_cid);
-          if (shouldCallBeClosed(callFromPush)) {
+          let _shouldCallBeClosed = shouldCallBeClosed(callFromPush);
+          if (_shouldCallBeClosed) {
+            getLogger(['firebaseMessagingOnMessageHandler'])(
+              'debug',
+              `Closing fg service callCid: ${call_cid} shouldCallBeClosed: ${_shouldCallBeClosed}`
+            );
             notifee.stopForegroundService();
             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', () => {
-            if (!canListenToWS() || shouldCallBeClosed(callFromPush)) {
+          const unsubscribe = callFromPush.on('all', (event) => {
+            const _canListenToWS = canListenToWS();
+            if (!_canListenToWS) {
+              getLogger(['firebaseMessagingOnMessageHandler'])(
+                'debug',
+                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+                { event }
+              );
+              unsubscribeFunctions.forEach((fn) => fn());
+              notifee.stopForegroundService();
+              return;
+            }
+            _shouldCallBeClosed = shouldCallBeClosed(callFromPush);
+            if (_shouldCallBeClosed) {
+              getLogger(['firebaseMessagingOnMessageHandler'])(
+                'debug',
+                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed: ${_shouldCallBeClosed}`,
+                { event }
+              );
               unsubscribeFunctions.forEach((fn) => fn());
               notifee.stopForegroundService();
             }
@@ -221,6 +255,14 @@ export const firebaseDataHandler = async (
     const { getTitle, getBody } = incomingCallNotificationTextGetters;
     const createdUserName = data.created_by_display_name as string;
 
+    const title = getTitle(createdUserName);
+    const body = getBody(createdUserName);
+
+    getLogger(['firebaseMessagingOnMessageHandler'])(
+      'debug',
+      `Displaying incoming call notification with callCid: ${call_cid} title: ${title} body: ${body} asForegroundService: ${asForegroundService}`
+    );
+
     const channelId = incomingCallChannel.id;
     await notifee.displayNotification({
       id: call_cid,
@@ -276,6 +318,10 @@ export const firebaseDataHandler = async (
     const callFromPush = await client.onRingingCall(call_cid);
 
     if (shouldCallBeClosed(callFromPush)) {
+      getLogger(['firebaseMessagingOnMessageHandler'])(
+        'debug',
+        `Removing incoming call notification immediately with callCid: ${call_cid} as it should be closed`
+      );
       notifee.cancelDisplayedNotification(call_cid);
     }
   } else {
@@ -288,7 +334,7 @@ export const firebaseDataHandler = async (
     if (!callChannel || !callNotificationTextGetters) {
       const logger = getLogger(['firebaseMessagingOnMessageHandler']);
       logger(
-        'info',
+        'debug',
         "Can't show call notification as either or both callChannel and callNotificationTextGetters is not provided"
       );
       return;
@@ -299,6 +345,14 @@ export const firebaseDataHandler = async (
     const createdUserName = data.created_by_display_name as string;
     // we can safely cast to string because the data is from "stream.video"
     const type = data.type as NonRingingPushEvent;
+
+    const title = getTitle(type, createdUserName);
+    const body = getBody(type, createdUserName);
+
+    getLogger(['firebaseMessagingOnMessageHandler'])(
+      'debug',
+      `Displaying NonRingingPushEvent ${type} notification with title: ${title} body: ${body}`
+    );
     await notifee.displayNotification({
       title: getTitle(type, createdUserName),
       body: getBody(type, createdUserName),
@@ -369,25 +423,53 @@ export const onAndroidNotifeeEvent = async ({
       mustDecline ||
       type === notifeeLib.EventType.ACTION_PRESS
     ) {
+      getLogger(['onAndroidNotifeeEvent'])(
+        'debug',
+        `clearPushWSEventSubscriptions for callCId: ${call_cid} mustAccept: ${mustAccept} mustDecline: ${mustDecline}`
+      );
       clearPushWSEventSubscriptions();
       notifee.stopForegroundService();
     }
 
     if (mustAccept) {
+      getLogger(['onAndroidNotifeeEvent'])(
+        'debug',
+        `pushAcceptedIncomingCallCId$ added with callCId: ${call_cid}`
+      );
       pushAcceptedIncomingCallCId$.next(call_cid);
       // NOTE: accept will be handled by the app with rxjs observers as the app will go to foreground always
     } else if (mustDecline) {
+      getLogger(['onAndroidNotifeeEvent'])(
+        'debug',
+        `pushRejectedIncomingCallCId$ added with callCId: ${call_cid}`
+      );
       pushRejectedIncomingCallCId$.next(call_cid);
       if (hasObservers) {
         // if we had observers we can return here as the observers will handle the call as the app is in the foreground state
+        getLogger(['onAndroidNotifeeEvent'])(
+          'debug',
+          `Skipped processCallFromPushInBackground for Declining call with callCId: ${call_cid} as the app is in the foreground state`
+        );
         return;
       }
+      getLogger(['onAndroidNotifeeEvent'])(
+        'debug',
+        `start processCallFromPushInBackground - Declining call with callCId: ${call_cid}`
+      );
       await processCallFromPushInBackground(pushConfig, call_cid, 'decline');
     } else {
       if (type === notifeeLib.EventType.PRESS) {
+        getLogger(['onAndroidNotifeeEvent'])(
+          'debug',
+          `pushTappedIncomingCallCId$ added with callCId: ${call_cid}`
+        );
         pushTappedIncomingCallCId$.next(call_cid);
         // pressed state will be handled by the app with rxjs observers as the app will go to foreground always
       } else if (isBackground && type === notifeeLib.EventType.DELIVERED) {
+        getLogger(['onAndroidNotifeeEvent'])(
+          'debug',
+          `pushAndroidBackgroundDeliveredIncomingCallCId$ added with callCId: ${call_cid}`
+        );
         pushAndroidBackgroundDeliveredIncomingCallCId$.next(call_cid);
         // background delivered state will be handled by the app with rxjs observers as processing needs to happen only when app is opened
       }
@@ -395,6 +477,10 @@ export const onAndroidNotifeeEvent = async ({
   } else {
     const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
     if (type === notifeeLib.EventType.PRESS) {
+      getLogger(['onAndroidNotifeeEvent'])(
+        'debug',
+        `onTapNonRingingCallNotification with callCId: ${call_cid}`
+      );
       pushConfig.onTapNonRingingCallNotification?.(
         call_cid,
         data.type as NonRingingPushEvent

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

@@ -57,6 +57,10 @@ export const shouldCallBeEnded = (
       callkeepReason = 4;
     }
   }
+  getLogger(['shouldCallBeEnded'])(
+    'debug',
+    `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} callkeepReason: ${callkeepReason}`
+  );
   return { mustEndCall, callkeepReason };
 };
 
@@ -111,16 +115,24 @@ export const processCallFromPush = async (
       if (pushConfig.publishOptions) {
         callFromPush.updatePublishOptions(pushConfig.publishOptions);
       }
+      getLogger(['processCallFromPush'])(
+        'debug',
+        `joining call from push notification with callCid: ${callFromPush.cid}`
+      );
       await callFromPush.join();
     } else if (action === 'decline') {
       const canReject =
         callFromPush.state.callingState === CallingState.RINGING;
+      getLogger(['processCallFromPush'])(
+        'debug',
+        `declining call from push notification with callCid: ${callFromPush.cid} reject: ${canReject}`
+      );
       await callFromPush.leave({ reject: canReject, reason: 'decline' });
     }
   } catch (e) {
     const logger = getLogger(['processCallFromPush']);
     logger(
-      'error',
+      'warn',
       `failed to process ${action} call from push notification`,
       e
     );