@stream-io/video-react-native-sdk 1.23.0 → 1.24.1

package/src/utils/push/android.ts

@@ -1,8 +1,8 @@
 import {
   Call,
   CallingState,
-  getLogger,
   StreamVideoClient,
+  videoLoggerSystem,
 } from '@stream-io/video-client';
 import { AppState, Platform } from 'react-native';
 import type {
@@ -59,19 +59,18 @@ export async function initAndroidPushToken(
   if (Platform.OS !== 'android' || !pushConfig.android.pushProviderName) {
     return;
   }
-  const logger = getLogger(['initAndroidPushToken']);
+  const logger = videoLoggerSystem.getLogger('initAndroidPushToken');
   const setDeviceToken = async (token: string) => {
     const userId = client.streamClient._user?.id ?? '';
     if (client.streamClient.anonymous) {
-      logger('debug', 'Skipped sending firebase token for anonymous user');
+      logger.debug('Skipped sending firebase token for anonymous user');
       return;
     }
     if (
       lastFirebaseToken.token === token &&
       lastFirebaseToken.userId === userId
     ) {
-      logger(
-        'debug',
+      logger.debug(
         `Skipping setting the same token again for userId: ${userId} and token: ${token}`,
       );
       return;
@@ -80,14 +79,14 @@ export async function initAndroidPushToken(
     setPushLogoutCallback(async () => {
       lastFirebaseToken = { token: '', userId: '' };
       try {
-        logger('debug', `Logout removeDeviceToken: ${token}`);
+        logger.debug(`Logout removeDeviceToken: ${token}`);
         await client.removeDevice(token);
       } catch (err) {
-        logger('warn', 'Failed to remove firebase token from stream', err);
+        logger.warn('Failed to remove firebase token from stream', err);
       }
     });
     const push_provider_name = pushConfig.android.pushProviderName;
-    logger('debug', `sending firebase token: ${token} for userId: ${userId}`);
+    logger.debug(`sending firebase token: ${token} for userId: ${userId}`);
     await client.addDevice(token, 'firebase', push_provider_name);
   };
   if (pushConfig.isExpo) {
@@ -95,7 +94,7 @@ export async function initAndroidPushToken(
       ? getExpoNotificationsLib()
       : getExpoNotificationsLibNoThrow();
     if (expoNotificationsLib) {
-      logger('debug', `setting expo notification token listeners`);
+      logger.debug(`setting expo notification token listeners`);
       const subscription = expoNotificationsLib.addPushTokenListener(
         (devicePushToken) => {
           setDeviceToken(devicePushToken.data);
@@ -114,7 +113,7 @@ export async function initAndroidPushToken(
       ? getFirebaseMessagingLibNoThrow(true)
       : getFirebaseMessagingLib();
   if (messaging) {
-    logger('debug', `setting firebase token listeners`);
+    logger.debug(`setting firebase token listeners`);
     const unsubscribe = messaging().onTokenRefresh((refreshedToken) =>
       setDeviceToken(refreshedToken),
     );
@@ -155,9 +154,8 @@ export const firebaseDataHandler = async (
   const notifee = notifeeLib.default;
   const settings = await notifee.getNotificationSettings();
   if (settings.authorizationStatus !== 1) {
-    const logger = getLogger(['firebaseDataHandler']);
-    logger(
-      'debug',
+    const logger = videoLoggerSystem.getLogger('firebaseDataHandler');
+    logger.debug(
       `Notification permission not granted, unable to post ${data.type} notifications`,
     );
     return;
@@ -192,20 +190,22 @@ 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`,
-            );
+            videoLoggerSystem
+              .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);
           let _shouldCallBeClosed = shouldCallBeClosed(callFromPush);
           if (_shouldCallBeClosed) {
-            getLogger(['firebaseMessagingOnMessageHandler'])(
-              'debug',
-              `Closing fg service callCid: ${call_cid} shouldCallBeClosed: ${_shouldCallBeClosed}`,
-            );
+            videoLoggerSystem
+              .getLogger('firebaseMessagingOnMessageHandler')
+              .debug(
+                `Closing fg service callCid: ${call_cid} shouldCallBeClosed: ${_shouldCallBeClosed}`,
+              );
             notifee.stopForegroundService();
             return;
           }
@@ -214,22 +214,24 @@ export const firebaseDataHandler = async (
           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 },
-              );
+              videoLoggerSystem
+                .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 },
-              );
+              videoLoggerSystem
+                .getLogger('firebaseMessagingOnMessageHandler')
+                .debug(
+                  `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed: ${_shouldCallBeClosed}`,
+                  { event },
+                );
               unsubscribeFunctions.forEach((fn) => fn());
               notifee.stopForegroundService();
             }
@@ -241,10 +243,11 @@ export const firebaseDataHandler = async (
                 callingState === CallingState.IDLE ||
                 callingState === CallingState.LEFT
               ) {
-                getLogger(['firebaseMessagingOnMessageHandler'])(
-                  'debug',
-                  `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
-                );
+                videoLoggerSystem
+                  .getLogger('firebaseMessagingOnMessageHandler')
+                  .debug(
+                    `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
+                  );
                 unsubscribeFunctions.forEach((fn) => fn());
                 notifee.stopForegroundService();
               }
@@ -261,9 +264,10 @@ export const firebaseDataHandler = async (
     const incomingCallNotificationTextGetters =
       pushConfig.android.incomingCallNotificationTextGetters;
     if (!incomingCallChannel || !incomingCallNotificationTextGetters) {
-      const logger = getLogger(['firebaseMessagingOnMessageHandler']);
-      logger(
-        'error',
+      const logger = videoLoggerSystem.getLogger(
+        'firebaseMessagingOnMessageHandler',
+      );
+      logger.error(
         "Can't show incoming call notification as either or both incomingCallChannel and incomingCallNotificationTextGetters were not provided",
       );
       return;
@@ -284,10 +288,11 @@ export const firebaseDataHandler = async (
     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}`,
-    );
+    videoLoggerSystem
+      .getLogger('firebaseMessagingOnMessageHandler')
+      .debug(
+        `Displaying incoming call notification with callCid: ${call_cid} title: ${title} body: ${body} asForegroundService: ${asForegroundService}`,
+      );
 
     const channelId = incomingCallChannel.id;
     await notifee.displayNotification({
@@ -346,10 +351,11 @@ 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`,
-      );
+      videoLoggerSystem
+        .getLogger('firebaseMessagingOnMessageHandler')
+        .debug(
+          `Removing incoming call notification immediately with callCid: ${call_cid} as it should be closed`,
+        );
       notifee.cancelDisplayedNotification(call_cid);
     }
   } else {
@@ -358,9 +364,10 @@ export const firebaseDataHandler = async (
     const callNotificationTextGetters =
       pushConfig.android.callNotificationTextGetters;
     if (!callChannel || !callNotificationTextGetters) {
-      const logger = getLogger(['firebaseMessagingOnMessageHandler']);
-      logger(
-        'debug',
+      const logger = videoLoggerSystem.getLogger(
+        'firebaseMessagingOnMessageHandler',
+      );
+      logger.debug(
         "Can't show call notification as either or both callChannel and callNotificationTextGetters is not provided",
       );
       return;
@@ -375,10 +382,11 @@ export const firebaseDataHandler = async (
     const title = getTitle(type, createdUserName);
     const body = getBody(type, createdUserName);
 
-    getLogger(['firebaseMessagingOnMessageHandler'])(
-      'debug',
-      `Displaying NonRingingPushEvent ${type} notification with title: ${title} body: ${body}`,
-    );
+    videoLoggerSystem
+      .getLogger('firebaseMessagingOnMessageHandler')
+      .debug(
+        `Displaying NonRingingPushEvent ${type} notification with title: ${title} body: ${body}`,
+      );
     await notifee.displayNotification({
       title: getTitle(type, createdUserName),
       body: getBody(type, createdUserName),
@@ -450,53 +458,54 @@ export const onAndroidNotifeeEvent = async ({
       mustDecline ||
       type === notifeeLib.EventType.ACTION_PRESS
     ) {
-      getLogger(['onAndroidNotifeeEvent'])(
-        'debug',
-        `clearPushWSEventSubscriptions for callCId: ${call_cid} mustAccept: ${mustAccept} mustDecline: ${mustDecline}`,
-      );
+      videoLoggerSystem
+        .getLogger('onAndroidNotifeeEvent')
+        .debug(
+          `clearPushWSEventSubscriptions for callCId: ${call_cid} mustAccept: ${mustAccept} mustDecline: ${mustDecline}`,
+        );
       clearPushWSEventSubscriptions(call_cid);
       notifee.stopForegroundService();
     }
 
     if (mustAccept) {
-      getLogger(['onAndroidNotifeeEvent'])(
-        'debug',
-        `pushAcceptedIncomingCallCId$ added with callCId: ${call_cid}`,
-      );
+      videoLoggerSystem
+        .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}`,
-      );
+      videoLoggerSystem
+        .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`,
-        );
+        videoLoggerSystem
+          .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}`,
-      );
+      videoLoggerSystem
+        .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}`,
-        );
+        videoLoggerSystem
+          .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}`,
-        );
+        videoLoggerSystem
+          .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
       }
@@ -504,10 +513,9 @@ export const onAndroidNotifeeEvent = async ({
   } else {
     const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
     if (type === notifeeLib.EventType.PRESS) {
-      getLogger(['onAndroidNotifeeEvent'])(
-        'debug',
-        `onTapNonRingingCallNotification with callCId: ${call_cid}`,
-      );
+      videoLoggerSystem
+        .getLogger('onAndroidNotifeeEvent')
+        .debug(`onTapNonRingingCallNotification with callCId: ${call_cid}`);
       pushConfig.onTapNonRingingCallNotification?.(
         call_cid,
         data.type as NonRingingPushEvent,

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

@@ -1,10 +1,10 @@
-import { getLogger } from '@stream-io/video-client';
 import { AppState, NativeModules, Platform } from 'react-native';
 import { getCallKeepLib, getVoipPushNotificationLib } from '../libs';
 import { voipPushNotificationCallCId$ } from './rxSubjects';
 import { pushUnsubscriptionCallbacks } from './constants';
 import { canAddPushWSSubscriptionsRef, shouldCallBeEnded } from './utils';
 import { StreamVideoConfig } from '../../StreamVideoRN/types';
+import { videoLoggerSystem } from '@stream-io/video-client';
 
 export const onVoipNotificationReceived = async (
   notification: any,
@@ -42,12 +42,11 @@ export const onVoipNotificationReceived = async (
   if (!call_cid || Platform.OS !== 'ios' || !pushConfig.ios.pushProviderName) {
     return;
   }
-  const logger = getLogger(['setupIosVoipPushEvents']);
+  const logger = videoLoggerSystem.getLogger('setupIosVoipPushEvents');
   const client = await pushConfig.createStreamVideoClient();
 
   if (!client) {
-    logger(
-      'debug',
+    logger.debug(
       'client not found, not processing call.ring voip push notification',
     );
     return;
@@ -67,11 +66,10 @@ export const onVoipNotificationReceived = async (
         call_cid,
       );
   } catch (error) {
-    logger('error', 'Error in getting call uuid from native module', error);
+    logger.error('Error in getting call uuid from native module', error);
   }
   if (!uuid) {
-    logger(
-      'error',
+    logger.error(
       `Not processing call.ring push notification, as no uuid found for call_cid: ${call_cid}`,
     );
     return;
@@ -86,8 +84,7 @@ export const onVoipNotificationReceived = async (
     );
     if (mustEndCall) {
       const callkeep = getCallKeepLib();
-      logger(
-        'debug',
+      logger.debug(
         `callkeep.reportEndCallWithUUID for uuid: ${uuid}, call_cid: ${call_cid}, reason: ${callkeepReason}`,
       );
       callkeep.reportEndCallWithUUID(uuid, callkeepReason);
@@ -104,8 +101,7 @@ export const onVoipNotificationReceived = async (
     const unsubscribe = callFromPush.on('all', (event) => {
       const _canListenToWS = canListenToWS();
       if (!_canListenToWS) {
-        logger(
-          'debug',
+        logger.debug(
           `unsubscribe due to event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
           event,
         );
@@ -114,8 +110,7 @@ export const onVoipNotificationReceived = async (
       }
       const _closed = closeCallIfNecessary();
       if (_closed) {
-        logger(
-          'debug',
+        logger.debug(
           `unsubscribe due to event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed: ${_closed}`,
           event,
         );
@@ -128,8 +123,7 @@ export const onVoipNotificationReceived = async (
   }
   // send the info to this subject, it is listened by callkeep events
   // callkeep events will then accept/reject the call
-  logger(
-    'debug',
+  logger.debug(
     `call_cid:${call_cid} uuid:${uuid} received and processed from call.ring push notification`,
   );
   voipPushNotificationCallCId$.next(call_cid);

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

@@ -1,8 +1,8 @@
 import {
   Call,
   CallingState,
-  getLogger,
   StreamVideoClient,
+  videoLoggerSystem,
 } from '@stream-io/video-client';
 import type {
   NonRingingPushEvent,
@@ -56,10 +56,11 @@ export const shouldCallBeEnded = (
       callkeepReason = 4;
     }
   }
-  getLogger(['shouldCallBeEnded'])(
-    'debug',
-    `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} callkeepReason: ${callkeepReason}`,
-  );
+  videoLoggerSystem
+    .getLogger('shouldCallBeEnded')
+    .debug(
+      `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} callkeepReason: ${callkeepReason}`,
+    );
   return { mustEndCall, callkeepReason };
 };
 
@@ -80,8 +81,10 @@ export const processCallFromPushInBackground = async (
       return;
     }
   } catch (e) {
-    const logger = getLogger(['processCallFromPushInBackground']);
-    logger('error', 'failed to create video client', e);
+    const logger = videoLoggerSystem.getLogger(
+      'processCallFromPushInBackground',
+    );
+    logger.error('failed to create video client', e);
     return;
   }
   await processCallFromPush(videoClient, call_cid, action, pushConfig);
@@ -104,8 +107,8 @@ export const processCallFromPush = async (
   try {
     callFromPush = await client.onRingingCall(call_cid);
   } catch (e) {
-    const logger = getLogger(['processCallFromPush']);
-    logger('error', 'failed to fetch call from push notification', e);
+    const logger = videoLoggerSystem.getLogger('processCallFromPush');
+    logger.error('failed to fetch call from push notification', e);
     return;
   }
   // note: when action was pressed or delivered, we dont need to do anything as the only thing is to do is to get the call which adds it to the client
@@ -114,27 +117,25 @@ export const processCallFromPush = async (
       if (pushConfig.publishOptions) {
         callFromPush.updatePublishOptions(pushConfig.publishOptions);
       }
-      getLogger(['processCallFromPush'])(
-        'debug',
-        `joining call from push notification with callCid: ${callFromPush.cid}`,
-      );
+      videoLoggerSystem
+        .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}`,
-      );
+      videoLoggerSystem
+        .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(
-      'warn',
-      `failed to process ${action} call from push notification`,
-      e,
-    );
+    const logger = videoLoggerSystem.getLogger('processCallFromPush');
+    logger.warn(`failed to process ${action} call from push notification`, e);
   }
 };
 
@@ -162,8 +163,10 @@ export const processNonIncomingCallFromPush = async (
       await callFromPush.get();
     }
   } catch (e) {
-    const logger = getLogger(['processNonIncomingCallFromPush']);
-    logger('error', 'failed to fetch call from push notification', e);
+    const logger = videoLoggerSystem.getLogger(
+      'processNonIncomingCallFromPush',
+    );
+    logger.error('failed to fetch call from push notification', e);
     return;
   }
   onNewCallNotification(callFromPush, nonRingingNotificationType);