@stream-io/video-react-native-sdk 1.40.1 → 1.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.40.1",
+  "version": "1.41.0",
   "description": "Stream Video SDK for React Native",
   "author": "https://getstream.io",
   "homepage": "https://getstream.io/video/docs/react-native/",
@@ -17,6 +17,7 @@
     "build": "yarn copy-version && bob build && yarn build:expo-plugin",
     "test:expo-plugin": "jest --config=expo-config-plugin/jest.config.js --coverage",
     "test": "yarn copy-version && jest --coverage && yarn test:expo-plugin",
+    "test:types": "yarn copy-version && tsc -p tsconfig.spec.json",
     "copy-version": "echo \"export const version = '$npm_package_version';\" > ./src/version.ts"
   },
   "repository": {
@@ -51,8 +52,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.55.1",
-    "@stream-io/video-react-bindings": "1.18.1",
+    "@stream-io/video-client": "1.55.2",
+    "@stream-io/video-react-bindings": "1.18.3",
     "intl-pluralrules": "2.0.1",
     "react-native-url-polyfill": "^3.0.0",
     "rxjs": "~7.8.2",
@@ -67,7 +68,6 @@
     "@stream-io/react-native-webrtc": "^145.0.0",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
-    "expo-build-properties": "*",
     "expo-notifications": "*",
     "react": ">=17.0.0",
     "react-native": ">=0.73.0",
@@ -94,9 +94,6 @@
     "expo": {
       "optional": true
     },
-    "expo-build-properties": {
-      "optional": true
-    },
     "expo-notifications": {
       "optional": true
     },
@@ -117,11 +114,11 @@
     "@react-native-firebase/messaging": "^24.0.0",
     "@react-native/babel-preset": "0.85.3",
     "@react-native/metro-config": "0.85.3",
-    "@stream-io/noise-cancellation-react-native": "^0.9.1",
-    "@stream-io/react-native-callingx": "^0.6.1",
+    "@stream-io/noise-cancellation-react-native": "^0.9.3",
+    "@stream-io/react-native-callingx": "^0.7.0",
     "@stream-io/react-native-webrtc": "145.0.0",
     "@stream-io/typescript-config": "^0.0.0",
-    "@stream-io/video-filters-react-native": "^0.14.1",
+    "@stream-io/video-filters-react-native": "^0.14.3",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.6",
@@ -130,7 +127,6 @@
     "@types/react": "~19.2.15",
     "@types/react-test-renderer": "^19.1.0",
     "expo": "~56.0.9",
-    "expo-build-properties": "~56.0.17",
     "expo-module-scripts": "^56.0.3",
     "expo-notifications": "~56.0.16",
     "jest": "^29.7.0",

package/src/components/Call/CallLayout/CallParticipantsSpotlight.tsx

@@ -3,7 +3,10 @@ import {
   hasScreenShare,
   type StreamVideoParticipant,
 } from '@stream-io/video-client';
-import { useCall } from '@stream-io/video-react-bindings';
+import {
+  useCall,
+  useSpeakerLayoutSortPreset,
+} from '@stream-io/video-react-bindings';
 import { StyleSheet, View } from 'react-native';
 import { debounceTime } from 'rxjs';
 import { ComponentTestIds } from '../../../constants/TestIds';
@@ -70,6 +73,8 @@ export const CallParticipantsSpotlight = ({
       .subscribe(setAllParticipants);
     return () => sub.unsubscribe();
   }, [call]);
+  const isOneOnOneCall = allParticipants.length === 2;
+  useSpeakerLayoutSortPreset(call, isOneOnOneCall);
   const [participantInSpotlight, ...otherParticipants] = allParticipants;
   const isScreenShareOnSpotlight =
     participantInSpotlight && hasScreenShare(participantInSpotlight);

package/src/components/Call/CallParticipantsList/CallParticipantsList.tsx

@@ -2,6 +2,7 @@ import React, {
   useCallback,
   useEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
 } from 'react';
@@ -17,7 +18,6 @@ import {
   type StreamVideoParticipantPatches,
   VisibilityState,
 } from '@stream-io/video-client';
-import { Subject, debounceTime } from 'rxjs';
 import { useCall } from '@stream-io/video-react-bindings';
 import { ComponentTestIds } from '../../../constants/TestIds';
 import {
@@ -109,19 +109,15 @@ export const CallParticipantsList = ({
   if (!viewableParticipantSessionIds.current) {
     viewableParticipantSessionIds.current = new Set();
   }
-  const forceUpdate$Ref = useRef<Subject<void>>(null!);
-  if (!forceUpdate$Ref.current) {
-    forceUpdate$Ref.current = new Subject<void>();
-  }
-  const forceUpdate$ = forceUpdate$Ref.current;
-  const [forceUpdateValue, setForceUpdateValue] = useState(0);
-  useEffect(() => {
-    const sub = forceUpdate$.pipe(debounceTime(500)).subscribe(() => {
-      setForceUpdateValue((v) => v + 1);
-    });
-    return () => sub.unsubscribe();
-  }, [forceUpdate$]);
-  const forceUpdate = useCallback(() => forceUpdate$.next(), [forceUpdate$]);
+  // Debounced force re-render: coalesces rapid viewability changes into a single
+  // re-render 500ms after the last change (drives the FlatList `extraData` below).
+  const [forceUpdateValue, forceRender] = useReducer((v: number) => v + 1, 0);
+  const forceUpdateTimeout = useRef<ReturnType<typeof setTimeout>>(undefined);
+  const forceUpdate = useCallback(() => {
+    clearTimeout(forceUpdateTimeout.current);
+    forceUpdateTimeout.current = setTimeout(forceRender, 500);
+  }, []);
+  useEffect(() => () => clearTimeout(forceUpdateTimeout.current), []);
 
   // we use a ref to store the active call object
   // so that it can be used in the onViewableItemsChanged callback
@@ -131,59 +127,64 @@ export const CallParticipantsList = ({
   // This is the function that gets called when the user scrolls the list of participants.
   // It updates viewableParticipantSessionIds HashSet with the session IDs
   // of the participants that are currently visible.
-  const onViewableItemsChanged = useRef<
-    FlatListProps['onViewableItemsChanged']
-  >(({ viewableItems }) => {
-    const participantPatches: StreamVideoParticipantPatches = {};
-    let mustUpdate = false;
-    const newVisibleParticipantSessionIds = new Set<string>(
-      viewableItems.map((v) => v.key),
-    );
-    const oldVisibleParticipantSessionIds =
-      viewableParticipantSessionIds.current;
-    newVisibleParticipantSessionIds.forEach((key) => {
-      if (!oldVisibleParticipantSessionIds.has(key)) {
-        mustUpdate = true;
-        participantPatches[key] = {
-          viewportVisibilityState: {
-            videoTrack: VisibilityState.VISIBLE,
-            screenShareTrack: VisibilityState.UNKNOWN,
-          },
-        };
-      }
-    });
-    oldVisibleParticipantSessionIds.forEach((key) => {
-      if (!newVisibleParticipantSessionIds.has(key)) {
-        mustUpdate = true;
-        participantPatches[key] = {
-          viewportVisibilityState: {
-            videoTrack: VisibilityState.VISIBLE,
-            screenShareTrack: VisibilityState.UNKNOWN,
-          },
-        };
+  const onViewableItemsChanged = useCallback<
+    NonNullable<FlatListProps['onViewableItemsChanged']>
+  >(
+    ({ viewableItems }) => {
+      const participantPatches: StreamVideoParticipantPatches = {};
+      let mustUpdate = false;
+      const newVisibleParticipantSessionIds = new Set<string>(
+        viewableItems.map((v) => v.key),
+      );
+      const oldVisibleParticipantSessionIds =
+        viewableParticipantSessionIds.current;
+      const visibilityPatch = (
+        videoTrack: VisibilityState,
+      ): StreamVideoParticipantPatches[string] => ({
+        viewportVisibilityState: {
+          videoTrack,
+          screenShareTrack: VisibilityState.UNKNOWN,
+        },
+      });
+      newVisibleParticipantSessionIds.forEach((key) => {
+        if (!oldVisibleParticipantSessionIds.has(key)) {
+          mustUpdate = true;
+          participantPatches[key] = visibilityPatch(VisibilityState.VISIBLE);
+        }
+      });
+      oldVisibleParticipantSessionIds.forEach((key) => {
+        if (!newVisibleParticipantSessionIds.has(key)) {
+          mustUpdate = true;
+          participantPatches[key] = visibilityPatch(VisibilityState.INVISIBLE);
+        }
+      });
+      viewableParticipantSessionIds.current = newVisibleParticipantSessionIds;
+      if (mustUpdate) {
+        activeCallRef.current?.state.updateParticipants(participantPatches);
+        forceUpdate();
       }
-    });
-    viewableParticipantSessionIds.current = newVisibleParticipantSessionIds;
-    if (mustUpdate) {
-      activeCallRef.current?.state.updateParticipants(participantPatches);
-      forceUpdate();
-    }
-  }).current;
+    },
+    [forceUpdate],
+  );
 
   // NOTE: key must be sessionId always as it is used to track viewable participants
-  const keyExtractor = useRef<NonNullable<FlatListProps['keyExtractor']>>(
+  const keyExtractor = useCallback<NonNullable<FlatListProps['keyExtractor']>>(
     (item) => item.sessionId,
-  ).current;
+    [],
+  );
 
-  const onLayout = useRef<NonNullable<FlatListProps['onLayout']>>((event) => {
-    const { height, width } = event.nativeEvent.layout;
-    setContainerLayout((prev) => {
-      if (prev.height === height && prev.width === width) {
-        return prev;
-      }
-      return { height, width };
-    });
-  }).current;
+  const onLayout = useCallback<NonNullable<FlatListProps['onLayout']>>(
+    (event) => {
+      const { height, width } = event.nativeEvent.layout;
+      setContainerLayout((prev) => {
+        if (prev.height === height && prev.width === width) {
+          return prev;
+        }
+        return { height, width };
+      });
+    },
+    [],
+  );
 
   const { itemHeight, itemWidth } = calculateParticipantViewSize({
     containerHeight: containerLayout.height,

package/src/components/Call/RingingCallContent/IncomingCall.tsx

@@ -1,11 +1,5 @@
 import React from 'react';
-import {
-  ImageBackground,
-  StyleSheet,
-  Text,
-  View,
-  type ViewStyle,
-} from 'react-native';
+import { Image, StyleSheet, Text, View, type ViewStyle } from 'react-native';
 import {
   useCallStateHooks,
   useConnectedUser,
@@ -120,18 +114,22 @@ const Background: React.FunctionComponent<{
 
   if (avatarsToShow.length) {
     return (
-      <ImageBackground
-        source={{
-          uri: avatarsToShow[0],
-        }}
+      <View
         style={[
           styles.background,
           { backgroundColor: colors.sheetTertiary },
           incomingCall.background,
         ]}
       >
+        <Image
+          source={{
+            uri: avatarsToShow[0],
+          }}
+          resizeMode="cover"
+          style={StyleSheet.absoluteFill}
+        />
         {children}
-      </ImageBackground>
+      </View>
     );
   }
   return (

package/src/components/Participant/ParticipantView/VideoRenderer/TrackSubscriber.tsx

@@ -7,6 +7,7 @@ import {
   hasScreenShare,
   hasVideo,
   SfuModels,
+  type StreamVideoParticipant,
   type VideoTrackType,
 } from '@stream-io/video-client';
 import {
@@ -14,8 +15,8 @@ import {
   combineLatest,
   distinctUntilChanged,
   distinctUntilKeyChanged,
+  filter,
   map,
-  takeWhile,
 } from 'rxjs';
 export type TrackSubscriberHandle = {
   onLayoutUpdate: (event: LayoutChangeEvent) => void;
@@ -67,7 +68,7 @@ const TrackSubscriber = forwardRef<TrackSubscriberHandle, TrackSubscriberProps>(
       };
       const isPublishingTrack$ = call.state.participants$.pipe(
         map((ps) => ps.find((p) => p.sessionId === participantSessionId)),
-        takeWhile((p) => !!p),
+        filter((p): p is StreamVideoParticipant => !!p),
         distinctUntilKeyChanged('publishedTracks'),
         map((p) =>
           trackType === 'videoTrack' ? hasVideo(p) : hasScreenShare(p),

package/src/components/Participant/ParticipantView/VideoRenderer/index.tsx

@@ -90,8 +90,11 @@ export const VideoRenderer = React.memo(
       ? screenShareStream
       : videoStream) as unknown as MediaStream | undefined;
 
+    const hasVideoTrackInStream =
+      !!videoStreamToRender && videoStreamToRender.getVideoTracks().length > 0;
+
     const canShowVideo =
-      !!videoStreamToRender &&
+      hasVideoTrackInStream &&
       isVisible &&
       isPublishingVideoTrack &&
       !hasPausedTrack(participant, trackType) &&

package/src/hooks/useAndroidKeepCallAliveEffect.ts

@@ -82,6 +82,7 @@ async function startForegroundService(call_cid: string) {
  */
 export const useAndroidKeepCallAliveEffect = () => {
   const foregroundServiceStartedRef = useRef(false);
+  const callingxKeepAliveOwnerRef = useRef<string | undefined>(undefined);
 
   const call = useCall();
   keepCallAliveCallRef.current = call;
@@ -101,15 +102,46 @@ export const useAndroidKeepCallAliveEffect = () => {
     }
 
     const callingx = getCallingxLibIfAvailable();
-    if (
-      callingx?.isSetup &&
-      (isRingingCall || (!isRingingCall && callingx?.isOngoingCallsEnabled))
-    ) {
+    const isCallingxManaged =
+      !!callingx?.isSetup &&
+      (isRingingCall || (!isRingingCall && callingx?.isOngoingCallsEnabled));
+
+    const isCallEnded =
+      callingState === CallingState.IDLE || callingState === CallingState.LEFT;
+
+    // Release the callingx keep-alive task when the call ends.
+    if (callingxKeepAliveOwnerRef.current && isCallEnded) {
+      const currentOwner = callingxKeepAliveOwnerRef.current;
+      callingxKeepAliveOwnerRef.current = undefined;
+      callingx?.releaseBackgroundTask(currentOwner).catch(() => {});
+      return undefined;
+    }
+
+    if (isCallingxManaged && callingx) {
+      // Mutual exclusion: never acquire the callingx task while the SDK's own keep-alive FGS is
+      // running — only one keep-alive mechanism should be active per call.
+      if (
+        !callingxKeepAliveOwnerRef.current &&
+        !isCallEnded &&
+        !foregroundServiceStartedRef.current
+      ) {
+        const owner = `keepalive:${activeCallCid}`;
+        callingxKeepAliveOwnerRef.current = owner;
+        callingx.acquireBackgroundTask(owner).catch((e) => {
+          if (callingxKeepAliveOwnerRef.current === owner) {
+            callingxKeepAliveOwnerRef.current = undefined;
+          }
+          videoLoggerSystem
+            .getLogger('useAndroidKeepCallAliveEffect')
+            .warn('Failed to acquire callingx keep-alive background task', e);
+        });
+      }
       return undefined;
     }
 
-    // start foreground service as soon as the call is joined
-    if (shouldStartForegroundService) {
+    // Start keep-alive FGS as soon as the call is joined — but only if the callingx
+    // keep-alive task isn't already holding the call alive.
+    if (shouldStartForegroundService && !callingxKeepAliveOwnerRef.current) {
       const run = async () => {
         if (foregroundServiceStartedRef.current) {
           return;
@@ -135,10 +167,7 @@ export const useAndroidKeepCallAliveEffect = () => {
       return () => {
         sub.remove();
       };
-    } else if (
-      callingState === CallingState.IDLE ||
-      callingState === CallingState.LEFT
-    ) {
+    } else if (isCallEnded) {
       if (foregroundServiceStartedRef.current) {
         keepCallAliveCallRef.current = undefined;
         // stop foreground service when the call is not active
@@ -162,6 +191,21 @@ export const useAndroidKeepCallAliveEffect = () => {
         stopForegroundServiceNoThrow();
         foregroundServiceStartedRef.current = false;
       }
+      // release the callingx keep-alive task if still held
+      if (callingxKeepAliveOwnerRef.current) {
+        const owner = callingxKeepAliveOwnerRef.current;
+        callingxKeepAliveOwnerRef.current = undefined;
+        getCallingxLibIfAvailable()
+          ?.releaseBackgroundTask(owner)
+          .catch(() => {
+            videoLoggerSystem
+              .getLogger('useAndroidKeepCallAliveEffect')
+              .warn(
+                'Failed to release callingx keep-alive background task',
+                owner,
+              );
+          });
+      }
     };
   }, []);
 };

package/src/modules/call-manager/CallManager.ts

@@ -4,6 +4,10 @@ import type {
   IOSAudioInterruptionEvent,
   StreamInCallManagerConfig,
 } from './types';
+import type {
+  AudioEndpoint as CallingxAudioEndpoint,
+  AudioEndpointsSnapshot as CallingxAudioSnapshot,
+} from '@stream-io/react-native-callingx';
 import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
 import { videoLoggerSystem } from '@stream-io/video-client';
 
@@ -15,6 +19,69 @@ const invariant = (condition: boolean, message: string) => {
   if (!condition) throw new Error(message);
 };
 
+/**
+ * On Android, whether the current call is managed by Telecom (via callingx).
+ * In that mode, audio routing/mode is owned by Telecom and StreamInCallManager audio methods should not be used
+ */
+const isAndroidTelecomManaged = (): boolean => {
+  if (Platform.OS !== 'android' || !CallingxModule) {
+    return false;
+  }
+  return (
+    CallingxModule.isSetup &&
+    CallingxModule.isTelecomBacked &&
+    (CallingxModule.hasRegisteredCall() || CallingxModule.isOngoingCallsEnabled)
+  );
+};
+
+/**
+ * When the current call is Telecom-managed, returns the callingx module and the
+ * registered callId. Centralizes the guard so call sites don't repeat the module /
+ * callId checks — `isAndroidTelecomManaged()` already implies the module exists, but
+ * the extra narrowing here is what makes that provable to the type-checker.
+ */
+const getTelecomContext = ():
+  | { cx: NonNullable<typeof CallingxModule>; callId: string }
+  | undefined => {
+  if (!isAndroidTelecomManaged() || !CallingxModule) {
+    return undefined;
+  }
+  const callId = CallingxModule.getRegisteredCallIds()[0];
+  if (!callId) {
+    return undefined;
+  }
+  return { cx: CallingxModule, callId };
+};
+
+/** Map a generic Telecom endpoint type to the SDK's endpoint display name. */
+const endpointTypeToDisplayName = (
+  type: string,
+): AudioDeviceStatus['currentEndpointType'] => {
+  switch (type) {
+    case 'earpiece':
+      return 'Earpiece';
+    case 'speaker':
+      return 'Speaker';
+    case 'wired_headset':
+      return 'Wired Headset';
+    case 'bluetooth':
+      return 'Bluetooth Device';
+    default:
+      return 'Unknown';
+  }
+};
+
+/** Adapt a callingx endpoints snapshot to the SDK's {@link AudioDeviceStatus}. */
+const snapshotToStatus = (
+  snapshot: CallingxAudioSnapshot,
+): AudioDeviceStatus => ({
+  devices: snapshot.endpoints.map((e) => e.name),
+  currentEndpointType: snapshot.currentEndpoint
+    ? endpointTypeToDisplayName(snapshot.currentEndpoint.type)
+    : 'Unknown',
+  selectedDevice: snapshot.currentEndpoint?.name ?? '',
+});
+
 class AndroidCallManager {
   private eventEmitter?: NativeEventEmitter;
 
@@ -23,6 +90,11 @@ class AndroidCallManager {
    */
   getAudioDeviceStatus = async (): Promise<AudioDeviceStatus> => {
     invariant(Platform.OS === 'android', 'Supported only on Android');
+    const tc = getTelecomContext();
+    if (tc) {
+      const snapshot = await tc.cx.getAvailableAudioEndpoints(tc.callId);
+      return snapshotToStatus(snapshot);
+    }
     return NativeManager.getAudioDeviceStatus();
   };
 
@@ -33,6 +105,30 @@ class AndroidCallManager {
    */
   selectAudioDevice = (endpointName: string): void => {
     invariant(Platform.OS === 'android', 'Supported only on Android');
+    const tc = getTelecomContext();
+    if (tc) {
+      const { cx, callId } = tc;
+      // Resolve name -> endpoint id from the current Telecom snapshot, then route via Telecom.
+      cx.getAvailableAudioEndpoints(callId)
+        .then((snapshot) => {
+          const target = snapshot.endpoints.find(
+            (e) => e.name === endpointName,
+          );
+          if (target) {
+            return cx.requestAudioEndpointChange(callId, target.id);
+          }
+          return undefined;
+        })
+        .catch((error) => {
+          videoLoggerSystem
+            .getLogger('CallManager')
+            .warn(
+              `selectAudioDevice: failed to route to "${endpointName}" for call ${callId} via Telecom`,
+              error,
+            );
+        });
+      return;
+    }
     NativeManager.chooseAudioDeviceEndpoint(endpointName);
   };
 
@@ -44,9 +140,26 @@ class AndroidCallManager {
     onChange: (audioDeviceStatus: AudioDeviceStatus) => void,
   ): (() => void) => {
     invariant(Platform.OS === 'android', 'Supported only on Android');
+    const cleanups: Array<() => void> = [];
+
+    // Telecom (callingx) route changes.
+    if (CallingxModule?.isSetup && CallingxModule.isTelecomBacked) {
+      const sub = CallingxModule.addEventListener(
+        'didChangeAudioEndpoints',
+        (params) => onChange(snapshotToStatus(params)),
+      );
+      cleanups.push(() => sub.remove());
+    }
+
+    // StreamInCallManager route changes (non-Telecom calls). Native
+    // suppresses these while in telecom-managed mode, and callingx emits no
+    // endpoint events for non-Telecom calls, so the two sources never overlap
+    // at runtime — safe to keep both subscribed in parallel.
     this.eventEmitter ??= new NativeEventEmitter(NativeManager);
     const s = this.eventEmitter.addListener('onAudioDeviceChanged', onChange);
-    return () => s.remove();
+    cleanups.push(() => s.remove());
+
+    return () => cleanups.forEach((cleanup) => cleanup());
   };
 }
 
@@ -95,6 +208,38 @@ class SpeakerManager {
    * Forces speakerphone on/off.
    */
   setForceSpeakerphoneOn = (force: boolean): void => {
+    const tc = getTelecomContext();
+    if (tc) {
+      const { cx, callId } = tc;
+      // Telecom owns routing: map on -> speaker endpoint, off -> highest-priority
+      // non-speaker endpoint (wired > bluetooth > earpiece), mirroring classic behavior.
+      cx.getAvailableAudioEndpoints(callId)
+        .then((snapshot) => {
+          let target: CallingxAudioEndpoint | undefined;
+          if (force) {
+            target = snapshot.endpoints.find((e) => e.type === 'speaker');
+          } else {
+            // Priority for the "speakerphone off" fallback: prefer wired, then bluetooth, then earpiece.
+            for (const type of ['wired_headset', 'bluetooth', 'earpiece']) {
+              target = snapshot.endpoints.find((e) => e.type === type);
+              if (target) break;
+            }
+          }
+          if (target) {
+            return cx.requestAudioEndpointChange(callId, target.id);
+          }
+          return undefined;
+        })
+        .catch((error) => {
+          videoLoggerSystem
+            .getLogger('CallManager')
+            .warn(
+              `setForceSpeakerphoneOn(${force}): failed to route for call ${callId} via Telecom`,
+              error,
+            );
+        });
+      return;
+    }
     NativeManager.setForceSpeakerphoneOn(force);
   };
 }
@@ -149,6 +294,22 @@ export class CallManager {
         );
       return;
     }
+    if (isAndroidTelecomManaged()) {
+      // Telecom owns routing/focus; forward the sticky preference to callingx and run in
+      // telecom-managed mode (StreamInCallManager keeps proximity/keep-screen-on only).
+      if (config?.audioRole !== 'listener' && CallingxModule) {
+        CallingxModule.setDefaultAudioDeviceEndpointType(
+          config?.deviceEndpointType ?? 'speaker',
+        );
+      }
+      NativeManager.setTelecomManagedMode(true);
+      NativeManager.setAudioRole(config?.audioRole ?? 'communicator');
+      NativeManager.start();
+      return;
+    }
+    if (Platform.OS === 'android') {
+      NativeManager.setTelecomManagedMode(false);
+    }
     NativeManager.setAudioRole(config?.audioRole ?? 'communicator');
     if (config?.audioRole === 'communicator') {
       const type = config.deviceEndpointType ?? 'speaker';

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

@@ -24,6 +24,14 @@ export interface CallManager extends NativeModule {
    */
   setDefaultAudioDeviceEndpointType: (type: DeviceEndpointType) => void;
 
+  /**
+   * Enables/disables Telecom-managed mode (Android). Must be set before **start()**.
+   * When enabled, audio focus, mode and device routing are owned by the Android
+   * Telecom stack (via callingx); StreamInCallManager only keeps proximity,
+   * keep-screen-on and mic/output mute.
+   */
+  setTelecomManagedMode: (enabled: boolean) => void;
+
   /**
    * Choose an audio device endpoint.
    * @param endpointName - The name of the audio device endpoint to choose.

package/src/utils/StreamVideoRN/types.ts

@@ -133,6 +133,11 @@ export type StreamVideoConfig = {
        * @default false
        */
       skipIncomingPushInForeground?: boolean;
+      /**
+       * Default audio endpoint for Telecom-managed calls on Android.
+       * @default 'speaker'
+       */
+      defaultDeviceEndpointType?: 'speaker' | 'earpiece';
     };
     /**
      * Whether to reject calls when the user is busy.