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

package/src/utils/internal/registerSDKGlobals.ts

@@ -1,20 +1,58 @@
 import { StreamRNVideoSDKGlobals } from '@stream-io/video-client';
-import { NativeModules } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
+import { getCallingxLibIfAvailable } from '../push/libs/callingx';
 
 const StreamInCallManagerNativeModule = NativeModules.StreamInCallManager;
 
+const CallingxModule = getCallingxLibIfAvailable();
+
+/**
+ * Checks if StreamInCallManager should be bypassed because CallKit is handling
+ * the audio session via CallingX.
+ *
+ * On iOS, when CallingX is set up and has a registered call, the audio session
+ * is managed by CallKit through CallingxImpl.swift.
+ * In this case, StreamInCallManager should not run to avoid conflicting audio
+ * session configurations.
+ */
+const shouldBypassForCallKit = ({
+  isRingingTypeCall,
+}: {
+  isRingingTypeCall: boolean;
+}): boolean => {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  if (!CallingxModule) {
+    return false;
+  }
+  const bypass =
+    CallingxModule.isSetup &&
+    (isRingingTypeCall || CallingxModule.isOngoingCallsEnabled);
+  return bypass;
+};
+
 const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
   callManager: {
-    setup: ({ defaultDevice }) => {
+    setup: ({ defaultDevice, isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
         defaultDevice,
       );
       StreamInCallManagerNativeModule.setup();
     },
-    start: () => {
+    start: ({ isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.start();
     },
-    stop: () => {
+    stop: ({ isRingingTypeCall }) => {
+      if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        return;
+      }
       StreamInCallManagerNativeModule.stop();
     },
   },

package/src/utils/keepCallAliveHeadlessTask.ts

@@ -0,0 +1,54 @@
+import { AppRegistry, Platform } from 'react-native';
+import type { Call } from '@stream-io/video-client';
+import { videoLoggerSystem } from '@stream-io/video-client';
+import { StreamVideoRN } from './StreamVideoRN';
+
+export const KEEP_CALL_ALIVE_HEADLESS_TASK_NAME = 'StreamVideoKeepCallAlive';
+
+/**
+ * The keep-alive headless task needs access to the active `Call` instance.
+ * The keep-alive hook will set this reference before starting the native service.
+ */
+export const keepCallAliveCallRef: { current: Call | undefined } = {
+  current: undefined,
+};
+
+function registerKeepCallAliveHeadlessTaskOnce() {
+  if (Platform.OS !== 'android') return;
+
+  AppRegistry.registerHeadlessTask(
+    KEEP_CALL_ALIVE_HEADLESS_TASK_NAME,
+    () => async (data: { callCid?: string } | undefined) => {
+      const logger = videoLoggerSystem.getLogger(
+        'KEEP_CALL_ALIVE_HEADLESS_TASK',
+      );
+      const callCid = data?.callCid;
+
+      const call = keepCallAliveCallRef.current;
+      if (!call) {
+        logger.warn(
+          'No active call instance available for keep-alive task; skipping.',
+          { callCid },
+        );
+        return;
+      }
+      if (callCid && call.cid && call.cid !== callCid) {
+        logger.warn(
+          'Keep-alive task callCid does not match active call; skipping.',
+          { callCid, activeCallCid: call.cid },
+        );
+        return;
+      }
+
+      const config = StreamVideoRN.getConfig();
+      const taskToRun = config.foregroundService.android.taskToRun;
+      try {
+        await taskToRun(call);
+      } catch (e) {
+        logger.error('Keep-alive headless task failed', e);
+      }
+    },
+  );
+}
+
+registerKeepCallAliveHeadlessTaskOnce();