@stream-io/video-react-native-sdk 1.2.14 → 1.3.0

package/src/utils/push/android.ts

@@ -1,4 +1,3 @@
-import { FirebaseMessagingTypes } from '@react-native-firebase/messaging';
 import {
   Call,
   RxUtils,
@@ -12,11 +11,10 @@ import type {
 } from '../StreamVideoRN/types';
 import {
   getFirebaseMessagingLib,
-  getFirebaseMessagingLibNoThrow,
   getExpoNotificationsLib,
-  getExpoTaskManagerLib,
   getNotifeeLibThrowIfNotInstalledForPush,
   NotifeeLib,
+  FirebaseMessagingTypes,
 } from './libs';
 import {
   pushAcceptedIncomingCallCId$,
@@ -25,15 +23,16 @@ import {
   pushNonRingingCallData$,
   pushUnsubscriptionCallbacks$,
   pushAndroidBackgroundDeliveredIncomingCallCId$,
-} from './rxSubjects';
+} from './internal/rxSubjects';
 import {
   canAddPushWSSubscriptionsRef,
   clearPushWSEventSubscriptions,
   processCallFromPushInBackground,
   shouldCallBeEnded,
-} from './utils';
+} from './internal/utils';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
 import { getAndroidDefaultRingtoneUrl } from '../getAndroidDefaultRingtoneUrl';
+import { StreamVideoRN } from '../StreamVideoRN';
 
 const ACCEPT_CALL_ACTION_ID = 'accept';
 const DECLINE_CALL_ACTION_ID = 'decline';
@@ -48,89 +47,6 @@ type Event = Parameters<onBackgroundEventFunctionParams>[0];
 
 let lastFirebaseToken = { token: '', userId: '' };
 
-//  EventType = NotifeeLib['EventType'];
-
-/** Setup Firebase push message handler **/
-export function setupFirebaseHandlerAndroid(pushConfig: PushConfig) {
-  if (Platform.OS !== 'android') {
-    return;
-  }
-  if (pushConfig.isExpo) {
-    const messaging = getFirebaseMessagingLibNoThrow(true);
-    if (messaging) {
-      // handles on app killed state in expo, expo-notifications cannot handle that
-      messaging().setBackgroundMessageHandler(
-        async (msg) =>
-          await firebaseMessagingOnMessageHandler(msg.data, pushConfig)
-      );
-      messaging().onMessage((msg) =>
-        firebaseMessagingOnMessageHandler(msg.data, pushConfig)
-      ); // this is to listen to foreground messages, which we dont need for now
-    } else {
-      const Notifications = getExpoNotificationsLib();
-      const TaskManager = getExpoTaskManagerLib();
-      const BACKGROUND_NOTIFICATION_TASK =
-        'STREAM-VIDEO-SDK-INTERNAL-BACKGROUND-NOTIFICATION-TASK';
-
-      TaskManager.defineTask(
-        BACKGROUND_NOTIFICATION_TASK,
-        ({ data, error }) => {
-          if (error) {
-            return;
-          }
-          // @ts-ignore
-          const dataToProcess = data.notification?.data;
-          firebaseMessagingOnMessageHandler(dataToProcess, pushConfig);
-        }
-      );
-      // background handler (does not handle on app killed state)
-      Notifications.registerTaskAsync(BACKGROUND_NOTIFICATION_TASK);
-      // foreground handler
-      Notifications.setNotificationHandler({
-        handleNotification: async (notification) => {
-          // @ts-ignore
-          const trigger = notification?.request?.trigger;
-          if (trigger.type === 'push') {
-            const data = trigger?.remoteMessage?.data;
-            if (data?.sender === 'stream.video') {
-              await firebaseMessagingOnMessageHandler(data, pushConfig);
-              return {
-                shouldShowAlert: false,
-                shouldPlaySound: false,
-                shouldSetBadge: false,
-              };
-            }
-          }
-          return {
-            shouldShowAlert: true,
-            shouldPlaySound: false,
-            shouldSetBadge: false,
-          };
-        },
-      });
-    }
-  } else {
-    const messaging = getFirebaseMessagingLib();
-    messaging().setBackgroundMessageHandler(
-      async (msg) =>
-        await firebaseMessagingOnMessageHandler(msg.data, pushConfig)
-    );
-    messaging().onMessage((msg) =>
-      firebaseMessagingOnMessageHandler(msg.data, pushConfig)
-    ); // this is to listen to foreground messages, which we dont need for now
-  }
-
-  // the notification tap handlers are always registered with notifee for both expo and non-expo in android
-  const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
-  const notifee = notifeeLib.default;
-  notifee.onBackgroundEvent(async (event) => {
-    await onNotifeeEvent(event, pushConfig, true);
-  });
-  notifee.onForegroundEvent((event) => {
-    onNotifeeEvent(event, pushConfig, false);
-  });
-}
-
 /** Send token to stream, create notification channel,  */
 export async function initAndroidPushToken(
   client: StreamVideoClient,
@@ -184,10 +100,14 @@ export async function initAndroidPushToken(
   }
 }
 
-const firebaseMessagingOnMessageHandler = async (
-  data: FirebaseMessagingTypes.RemoteMessage['data'],
-  pushConfig: PushConfig
+/**
+ * Creates notification from the push message data.
+ * For Ringing and Non-Ringing calls.
+ */
+export const firebaseDataHandler = async (
+  data: FirebaseMessagingTypes.RemoteMessage['data']
 ) => {
+  if (Platform.OS !== 'android') return;
   /* Example data from firebase
     "message": {
         "data": {
@@ -203,7 +123,8 @@ const firebaseMessagingOnMessageHandler = async (
         // other stuff
     }
   */
-  if (!data || data.sender !== 'stream.video') {
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (!pushConfig || !data || data.sender !== 'stream.video') {
     return;
   }
 
@@ -377,16 +298,25 @@ const firebaseMessagingOnMessageHandler = async (
   }
 };
 
-const onNotifeeEvent = async (
-  event: Event,
-  pushConfig: PushConfig,
-  isBackground: boolean
-) => {
+export const onAndroidNotifeeEvent = async ({
+  event,
+  isBackground,
+}: {
+  event: Event;
+  isBackground: boolean;
+}) => {
+  if (Platform.OS !== 'android') return;
   const { type, detail } = event;
   const { notification, pressAction } = detail;
   const notificationId = notification?.id;
   const data = notification?.data;
-  if (!data || !notificationId || data.sender !== 'stream.video') {
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (
+    !pushConfig ||
+    !data ||
+    !notificationId ||
+    data.sender !== 'stream.video'
+  ) {
     return;
   }
 
@@ -443,7 +373,6 @@ const onNotifeeEvent = async (
   } else {
     const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
     if (type === notifeeLib.EventType.PRESS) {
-      pushTappedIncomingCallCId$.next(call_cid);
       pushConfig.onTapNonRingingCallNotification?.(
         call_cid,
         data.type as NonRingingPushEvent

package/src/utils/push/index.ts

@@ -0,0 +1,3 @@
+export * from './android';
+export * from './ios';
+export * from './utils';

package/src/utils/push/{rxSubjects.ts → internal/rxSubjects.ts}

@@ -1,5 +1,5 @@
 import { BehaviorSubject } from 'rxjs';
-import { NonRingingPushEvent } from '../StreamVideoRN/types';
+import { NonRingingPushEvent } from '../../StreamVideoRN/types';
 
 /**
  * This rxjs subject is used to store the call cid of the accepted incoming call from push notification

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

@@ -0,0 +1,178 @@
+import {
+  Call,
+  RxUtils,
+  StreamVideoClient,
+  getLogger,
+} from '@stream-io/video-client';
+import type {
+  NonRingingPushEvent,
+  StreamVideoConfig,
+} from '../../StreamVideoRN/types';
+import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
+import { pushUnsubscriptionCallbacks$ } from './rxSubjects';
+
+type PushConfig = NonNullable<StreamVideoConfig['push']>;
+
+type CanAddPushWSSubscriptionsRef = { current: boolean };
+
+/**
+ * This function is used to check if the call should be ended based on the push notification
+ * Useful for callkeep management to end the call if necessary (with reportEndCallWithUUID)
+ */
+export const shouldCallBeEnded = (
+  callFromPush: Call,
+  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;
+  if (created_by_id && rejected_by) {
+    if (rejected_by[created_by_id]) {
+      // call was cancelled by the caller
+      mustEndCall = true;
+      callkeepReason = 2;
+    }
+  } 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;
+    }
+  } 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;
+    }
+  }
+  return { mustEndCall, callkeepReason };
+};
+
+/* An action for the notification or callkeep and app does not have JS context setup yet, so we need to do two steps:
+  1. we need to create a new client and connect the user to decline the call
+  2. this is because the app is in background state and we don't have a client to get the call and do an action
+*/
+export const processCallFromPushInBackground = async (
+  pushConfig: PushConfig,
+  call_cid: string,
+  action: Parameters<typeof processCallFromPush>[2]
+) => {
+  let videoClient: StreamVideoClient | undefined;
+
+  try {
+    videoClient = await pushConfig.createStreamVideoClient();
+    if (!videoClient) {
+      return;
+    }
+  } catch (e) {
+    const logger = getLogger(['processCallFromPushInBackground']);
+    logger('error', 'failed to create video client', e);
+    return;
+  }
+  await processCallFromPush(videoClient, call_cid, action, pushConfig);
+};
+
+/**
+ * This function is used process the call from push notifications due to incoming call
+ * It does the following steps:
+ * 1. Get the call from the client if present or create a new call
+ * 2. Fetch the latest state of the call from the server if its not already in ringing state
+ * 3. Join or leave the call based on the user's action.
+ */
+export const processCallFromPush = async (
+  client: StreamVideoClient,
+  call_cid: string,
+  action: 'accept' | 'decline' | 'pressed' | 'backgroundDelivered',
+  pushConfig: PushConfig
+) => {
+  let callFromPush: Call;
+  try {
+    callFromPush = await client.onRingingCall(call_cid);
+  } catch (e) {
+    const logger = 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
+  try {
+    if (action === 'accept') {
+      if (pushConfig.publishOptions) {
+        callFromPush.updatePublishOptions(pushConfig.publishOptions);
+      }
+      await callFromPush.join();
+    } else if (action === 'decline') {
+      await callFromPush.leave({ reject: true });
+    }
+  } catch (e) {
+    const logger = getLogger(['processCallFromPush']);
+    logger(
+      'error',
+      `failed to process ${action} call from push notification`,
+      e
+    );
+  }
+};
+
+/**
+ * This function is used process the call from push notifications due to non ringing calls
+ * It does the following steps:
+ * 1. Get the call from the client if present or create a new call
+ * 2. Fetch the latest state of the call from the server
+ * 3. Call all the callbacks to inform the app about the call
+ */
+export const processNonIncomingCallFromPush = async (
+  client: StreamVideoClient,
+  call_cid: string,
+  nonRingingNotificationType: NonRingingPushEvent
+) => {
+  let callFromPush: Call;
+  try {
+    const _callFromPush = client.state.calls.find((c) => c.cid === call_cid);
+    if (_callFromPush) {
+      callFromPush = _callFromPush;
+    } else {
+      // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
+      const [callType, callId] = call_cid.split(':');
+      callFromPush = client.call(callType as string, callId as string);
+      await callFromPush.get();
+    }
+  } catch (e) {
+    const logger = getLogger(['processNonIncomingCallFromPush']);
+    logger('error', 'failed to fetch call from push notification', e);
+    return;
+  }
+  onNewCallNotification(callFromPush, nonRingingNotificationType);
+};
+
+/**
+ * This function is used to clear all the push related WS subscriptions
+ * note: events are subscribed in push for accept/decline through WS
+ */
+export const clearPushWSEventSubscriptions = () => {
+  const unsubscriptionCallbacks = RxUtils.getCurrentValue(
+    pushUnsubscriptionCallbacks$
+  );
+  if (unsubscriptionCallbacks) {
+    unsubscriptionCallbacks.forEach((cb) => cb());
+  }
+  pushUnsubscriptionCallbacks$.next(undefined);
+};
+
+/**
+ * This ref is used to check if the push WS subscriptions can be added
+ * It is used to avoid adding the push WS subscriptions when the client is connected to WS in the foreground
+ */
+export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
+  current: true,
+};

package/src/utils/push/ios.ts

@@ -1,41 +1,24 @@
 import { Platform } from 'react-native';
-import type {
-  NonRingingPushEvent,
-  StreamVideoConfig,
-} from '../StreamVideoRN/types';
-import {
-  pushAcceptedIncomingCallCId$,
-  voipPushNotificationCallCId$,
-  voipCallkeepCallOnForegroundMap$,
-  voipCallkeepAcceptedCallOnNativeDialerMap$,
-  pushNonRingingCallData$,
-} from './rxSubjects';
-import {
-  clearPushWSEventSubscriptions,
-  processCallFromPushInBackground,
-} from './utils';
+import type { StreamVideoConfig } from '../StreamVideoRN/types';
+import { pushNonRingingCallData$ } from './internal/rxSubjects';
 import {
+  ExpoNotification,
   getExpoNotificationsLib,
-  getNotifeeLibThrowIfNotInstalledForPush,
   getPushNotificationIosLib,
+  PushNotificationiOSType,
 } from './libs';
 import { StreamVideoClient, getLogger } from '@stream-io/video-client';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
+import { EventType, Event } from '@notifee/react-native';
+import { StreamVideoRN } from '../StreamVideoRN';
+import { StreamPushPayload } from './utils';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
-type StreamPayload =
-  | {
-      call_cid: string;
-      type: 'call.ring' | NonRingingPushEvent;
-      sender: string;
-    }
-  | undefined;
-
 let lastApnToken = { token: '', userId: '' };
 
 function processNonRingingNotificationStreamPayload(
-  streamPayload: StreamPayload
+  streamPayload: StreamPushPayload
 ) {
   if (
     streamPayload?.sender === 'stream.video' &&
@@ -48,87 +31,56 @@ function processNonRingingNotificationStreamPayload(
   }
 }
 
-export const iosCallkeepAcceptCall = (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string
-) => {
-  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
-    return;
-  }
-  clearPushWSEventSubscriptions();
-  // to call end callkeep later if ended in app and not through callkeep
-  voipCallkeepAcceptedCallOnNativeDialerMap$.next({
-    uuid: callUUIDFromCallkeep,
-    cid: call_cid,
-  });
-  // to process the call in the app
-  pushAcceptedIncomingCallCId$.next(call_cid);
-  // no need to keep these references anymore
-  voipCallkeepCallOnForegroundMap$.next(undefined);
-};
-
-export const iosCallkeepRejectCall = async (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string,
-  pushConfig: PushConfig
-) => {
-  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
-    return;
+export const oniOSExpoNotificationEvent = (event: ExpoNotification) => {
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (pushConfig) {
+    if (event.request.trigger.type === 'push') {
+      const streamPayload = event.request.trigger.payload
+        ?.stream as StreamPushPayload;
+      processNonRingingNotificationStreamPayload(streamPayload);
+    }
   }
-  clearPushWSEventSubscriptions();
-  // no need to keep these references anymore
-  voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
-  voipCallkeepCallOnForegroundMap$.next(undefined);
-  voipPushNotificationCallCId$.next(undefined);
-  await processCallFromPushInBackground(pushConfig, call_cid, 'decline');
 };
 
-/**
- * Helper function to determine if the answer/end call event from callkeep must be processed
- * Just checks if we have a valid call_cid and acts as a type guard for call_cid
- */
-const shouldProcessCallFromCallkeep = (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string
-): call_cid is string => {
-  if (!call_cid || !callUUIDFromCallkeep) {
-    return false;
+export const oniOSNotifeeEvent = ({
+  event,
+}: {
+  event: Event;
+  isBackground: boolean;
+}) => {
+  if (Platform.OS !== 'ios') return;
+  const pushConfig = StreamVideoRN.getConfig().push;
+  const { type, detail } = event;
+  if (pushConfig && type === EventType.PRESS) {
+    const streamPayload = detail.notification?.data?.stream as
+      | StreamPushPayload
+      | undefined;
+    const result = processNonRingingNotificationStreamPayload(streamPayload);
+    if (result) {
+      pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
+    }
   }
-  return true;
 };
 
-export const setupRemoteNotificationsHandleriOS = (pushConfig: PushConfig) => {
-  if (Platform.OS !== 'ios') {
+export function onPushNotificationiOSStreamVideoEvent(
+  notification: PushNotificationiOSType
+) {
+  const pushNotificationIosLib = getPushNotificationIosLib();
+  const data = notification.getData();
+  const streamPayload = data?.stream as StreamPushPayload;
+  const isClicked = data.userInteraction === 1;
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (!streamPayload || !isClicked || !pushConfig) {
+    notification.finish(pushNotificationIosLib.FetchResult.NoData);
     return;
   }
-  const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
-
-  notifeeLib.default.onForegroundEvent(({ type, detail }) => {
-    if (type === notifeeLib.EventType.PRESS) {
-      const streamPayload = detail.notification?.data?.stream as
-        | StreamPayload
-        | undefined;
-      const result = processNonRingingNotificationStreamPayload(streamPayload);
-      if (result) {
-        pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
-      }
-    }
-  });
-  if (pushConfig.isExpo) {
-    const Notifications = getExpoNotificationsLib();
-
-    // foreground handler (just to show the notifications on foreground)
-    Notifications.setNotificationHandler({
-      handleNotification: async () => {
-        return {
-          shouldShowAlert: true,
-          shouldPlaySound: true,
-          shouldSetBadge: false,
-        };
-      },
-    });
+  // listen to foreground notifications
+  const result = processNonRingingNotificationStreamPayload(streamPayload);
+  if (result) {
+    pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
   }
-};
+  notification.finish(pushNotificationIosLib.FetchResult.NoData);
+}
 
 /** Send token to stream */
 export async function initIosNonVoipToken(
@@ -171,34 +123,16 @@ export async function initIosNonVoipToken(
         setDeviceToken(devicePushToken.data);
       }
     );
-    const subscriptionForReceive =
-      expoNotificationsLib.addNotificationReceivedListener((event) => {
-        // listen to foreground notifications
-        if (event.request.trigger.type === 'push') {
-          const streamPayload = event.request.trigger.payload
-            ?.stream as StreamPayload;
-          processNonRingingNotificationStreamPayload(streamPayload);
-        }
-      });
     setUnsubscribeListener(() => {
       subscription.remove();
-      subscriptionForReceive.remove();
     });
   } else {
     const pushNotificationIosLib = getPushNotificationIosLib();
     pushNotificationIosLib.addEventListener('register', (token) => {
       setDeviceToken(token);
     });
-    pushNotificationIosLib.addEventListener('notification', (notification) => {
-      const data = notification.getData();
-      const streamPayload = data?.stream as StreamPayload;
-      // listen to foreground notifications
-      processNonRingingNotificationStreamPayload(streamPayload);
-      notification.finish(pushNotificationIosLib.FetchResult.NoData);
-    });
     setUnsubscribeListener(() => {
       pushNotificationIosLib.removeEventListener('register');
-      pushNotificationIosLib.removeEventListener('notification');
     });
   }
 }

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

@@ -1,5 +1,9 @@
 export type ExpoNotificationsLib = typeof import('expo-notifications');
 
+import type { Notification } from 'expo-notifications';
+
+export type ExpoNotification = Notification;
+
 let expoNotificationsLib: ExpoNotificationsLib | undefined;
 
 try {

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

@@ -1,5 +1,4 @@
 export * from './expoNotifications';
-export * from './expoTaskManager';
 export * from './firebaseMessaging';
 export * from './iosPushNotification';
 export * from './voipPushNotification';

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

@@ -3,6 +3,10 @@ export type PushNotificationIosLib =
 
 let pushNotificationIosLib: PushNotificationIosLib | undefined;
 
+import type { PushNotification } from '@react-native-community/push-notification-ios';
+
+export type PushNotificationiOSType = PushNotification;
+
 try {
   pushNotificationIosLib =
     require('@react-native-community/push-notification-ios').default;