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

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

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

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

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

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

@@ -10,12 +10,9 @@ import type {
 } from '../../StreamVideoRN/types';
 import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
 import { pushUnsubscriptionCallbacks } from './constants';
-import { AppState } from 'react-native';
-import type { EndCallReason } from '@stream-io/react-native-callingx';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
-const logger = videoLoggerSystem.getLogger('callingx');
 type CanAddPushWSSubscriptionsRef = { current: boolean };
 
 /**
@@ -27,40 +24,44 @@ export const shouldCallBeEnded = (
   created_by_id: string | undefined,
   receiver_id: string | undefined,
 ) => {
+  /* callkeep reasons for ending a call
+    FAILED: 1,
+    REMOTE_ENDED: 2,
+    UNANSWERED: 3,
+    ANSWERED_ELSEWHERE: 4,
+    DECLINED_ELSEWHERE: 5,
+    MISSED: 6
+  */
   const callSession = callFromPush.state.session;
   const rejected_by = callSession?.rejected_by;
   const accepted_by = callSession?.accepted_by;
   let mustEndCall = false;
-  let endCallReason: EndCallReason = 'unknown';
-
-  if (callFromPush.state.endedAt) {
-    mustEndCall = true;
-    endCallReason = 'remote';
-  } else if (created_by_id && rejected_by) {
+  let callkeepReason = 0;
+  if (created_by_id && rejected_by) {
     if (rejected_by[created_by_id]) {
-      // call was cancelled by the caller before the receiver could answer
+      // call was cancelled by the caller
       mustEndCall = true;
-      endCallReason = 'canceled';
+      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;
-      endCallReason = 'rejected';
+      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;
-      endCallReason = 'answeredElsewhere';
+      callkeepReason = 4;
     }
   }
   videoLoggerSystem
     .getLogger('shouldCallBeEnded')
     .debug(
-      `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} endCallReason: ${endCallReason}`,
+      `callCid: ${callFromPush.cid} mustEndCall: ${mustEndCall} callkeepReason: ${callkeepReason}`,
     );
-  return { mustEndCall, endCallReason };
+  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:
@@ -70,95 +71,71 @@ export const shouldCallBeEnded = (
 export const processCallFromPushInBackground = async (
   pushConfig: PushConfig,
   call_cid: string,
-  action: 'accept' | 'decline' | 'pressed' | 'backgroundDelivered',
-  /**
-   * Callback to inform iOS CallKit that the action can be fulfilled
-   * Needed for iOS CallKit fullfillment of action
-   * as per ios docs "Instead, wait until you establish a connection and then fulfill the object."
-   * This means we wait until call.get() is done and call.join() or call.leave() is invoked (not completed) to fulfill the action
-   */
-  onIOSActionCanBeFulfilled: (didFail: boolean) => void,
+  action: Parameters<typeof processCallFromPush>[2],
 ) => {
   let videoClient: StreamVideoClient | undefined;
 
   try {
     videoClient = await pushConfig.createStreamVideoClient();
     if (!videoClient) {
-      throw new Error('createStreamVideoClient returned null');
+      return;
     }
   } catch (e) {
-    logger.error(
-      'processCallFromPushInBackground: failed to create video client',
-      e,
+    const logger = videoLoggerSystem.getLogger(
+      'processCallFromPushInBackground',
     );
-    onIOSActionCanBeFulfilled(true);
+    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 videoClient.onRingingCall(call_cid);
+    callFromPush = await client.onRingingCall(call_cid);
   } catch (e) {
-    logger.error(
-      'processCallFromPushInBackground: failed to fetch call from push notification',
-      e,
-    );
-    onIOSActionCanBeFulfilled(true);
+    const logger = videoLoggerSystem.getLogger('processCallFromPush');
+    logger.error('failed to fetch call from push notification', e);
     return;
   }
-  if (action === 'accept') {
-    if (pushConfig.publishOptions) {
-      callFromPush.updatePublishOptions(pushConfig.publishOptions);
-    }
-    logger.debug(
-      `joining call from push notification with callCid: ${callFromPush.cid}`,
-    );
-    const callingState = callFromPush.state.callingState;
-    if (
-      callingState !== CallingState.RINGING &&
-      callingState !== CallingState.IDLE
-    ) {
-      logger.debug(
-        `skipping join call as it is not in ringing or idle state from push notification. callCid: ${callFromPush.cid}`,
-      );
-      onIOSActionCanBeFulfilled(true);
-      return;
-    }
-    try {
-      onIOSActionCanBeFulfilled(false);
+  // 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);
+      }
+      videoLoggerSystem
+        .getLogger('processCallFromPush')
+        .debug(
+          `joining call from push notification with callCid: ${callFromPush.cid}`,
+        );
       await callFromPush.join();
-    } catch (e) {
-      logger.warn(
-        'processCallFromPushInBackground: failed to join call from push notification',
-        e,
-      );
-    }
-  } else if (action === 'decline') {
-    const alreadyLeft = callFromPush.state.callingState === CallingState.LEFT;
-    if (alreadyLeft) {
-      onIOSActionCanBeFulfilled(false);
-      return;
-    }
-    const canReject =
-      callFromPush.state.callingState === CallingState.RINGING ||
-      callFromPush.state.callingState === CallingState.IDLE;
-    const isCurrentUserMember = callFromPush.state.members.some(
-      (member) => member.user_id === callFromPush.currentUserId,
-    );
-    const reject = canReject && isCurrentUserMember;
-    logger.debug(
-      `declining call from push notification with callCid: ${callFromPush.cid} reject: ${reject}`,
-    );
-    try {
-      await callFromPush.leave({ reject, reason: 'decline' });
-      onIOSActionCanBeFulfilled(false);
-    } catch (e) {
-      logger.warn(
-        'processCallFromPushInBackground: failed to decline call from push notification',
-        e,
-      );
-      onIOSActionCanBeFulfilled(true);
+    } else if (action === 'decline') {
+      const canReject =
+        callFromPush.state.callingState === CallingState.RINGING;
+      videoLoggerSystem
+        .getLogger('processCallFromPush')
+        .debug(
+          `declining call from push notification with callCid: ${callFromPush.cid} reject: ${canReject}`,
+        );
+      await callFromPush.leave({ reject: canReject, reason: 'decline' });
     }
+  } catch (e) {
+    const logger = videoLoggerSystem.getLogger('processCallFromPush');
+    logger.warn(`failed to process ${action} call from push notification`, e);
   }
 };
 
@@ -186,13 +163,10 @@ export const processNonIncomingCallFromPush = async (
       await callFromPush.get();
     }
   } catch (e) {
-    const nonRingingCallLogger = videoLoggerSystem.getLogger(
+    const logger = videoLoggerSystem.getLogger(
       'processNonIncomingCallFromPush',
     );
-    nonRingingCallLogger.error(
-      'failed to fetch call from push notification',
-      e,
-    );
+    logger.error('failed to fetch call from push notification', e);
     return;
   }
   onNewCallNotification(callFromPush, nonRingingNotificationType);
@@ -217,21 +191,3 @@ export const clearPushWSEventSubscriptions = (call_cid: string) => {
 export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
   current: true,
 };
-
-export const canListenToWS = () =>
-  canAddPushWSSubscriptionsRef.current && AppState.currentState !== 'active';
-
-export const shouldCallBeClosed = (
-  call: Call,
-  pushData: { [key: string]: string | object },
-) => {
-  const created_by_id = pushData?.created_by_id as string;
-  const receiver_id = pushData?.receiver_id as string;
-
-  const { mustEndCall, endCallReason } = shouldCallBeEnded(
-    call,
-    created_by_id,
-    receiver_id,
-  );
-  return { mustEndCall, endCallReason };
-};

package/src/utils/push/ios.ts

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

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

@@ -0,0 +1,16 @@
+export type RNCallKeepType = typeof import('react-native-callkeep').default;
+
+let callkeep: RNCallKeepType | undefined;
+
+try {
+  callkeep = require('react-native-callkeep').default;
+} catch {}
+
+export function getCallKeepLib() {
+  if (!callkeep) {
+    throw Error(
+      'react-native-callkeep library is not installed. Please see https://github.com/react-native-webrtc/react-native-callkeep#Installation for installation instructions',
+    );
+  }
+  return callkeep;
+}

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

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

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

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

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

@@ -0,0 +1,17 @@
+export type VoipPushNotificationType =
+  typeof import('react-native-voip-push-notification').default;
+
+let voipPushNotification: VoipPushNotificationType | undefined;
+
+try {
+  voipPushNotification = require('react-native-voip-push-notification').default;
+} catch {}
+
+export function getVoipPushNotificationLib() {
+  if (!voipPushNotification) {
+    throw Error(
+      "react-native-voip-push-notification library is not installed. Please install it using 'yarn add react-native-voip-push-notification' or 'npm i react-native-voip-push-notification --save'",
+    );
+  }
+  return voipPushNotification;
+}