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

package/src/utils/internal/callingx/callingx.ts

@@ -2,7 +2,7 @@
  * Internal utils for callingx library usage from video-client.
  * See @./registerSDKGlobals.ts for more usage details.
  */
-import { Platform } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 import type { EndCallReason } from '@stream-io/react-native-callingx';
 import { getCallingxLibIfAvailable } from '../../push/libs/callingx';
 import { waitForAudioSessionActivation } from './audioSessionPromise';
@@ -15,6 +15,46 @@ import { CallingState, videoLoggerSystem } from '@stream-io/video-client';
 
 const CallingxModule = getCallingxLibIfAvailable();
 
+/**
+ * Fallback when Telecom registration fails/times out on Android: no component would own audio
+ * (Telecom never took over), so re-establish StreamInCallManager in its classic (non-telecom)
+ * mode to keep the call audible.
+ */
+function recoverAudioToClassicMode() {
+  if (Platform.OS !== 'android') {
+    return;
+  }
+  if (!CallingxModule?.isSetup || !CallingxModule.isTelecomBacked) {
+    return;
+  }
+  // If a call is already registered, Telecom owns audio for it (the registration
+  // partially succeeded). Switching to classic mode here would fight Telecom's
+  // routing/focus — leave ownership intact.
+  if (CallingxModule.hasRegisteredCall()) {
+    videoLoggerSystem
+      .getLogger('callingx')
+      .debug(
+        'recoverAudioToClassicMode: Telecom already owns a registered call; skipping classic fallback',
+      );
+    return;
+  }
+  const StreamInCallManagerNativeModule = NativeModules.StreamInCallManager;
+  if (!StreamInCallManagerNativeModule) {
+    return;
+  }
+  const logger = videoLoggerSystem.getLogger('callingx');
+  logger.warn(
+    'Telecom registration failed; falling back to classic StreamInCallManager audio',
+  );
+  try {
+    StreamInCallManagerNativeModule.stop();
+    StreamInCallManagerNativeModule.setTelecomManagedMode(false);
+    StreamInCallManagerNativeModule.start();
+  } catch (error) {
+    logger.error('recoverAudioToClassicMode: failed to recover audio', error);
+  }
+}
+
 /**
  * Gets the call display name. To be used for display in native call screen.
  */
@@ -97,6 +137,7 @@ export async function registerOutgoingCall(call: Call) {
       `registerOutgoingCall: Error registering outgoing call in callingx: ${call.cid}`,
       error,
     );
+    recoverAudioToClassicMode();
   }
 }
 
@@ -146,6 +187,7 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
         `startCallingxCall: Error starting call in callingx: ${call.cid}`,
         error,
       );
+      recoverAudioToClassicMode();
     }
   } else if (isIncomingCall) {
     logger.debug(`joinCallingxCall: Joining incoming call ${call.cid}`);
@@ -187,6 +229,7 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
         `Error joining incoming call in callingx: ${call.cid}`,
         error,
       );
+      recoverAudioToClassicMode();
     }
   }
 }

package/src/utils/internal/registerSDKGlobals.ts

@@ -45,6 +45,31 @@ const shouldBypassForCallKit = ({
   return bypass;
 };
 
+/**
+ * On Android, when the call is registered with the Telecom stack (via CallingX),
+ * routing/focus/mode must be owned by Telecom (per Android guidance we must not use
+ * AudioManager.setCommunicationDevice / startBluetoothSco). Unlike iOS, we do NOT skip
+ * StreamInCallManager entirely — Telecom provides no proximity/keep-screen-on — instead we
+ * run it in "telecom-managed" mode where it only keeps proximity/keep-screen-on/mute.
+ */
+const isAndroidTelecomManaged = ({
+  isRingingTypeCall,
+}: {
+  isRingingTypeCall: boolean;
+}): boolean => {
+  if (Platform.OS !== 'android') {
+    return false;
+  }
+  if (!CallingxModule) {
+    return false;
+  }
+  return (
+    CallingxModule.isSetup &&
+    CallingxModule.isTelecomBacked &&
+    (isRingingTypeCall || CallingxModule.isOngoingCallsEnabled)
+  );
+};
+
 const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
   callingX: {
     joinCall: joinCallingxCall,
@@ -58,6 +83,17 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
         CallingxModule?.setDefaultAudioDeviceEndpointType(defaultDevice);
         return;
       }
+      if (isAndroidTelecomManaged({ isRingingTypeCall })) {
+        // Telecom owns routing; forward the sticky preference to callingx and run the
+        // in-call manager in telecom-managed mode (proximity/keep-screen-on only).
+        CallingxModule?.setDefaultAudioDeviceEndpointType(defaultDevice);
+        StreamInCallManagerNativeModule.setTelecomManagedMode(true);
+        StreamInCallManagerNativeModule.setup();
+        return;
+      }
+      if (Platform.OS === 'android') {
+        StreamInCallManagerNativeModule.setTelecomManagedMode(false);
+      }
       StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
         defaultDevice,
       );
@@ -67,6 +103,8 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
       if (shouldBypassForCallKit({ isRingingTypeCall })) {
         return;
       }
+      // Android telecom-managed calls still start (for proximity/keep-screen-on);
+      // the native side skips routing/focus internally.
       StreamInCallManagerNativeModule.start();
     },
     stop: ({ isRingingTypeCall }) => {

package/src/utils/push/android.ts

@@ -121,163 +121,164 @@ export const firebaseDataHandler = async (
     const asForegroundService = canListenToWS();
 
     if (asForegroundService) {
-      // Listen to call events from WS through fg service
-      // note: this will replace the current empty fg service runner
-      //we need to start service (e.g. by calling display incoming call) and than launch bg task, consider making those steps independent
-      await callingx.startBackgroundTask((_: unknown, stopTask: () => void) => {
-        return new Promise((resolve) => {
-          const finishBackgroundTask = () => {
+      // Listen to call events from WS with headless task, bound to call service.
+      // By this moment the call service is already running, so we can acquire the background task.
+      const backgroundTaskOwner = `push:${call_cid}`;
+      await callingx.acquireBackgroundTask(backgroundTaskOwner).catch((e) => {
+        logger.error(
+          `Failed to acquire background task for callCid: ${call_cid} error: ${e}`,
+        );
+      });
+
+      const finishBackgroundTask = () => {
+        callingx.log(
+          `Finishing background task for callCid: ${call_cid}`,
+          'debug',
+        );
+        callingx.releaseBackgroundTask(backgroundTaskOwner);
+      };
+
+      (async () => {
+        try {
+          const _client = await pushConfig.createStreamVideoClient();
+          if (!_client) {
+            logger.debug(
+              `Closing fg service as there is no client to create from push config`,
+            );
+            finishBackgroundTask();
+            return;
+          }
+
+          const callFromPush = await _client.onRingingCall(call_cid);
+          const { mustEndCall, endCallReason } = shouldCallBeClosed(
+            callFromPush,
+            data,
+          );
+          if (mustEndCall) {
+            logger.debug(
+              `Closing fg service callCid: ${call_cid} endCallReason: ${endCallReason}`,
+            );
+
             callingx.log(
-              `Finishing background task for callCid: ${call_cid}`,
+              `Ending call with callCid: ${call_cid} endCallReason: ${endCallReason}`,
               'debug',
             );
-            resolve(undefined);
-            stopTask();
-          };
+            callingx.endCallWithReason(call_cid, endCallReason);
+            callFromPush.leave({ reject: false }).catch((error) => {
+              logger.error(
+                `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
+              );
+            });
+            finishBackgroundTask();
+            return;
+          }
 
-          (async () => {
-            try {
-              const _client = await pushConfig.createStreamVideoClient();
-              if (!_client) {
-                logger.debug(
-                  `Closing fg service as there is no client to create from push config`,
-                );
-                finishBackgroundTask();
-                return;
-              }
+          const unsubscribeFunctions: Array<() => void> = [];
+          // check if service needs to be closed if accept/decline event was done on another device
+          const unsubscribe = callFromPush.on('all', (event) => {
+            const _canListenToWS = canListenToWS();
+            if (!_canListenToWS) {
+              logger.debug(
+                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+                { event },
+              );
+              unsubscribeFunctions.forEach((fn) => fn());
+
+              finishBackgroundTask();
+              return;
+            }
 
-              const callFromPush = await _client.onRingingCall(call_cid);
-              const { mustEndCall, endCallReason } = shouldCallBeClosed(
-                callFromPush,
-                data,
+            const {
+              mustEndCall: mustEndCallFromEvent,
+              endCallReason: endCallReasonFromEvent,
+            } = shouldCallBeClosed(callFromPush, data);
+            if (mustEndCallFromEvent) {
+              logger.debug(
+                `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed`,
+                { event },
               );
-              if (mustEndCall) {
+              unsubscribeFunctions.forEach((fn) => fn());
+
+              callingx.endCallWithReason(call_cid, endCallReasonFromEvent);
+              finishBackgroundTask();
+            }
+          });
+
+          // 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
+              ) {
                 logger.debug(
-                  `Closing fg service callCid: ${call_cid} endCallReason: ${endCallReason}`,
+                  `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
                 );
-
+                unsubscribeFunctions.forEach((fn) => fn());
                 callingx.log(
-                  `Ending call with callCid: ${call_cid} endCallReason: ${endCallReason}`,
+                  `Ending call with callCid: ${call_cid} callingState: ${callingState}`,
                   'debug',
                 );
-                callingx.endCallWithReason(call_cid, endCallReason);
-                callFromPush.leave({ reject: false }).catch((error) => {
-                  logger.error(
-                    `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
-                  );
-                });
-                resolve(undefined);
-                return;
+                finishBackgroundTask();
               }
+            },
+          );
 
-              const unsubscribeFunctions: Array<() => void> = [];
-              // check if service needs to be closed if accept/decline event was done on another device
-              const unsubscribe = callFromPush.on('all', (event) => {
-                const _canListenToWS = canListenToWS();
-                if (!_canListenToWS) {
-                  logger.debug(
-                    `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
-                    { event },
-                  );
-                  unsubscribeFunctions.forEach((fn) => fn());
-
-                  finishBackgroundTask();
-                  return;
-                }
-
-                const {
-                  mustEndCall: mustEndCallFromEvent,
-                  endCallReason: endCallReasonFromEvent,
-                } = shouldCallBeClosed(callFromPush, data);
-                if (mustEndCallFromEvent) {
-                  logger.debug(
-                    `Closing fg service from event callCid: ${call_cid} canListenToWS: ${_canListenToWS} shouldCallBeClosed`,
-                    { event },
-                  );
-                  unsubscribeFunctions.forEach((fn) => fn());
-
-                  callingx.endCallWithReason(call_cid, endCallReasonFromEvent);
-                  resolve(undefined);
-                }
-              });
-
-              // 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
-                  ) {
-                    logger.debug(
-                      `Closing fg service from callingState callCid: ${call_cid} callingState: ${callingState}`,
-                    );
-                    unsubscribeFunctions.forEach((fn) => fn());
-                    callingx.log(
-                      `Ending call with callCid: ${call_cid} callingState: ${callingState}`,
-                      'debug',
-                    );
-                    resolve(undefined);
-                  }
+          const endCallSubscription = callingx.addEventListener(
+            'endCall',
+            async ({ callId }: { callId: string }) => {
+              unsubscribeFunctions.forEach((fn) => fn());
+              try {
+                await callFromPush.leave({
+                  reject:
+                    callFromPush.state.callingState === CallingState.RINGING,
+                  reason: 'decline',
                 });
+              } catch (error) {
+                logger.error(
+                  `Failed to leave call with callCid: ${call_cid} error: ${error}`,
+                );
+              } finally {
+                callingx.log(
+                  `Ending call with callCid: ${call_cid} callId: ${callId}`,
+                  'debug',
+                );
+                finishBackgroundTask();
+              }
+            },
+          );
 
-              const endCallSubscription = callingx.addEventListener(
-                'endCall',
-                async ({ callId }: { callId: string }) => {
-                  unsubscribeFunctions.forEach((fn) => fn());
-                  try {
-                    await callFromPush.leave({
-                      reject:
-                        callFromPush.state.callingState ===
-                        CallingState.RINGING,
-                      reason: 'decline',
-                    });
-                  } catch (error) {
-                    logger.error(
-                      `Failed to leave call with callCid: ${call_cid} error: ${error}`,
-                    );
-                  } finally {
-                    callingx.log(
-                      `Ending call with callCid: ${call_cid} callId: ${callId}`,
-                      'debug',
-                    );
-                    resolve(undefined);
-                  }
-                },
-              );
-
-              //stop background task when app comes to foreground
-              const appStateSubscription = AppState.addEventListener(
-                'change',
-                (nextAppState) => {
-                  const _canListenToWS = canListenToWS();
-                  callingx.log(
-                    `AppState changed to: ${nextAppState} for callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
-                    'debug',
-                  );
-                  if (!_canListenToWS) {
-                    unsubscribeFunctions.forEach((fn) => fn());
-                    finishBackgroundTask();
-                    return;
-                  }
-                },
-              );
-
-              unsubscribeFunctions.push(unsubscribe);
-              unsubscribeFunctions.push(() => stateSubscription.unsubscribe());
-              unsubscribeFunctions.push(() => endCallSubscription.remove());
-              unsubscribeFunctions.push(() => appStateSubscription.remove());
-              pushUnsubscriptionCallbacks.get(call_cid)?.forEach((cb) => cb());
-              pushUnsubscriptionCallbacks.set(call_cid, unsubscribeFunctions);
-            } catch (error) {
+          //stop background task when app comes to foreground
+          const appStateSubscription = AppState.addEventListener(
+            'change',
+            (nextAppState) => {
+              const _canListenToWS = canListenToWS();
               callingx.log(
-                `Failed to start background task with callCid: ${call_cid} error: ${error}`,
-                'error',
+                `AppState changed to: ${nextAppState} for callCid: ${call_cid} canListenToWS: ${_canListenToWS}`,
+                'debug',
               );
-              finishBackgroundTask();
-            }
-          })();
-        });
-      });
+              if (!_canListenToWS) {
+                unsubscribeFunctions.forEach((fn) => fn());
+                finishBackgroundTask();
+                return;
+              }
+            },
+          );
+
+          unsubscribeFunctions.push(unsubscribe);
+          unsubscribeFunctions.push(() => stateSubscription.unsubscribe());
+          unsubscribeFunctions.push(() => endCallSubscription.remove());
+          unsubscribeFunctions.push(() => appStateSubscription.remove());
+          pushUnsubscriptionCallbacks.get(call_cid)?.forEach((cb) => cb());
+          pushUnsubscriptionCallbacks.set(call_cid, unsubscribeFunctions);
+        } catch (error) {
+          callingx.log(
+            `Failed to start background task with callCid: ${call_cid} error: ${error}`,
+            'error',
+          );
+          finishBackgroundTask();
+        }
+      })();
     }
 
     if (asForegroundService) {

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

@@ -84,6 +84,10 @@ export function extractCallingExpOptions(
       androidOptions.skipIncomingPushInForeground =
         pushConfig.android.skipIncomingPushInForeground;
     }
+    if (pushConfig.android.defaultDeviceEndpointType !== undefined) {
+      androidOptions.defaultDeviceEndpointType =
+        pushConfig.android.defaultDeviceEndpointType;
+    }
   }
 
   if (foregroundServiceConfig.android.channel) {

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.40.1-beta.0';
+export const version = '1.40.2';

package/expo-config-plugin/dist/withBuildProperties.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const expo_build_properties_1 = require("expo-build-properties");
-const withStreamVideoReactNativeBuildProperties = (configuration) => {
-    return (0, expo_build_properties_1.withBuildProperties)(configuration, {
-        android: {
-            extraProguardRules: `
--keep class org.webrtc.** { *; }
-`,
-        },
-    });
-};
-exports.default = withStreamVideoReactNativeBuildProperties;