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

package/src/hooks/useAndroidKeepCallAliveEffect.ts

@@ -9,7 +9,10 @@ import {
   Platform,
 } from 'react-native';
 import { CallingState, videoLoggerSystem } from '@stream-io/video-client';
-import { keepCallAliveCallRef } from '../utils/keepCallAliveHeadlessTask';
+import {
+  endKeepCallAliveHeadlessTask,
+  keepCallAliveCallRef,
+} from '../utils/keepCallAliveHeadlessTask';
 import { getCallingxLibIfAvailable } from '../utils/push/libs';
 
 async function stopForegroundServiceNoThrow() {
@@ -21,7 +24,10 @@ async function stopForegroundServiceNoThrow() {
   }
 }
 
-async function startForegroundService(call_cid: string) {
+/**
+ * @returns true when the native foreground service was asked to start.
+ */
+async function startForegroundService(call_cid: string): Promise<boolean> {
   const logger = videoLoggerSystem.getLogger('startForegroundService');
   const isCallAliveConfigured = await (async () => {
     try {
@@ -32,10 +38,14 @@ async function startForegroundService(call_cid: string) {
     }
   })();
   if (!isCallAliveConfigured) {
-    logger.info(
-      'KeepCallAlive is not configured. Skipping foreground service setup.',
+    logger.warn(
+      'KeepCallAlive is not configured, the call will not survive the app going to the ' +
+        'background: audio publishing stops and the user is eventually dropped from the call. ' +
+        'Declare android.permission.FOREGROUND_SERVICE and ' +
+        'android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK in the app manifest (see logcat, ' +
+        'tag StreamVideoReactNative, for the exact list of missing permissions).',
     );
-    return;
+    return false;
   }
   // Check for notification permission (Android 13+) before starting the service.
   const hasPostNotificationsPermission =
@@ -47,7 +57,7 @@ async function startForegroundService(call_cid: string) {
     logger.info(
       'Notification permission not granted, can not start foreground service to keep the call alive',
     );
-    return;
+    return false;
   }
   const videoConfig = StreamVideoRN.getConfig();
   const foregroundServiceConfig = videoConfig.foregroundService;
@@ -58,19 +68,34 @@ async function startForegroundService(call_cid: string) {
   // NOTE: we use requestAnimationFrame to ensure that the foreground service is started after all the current UI operations are done
   // this is a workaround for the crash - android.app.RemoteServiceException$ForegroundServiceDidNotStartInTimeException: Context.startForegroundService() did not then call Service.startForeground()
   // this crash was reproducible only in some android devices
-  requestAnimationFrame(async () => {
-    try {
-      await NativeModules.StreamVideoReactNative.startKeepCallAliveService(
-        call_cid,
-        channel.id,
-        channel.name,
-        notificationTexts.title,
-        notificationTexts.body,
-        smallIconName ?? null,
-      );
-    } catch (e) {
-      logger.warn('Failed to start keep-call-alive foreground service', e);
-    }
+  return new Promise<boolean>((resolve) => {
+    requestAnimationFrame(async () => {
+      // The service declares the camera/microphone foreground service types, which are
+      // while-in-use permissions: Android requires startForegroundService() to be called while the
+      // app has a visible activity, otherwise the start is rejected. The frame we deferred to can
+      // land after the app left the foreground, so re-check before calling native.
+      if (AppState.currentState !== 'active') {
+        logger.info(
+          'App is no longer in the foreground, not starting the keep-call-alive foreground service',
+        );
+        resolve(false);
+        return;
+      }
+      try {
+        await NativeModules.StreamVideoReactNative.startKeepCallAliveService(
+          call_cid,
+          channel.id,
+          channel.name,
+          notificationTexts.title,
+          notificationTexts.body,
+          smallIconName ?? null,
+        );
+        resolve(true);
+      } catch (e) {
+        logger.warn('Failed to start keep-call-alive foreground service', e);
+        resolve(false);
+      }
+    });
   });
 }
 
@@ -147,8 +172,18 @@ export const useAndroidKeepCallAliveEffect = () => {
           return;
         }
 
-        await startForegroundService(activeCallCid);
-        foregroundServiceStartedRef.current = true;
+        try {
+          // only mark as started when native actually accepted the start, so that a later render
+          // while still joined can retry.
+          foregroundServiceStartedRef.current =
+            await startForegroundService(activeCallCid);
+        } catch (e) {
+          // run() is intentionally not awaited, so anything thrown here would surface as an
+          // unhandled rejection. Leave the ref false so a later render can retry.
+          videoLoggerSystem
+            .getLogger('useAndroidKeepCallAliveEffect')
+            .warn('Failed to start the keep-call-alive foreground service', e);
+        }
       };
 
       // ensure that app is active before running the function
@@ -170,6 +205,8 @@ export const useAndroidKeepCallAliveEffect = () => {
     } else if (isCallEnded) {
       if (foregroundServiceStartedRef.current) {
         keepCallAliveCallRef.current = undefined;
+        // let the headless task resolve so RN unwinds it, then stop the foreground service
+        endKeepCallAliveHeadlessTask();
         // stop foreground service when the call is not active
         stopForegroundServiceNoThrow();
         foregroundServiceStartedRef.current = false;
@@ -188,6 +225,7 @@ export const useAndroidKeepCallAliveEffect = () => {
       // stop foreground service when this effect is unmounted
       if (foregroundServiceStartedRef.current) {
         keepCallAliveCallRef.current = undefined;
+        endKeepCallAliveHeadlessTask();
         stopForegroundServiceNoThrow();
         foregroundServiceStartedRef.current = false;
       }

package/src/modules/call-manager/native-module.d.ts

@@ -32,6 +32,20 @@ export interface CallManager extends NativeModule {
    */
   setTelecomManagedMode: (enabled: boolean) => void;
 
+  /**
+   * Opt out of the Android 11+ communication-mode keep-alive workaround.
+   *
+   * On Android 11+ (API 30) the OS resets `MODE_IN_COMMUNICATION` ~6s after it is
+   * set when there is no active voice-communication playback/recording, which
+   * breaks audio routing and AEC. By default the SDK plays a silent
+   * voice-communication track for the duration of a communicator-role call to
+   * prevent this. Pass `true` to disable it. Sticky for the process lifetime.
+   *
+   * No-op on iOS and on Android below API 30. See
+   * https://issuetracker.google.com/issues/209493718
+   */
+  setDisableCommunicationModeWorkaround: (disabled: boolean) => void;
+
   /**
    * Choose an audio device endpoint by its stable id.
    * @param deviceId - The id of the audio device to choose (`AudioDevice.id`).

package/src/utils/StreamVideoRN/index.ts

@@ -158,6 +158,33 @@ export class StreamVideoRN {
     pushLogoutCallbacks.current = [];
   }
 
+  /**
+   * Android only. Opt out of the Android 11+ communication-mode keep-alive.
+   *
+   * By default the SDK plays a silent voice-communication track for the duration of a
+   * communicator-role call, so Android does not reset `MODE_IN_COMMUNICATION` ~6s after it is
+   * set (which breaks audio routing and echo cancellation).
+   * See {@link https://issuetracker.google.com/issues/209493718}
+   *
+   * Call this at app start, alongside {@link setPushConfig} — the native audio manager
+   * rejects the change once it has been activated for a call. No-op on iOS and on
+   * Android below API 30.
+   */
+  static setDisableCommunicationModeWorkaround(disabled: boolean) {
+    if (Platform.OS !== 'android') {
+      return;
+    }
+    try {
+      NativeModules.StreamInCallManager?.setDisableCommunicationModeWorkaround(
+        disabled,
+      );
+    } catch (error) {
+      videoLoggerSystem
+        .getLogger('StreamVideoRN')
+        .warn('setDisableCommunicationModeWorkaround failed', error);
+    }
+  }
+
   /**
    * Play native busy tone for call rejection
    */

package/src/utils/StreamVideoRN/types.ts

@@ -176,8 +176,7 @@ export type StreamVideoConfig = {
        */
       notificationTexts: KeepAliveAndroidNotificationTexts;
       /**
-       * The task to run in the foreground service
-       * The task must resolve a promise once complete
+       * The task to run in the foreground service.
        */
       taskToRun: (call: Call) => Promise<void>;
     };

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

@@ -55,15 +55,24 @@ export function getCallDisplayName(
   return names.sort().join(', ');
 }
 
-function getCallDisplayNameFromCall(call: Call): string {
-  return (
+/**
+ * Args shared by the callingx call registration APIs:
+ * `(callId, phoneNumber, callerName, hasVideo)`.
+ */
+function getCallingxCallArgs(call: Call): [string, string, string, boolean] {
+  const callDisplayName =
     call.state.custom?.display_name ||
     getCallDisplayName(
       call.state.members,
       call.state.participants,
       call.currentUserId,
-    )
-  );
+    );
+  return [
+    call.cid, // unique id for call
+    call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
+    callDisplayName, // display name for display in call screen
+    call.state.settings?.video?.enabled ?? false, // is video call?
+  ];
 }
 
 export async function registerOutgoingCall(call: Call) {
@@ -84,13 +93,7 @@ export async function registerOutgoingCall(call: Call) {
 
   try {
     logger.debug(`registerOutgoingCall: Registering outgoing call ${call.cid}`);
-    const callDisplayName = getCallDisplayNameFromCall(call);
-    await CallingxModule.startCall(
-      call.cid, // unique id for call
-      call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
-      callDisplayName, // display name for display in call screen
-      call.state.settings?.video?.enabled ?? false, // is video call?
-    );
+    await CallingxModule.startCall(...getCallingxCallArgs(call));
   } catch (error) {
     logger.error(
       `registerOutgoingCall: Error registering outgoing call in callingx: ${call.cid}`,
@@ -119,67 +122,45 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
   const logger = videoLoggerSystem.getLogger('callingx');
   const isOutcomingCall = call.ringing && call.isCreatedByMe;
   const isIncomingCall = call.ringing && !call.isCreatedByMe;
+  const isOngoingCall = (c: Call) =>
+    !c.ringing &&
+    CallingxModule.isOngoingCallsEnabled &&
+    !c.isOwnTracksLoopbackAllowed;
 
-  const startCallInCallingx = async () => {
-    logger.debug(`joinCallingxCall: Joining call ${call.cid}`);
-    const callDisplayName = getCallDisplayNameFromCall(call);
-    await CallingxModule.startCall(
-      call.cid, // unique id for call
-      call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
-      callDisplayName, // display name for display in call screen
-      call.state.settings?.video?.enabled ?? false, // is video call?
-    );
-  };
+  if (!isIncomingCall && !isOutcomingCall && !isOngoingCall(call)) {
+    return;
+  }
 
-  if (
-    isOutcomingCall ||
-    (!call.ringing && CallingxModule.isOngoingCallsEnabled)
-  ) {
-    try {
-      await startCallInCallingx();
-    } catch (error) {
-      logger.error(
-        `startCallingxCall: Error starting call in callingx: ${call.cid}`,
-        error,
+  try {
+    const activeCallsToLeave = activeCalls.filter(
+      (c) =>
+        c.cid !== call.cid &&
+        (c.ringing || isOngoingCall(c)) &&
+        c.state.callingState !== CallingState.LEFT,
+    );
+    for (const activeCall of activeCallsToLeave) {
+      logger.debug(
+        `leaving currently-active-call:${activeCall.cid} before joining the call:${call.cid}`,
       );
+      await activeCall.leave({ reason: 'cancel' }).catch((e) => {
+        logger.error(`failed to leave active call ${activeCall.cid}`, e);
+      });
     }
-  } else if (isIncomingCall) {
-    logger.debug(`joinCallingxCall: Joining incoming call ${call.cid}`);
-
-    try {
-      // Leave any existing active ringing calls before joining a new ringing call
-      const activeCallsToLeave = activeCalls.filter(
-        (c) =>
-          c.cid !== call.cid &&
-          c.ringing &&
-          c.state.callingState !== CallingState.LEFT,
-      );
-      for (const activeCall of activeCallsToLeave) {
-        logger.debug(
-          `leaving active call ${activeCall.cid} before joining ${call.cid}`,
-        );
-        await activeCall.leave({ reason: 'cancel' }).catch((e) => {
-          logger.error(`failed to leave active call ${activeCall.cid}`, e);
-        });
-      }
-      // Awaits native CallKit/Telecom registration before answering.
-      // Safe to call even if the call is already registered (e.g. from VoIP push) --
-      // iOS early-returns with no error, Android sends the registered broadcast.
-      const callDisplayName = getCallDisplayNameFromCall(call);
-      await CallingxModule.displayIncomingCall(
-        call.cid, // unique id for call
-        call.state.createdBy?.id ?? callDisplayName, // handle for native call UI (prefer createdBy user id, fallback to call display name)
-        callDisplayName, // display name for display in call screen
-        call.state.settings?.video?.enabled ?? false, // is video call?
-      );
-
+    logger.debug(
+      `joinCallingxCall: Joining call ${call.cid} isIncoming: ${isIncomingCall} isOutgoing: ${isOutcomingCall}`,
+    );
+    const callArgs = getCallingxCallArgs(call);
+    if (isIncomingCall) {
+      await CallingxModule.displayIncomingCall(...callArgs);
       await CallingxModule.answerIncomingCall(call.cid);
-    } catch (error) {
-      logger.error(
-        `Error joining incoming call in callingx: ${call.cid}`,
-        error,
-      );
+    } else {
+      await CallingxModule.startCall(...callArgs);
     }
+  } catch (error) {
+    logger.error(
+      `startCallingxCall: Error starting call in callingx: ${call.cid} isIncoming: ${isIncomingCall} isOutgoing: ${isOutcomingCall}`,
+      error,
+    );
   }
 }
 

package/src/utils/keepCallAliveHeadlessTask.ts

@@ -13,6 +13,21 @@ export const keepCallAliveCallRef: { current: Call | undefined } = {
   current: undefined,
 };
 
+let resolveRunningTask: (() => void) | undefined;
+
+/**
+ * Ends the currently running keep-alive headless task.
+ *
+ * The task's promise is app-provided (`foregroundService.android.taskToRun`) and by default never
+ * resolves, so stopping the native service alone would leave the task registered in
+ * `HeadlessJsTaskContext` forever - which keeps RN's timer choreographer callback posted for the
+ * rest of the process lifetime. Resolving it here lets React Native unwind the task properly.
+ */
+export const endKeepCallAliveHeadlessTask = () => {
+  resolveRunningTask?.();
+  resolveRunningTask = undefined;
+};
+
 function registerKeepCallAliveHeadlessTaskOnce() {
   if (Platform.OS !== 'android') return;
 
@@ -42,10 +57,37 @@ function registerKeepCallAliveHeadlessTaskOnce() {
 
       const config = StreamVideoRN.getConfig();
       const taskToRun = config.foregroundService.android.taskToRun;
+      // A previous task (if any) must not keep hanging around.
+      endKeepCallAliveHeadlessTask();
+      const taskEnded = new Promise<void>((resolve) => {
+        resolveRunningTask = resolve;
+      });
+      const ownResolver = resolveRunningTask;
+
+      // React Native stops the foreground service as soon as the promise returned from here
+      // settles. `taskToRun` is app-provided and may resolve early - or immediately - so its
+      // completion must not end the keep-alive: that would drop the call's background protection
+      // while the call is still ongoing. The task's lifetime is owned by the SDK instead, and ends
+      // via endKeepCallAliveHeadlessTask() when the call is left.
+      (async () => {
+        try {
+          await taskToRun(call);
+          logger.debug(
+            'Keep-alive taskToRun completed, keeping the call alive until the call ends',
+          );
+        } catch (e) {
+          logger.error('Keep-alive headless task failed', e);
+        }
+      })();
+
       try {
-        await taskToRun(call);
-      } catch (e) {
-        logger.error('Keep-alive headless task failed', e);
+        await taskEnded;
+      } finally {
+        // a newer task may already have installed its own resolver - clearing it here would leave
+        // that task with no way to be ended.
+        if (resolveRunningTask === ownResolver) {
+          resolveRunningTask = undefined;
+        }
       }
     },
   );

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

@@ -79,6 +79,35 @@ export const onRingNotificationReceived = async (
     callingx.releaseBackgroundTask(backgroundTaskOwner);
   };
 
+  /**
+   * Gives up on this push: dismisses the call the native push path already displayed, then asks
+   * the call service to stop. `stopService` is only a request — it no-ops while any other call is
+   * registered or being registered — so this call must be ended explicitly rather than relying on
+   * the service teardown to wipe it.
+   */
+  const abandonPush = async () => {
+    if (asForegroundService) {
+      finishBackgroundTask();
+    }
+    // Each step is contained on its own: failing to dismiss the call must not skip the stop
+    // request, and neither may skip the unsubscription cleanup — a stale entry makes every later
+    // push for this cid look like a duplicate and get discarded.
+    try {
+      await callingx.endCallWithReason(call_cid, 'error');
+    } catch (error) {
+      nativeLog(`Failed to end call ${call_cid}: ${error}`, 'error');
+    }
+    try {
+      await callingx.stopService();
+    } catch (error) {
+      nativeLog(
+        `Failed to stop the call service for ${call_cid}: ${error}`,
+        'error',
+      );
+    }
+    pushUnsubscriptionCallbacks.delete(call_cid);
+  };
+
   if (asForegroundService) {
     // initialize the callback array immediately to avoid race condition
     pushUnsubscriptionCallbacks.set(call_cid, []);
@@ -98,21 +127,13 @@ export const onRingNotificationReceived = async (
     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);
+      await abandonPush();
       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);
+    await abandonPush();
     return;
   }
 

package/src/version.ts

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