@stream-io/video-react-native-sdk 1.43.0 → 1.45.0

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

@@ -0,0 +1,252 @@
+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);
+  };
+
+  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`);
+      if (asForegroundService) {
+        finishBackgroundTask();
+      }
+      await callingx.stopService();
+      pushUnsubscriptionCallbacks.delete(call_cid);
+      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');
+    if (asForegroundService) {
+      finishBackgroundTask();
+    }
+    await callingx.stopService();
+    pushUnsubscriptionCallbacks.delete(call_cid);
+    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,13 +1,13 @@
-import { lib, type Type } from './lib';
-import { videoLoggerSystem } from '@stream-io/video-client';
-
-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. ' +
@@ -17,20 +17,12 @@ export function getFirebaseMessagingLib(): FirebaseMessagingType {
   return lib;
 }
 
-export function getFirebaseMessagingLibNoThrow(
-  isExpo: boolean,
-): FirebaseMessagingType | undefined {
-  if (!lib) {
-    const logger = videoLoggerSystem.getLogger(
-      'getFirebaseMessagingLibNoThrow',
-    );
-    logger.debug(
-      `${
-        isExpo
-          ? 'In Expo, @react-native-firebase/messaging library is required to receive ringing notifications in app killed state for Android.'
-          : ''
-      }${INSTALLATION_INSTRUCTION}`,
-    );
-  }
-  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}`);
+    });
   });
 }

package/src/utils/push/utils.ts

@@ -1,4 +1,4 @@
-import type { FirebaseMessagingTypes } from './libs/firebaseMessaging';
+import type { FirebaseRemoteMessage } from './libs/firebaseMessaging';
 import type { NonRingingPushEvent } from '../StreamVideoRN/types';
 
 export type StreamPushPayload =
@@ -9,8 +9,6 @@ export type StreamPushPayload =
     }
   | undefined;
 
-export function isFirebaseStreamVideoMessage(
-  message: FirebaseMessagingTypes.RemoteMessage,
-) {
+export function isFirebaseStreamVideoMessage(message: FirebaseRemoteMessage) {
   return message.data?.sender === 'stream.video';
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.43.0';
+export const version = '1.45.0';