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

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 { NativeModules, Platform } from 'react-native';
+import { Platform } from 'react-native';
 import type { EndCallReason } from '@stream-io/react-native-callingx';
 import { getCallingxLibIfAvailable } from '../../push/libs/callingx';
 import type {
@@ -14,46 +14,6 @@ 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.
  */
@@ -88,7 +48,7 @@ export function getCallDisplayName(
   if (names.length === 0) {
     names = [
       participants.find((participant) => participant.userId === currentUserId)
-        ?.name ?? 'Call',
+        ?.name || 'Call',
     ];
   }
 
@@ -97,7 +57,7 @@ export function getCallDisplayName(
 
 function getCallDisplayNameFromCall(call: Call): string {
   return (
-    call.state.custom?.display_name ??
+    call.state.custom?.display_name ||
     getCallDisplayName(
       call.state.members,
       call.state.participants,
@@ -136,7 +96,6 @@ export async function registerOutgoingCall(call: Call) {
       `registerOutgoingCall: Error registering outgoing call in callingx: ${call.cid}`,
       error,
     );
-    recoverAudioToClassicMode();
   }
 }
 
@@ -183,7 +142,6 @@ 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}`);
@@ -221,7 +179,6 @@ export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
         `Error joining incoming call in callingx: ${call.cid}`,
         error,
       );
-      recoverAudioToClassicMode();
     }
   }
 }
@@ -246,3 +203,37 @@ export async function endCallingxCall(call: Call, reason?: EndCallReason) {
     );
   }
 }
+
+export async function wireAudioEngineSubscription() {
+  if (!CallingxModule || !CallingxModule.isSetup || Platform.OS !== 'ios') {
+    return;
+  }
+  const logger = videoLoggerSystem.getLogger('callingx');
+
+  try {
+    logger.debug('wireEngineSubscription: Wiring engine subscription');
+    CallingxModule.wireAudioEngineSubscription();
+  } catch (error) {
+    logger.error(
+      'wireAudioEngineSubscription: Error wiring engine subscription',
+      error,
+    );
+  }
+}
+
+export function unwireAudioEngineSubscription() {
+  if (!CallingxModule || !CallingxModule.isSetup || Platform.OS !== 'ios') {
+    return;
+  }
+  const logger = videoLoggerSystem.getLogger('callingx');
+
+  try {
+    logger.debug('unwireEngineSubscription: Cancelling engine subscription');
+    CallingxModule.unwireAudioEngineSubscription();
+  } catch (error) {
+    logger.error(
+      'unwireAudioEngineSubscription: Error cancelling engine subscription',
+      error,
+    );
+  }
+}

package/src/utils/internal/registerMediaEngine.ts

@@ -0,0 +1,42 @@
+import {
+  type CallMediaEngine,
+  setCallMediaEngineProvider,
+  videoLoggerSystem,
+} from '@stream-io/video-client';
+import { CallFactory } from '@stream-io/react-native-webrtc';
+import { callManager } from '../../modules/call-manager';
+
+const logger = videoLoggerSystem.getLogger('CallMediaEngine');
+
+/**
+ * Registers the React Native {@link CallMediaEngine} provider.
+ *
+ * Once registered, every `Call.ensureMediaFactory()` builds the call's native
+ * `PeerConnectionFactory` (with the call's audio configuration) and sets it as
+ * the single live factory. The WebRTC globals (`getUserMedia`/`getDisplayMedia`/
+ * `new RTCPeerConnection`) then resolve to it, so the call's tracks and peer
+ * connections are created with — and torn down with — that one native factory,
+ * which is what lets the call own its AudioDeviceModule. The engine itself only
+ * manages the factory lifecycle (`dispose` at leave).
+ *
+ * @internal
+ */
+export function registerCallMediaEngine() {
+  setCallMediaEngineProvider(async (): Promise<CallMediaEngine> => {
+    const config = callManager.getStoredConfig();
+    const bypassVoiceProcessing = config?.audioRole === 'listener';
+    const factory = await CallFactory.create({
+      bypassVoiceProcessing,
+    });
+    logger.debug(
+      `Created per-call factory (bypassVoiceProcessing=${bypassVoiceProcessing})`,
+    );
+
+    return {
+      dispose: async () => {
+        logger.debug('Disposing per-call factory');
+        return await factory.dispose();
+      },
+    };
+  });
+}

package/src/utils/internal/registerSDKGlobals.ts

@@ -1,7 +1,9 @@
-import { StreamRNVideoSDKGlobals } from '@stream-io/video-client';
+import {
+  StreamRNVideoSDKGlobals,
+  videoLoggerSystem,
+} from '@stream-io/video-client';
 import { NativeModules, PermissionsAndroid, Platform } from 'react-native';
 import {
-  AudioDeviceModule,
   AudioEngineMuteMode,
   audioDeviceModuleEvents,
 } from '@stream-io/react-native-webrtc';
@@ -10,7 +12,11 @@ import {
   endCallingxCall,
   registerOutgoingCall,
   joinCallingxCall,
+  wireAudioEngineSubscription,
+  unwireAudioEngineSubscription,
 } from './callingx/callingx';
+import { registerCallMediaEngine } from './registerMediaEngine';
+import { callManager as publicCallManager } from '../../modules/call-manager';
 
 const StreamInCallManagerNativeModule = NativeModules.StreamInCallManager;
 const StreamVideoReactNativeModule = NativeModules.StreamVideoReactNative as {
@@ -19,6 +25,18 @@ const StreamVideoReactNativeModule = NativeModules.StreamVideoReactNative as {
 
 const CallingxModule = getCallingxLibIfAvailable();
 
+/**
+ * Runs a fire-and-forget native call, logging instead of throwing on a bridge
+ * error so it can't crash the caller (e.g. the join/leave flow).
+ */
+const safeNativeCall = (label: string, fn: () => void): void => {
+  try {
+    fn();
+  } catch (error) {
+    videoLoggerSystem.getLogger('CallManager').warn(`${label} failed`, error);
+  }
+};
+
 /**
  * Checks if StreamInCallManager should be bypassed because CallKit is handling
  * the audio session via CallingX.
@@ -52,22 +70,17 @@ const shouldBypassForCallKit = ({
  * 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') {
+const isAndroidTelecomManaged = ({ cid }: { cid: string }): boolean => {
+  if (Platform.OS !== 'android' || !CallingxModule) {
     return false;
   }
-  if (!CallingxModule) {
+  if (!CallingxModule.isSetup || !CallingxModule.isTelecomBacked) {
     return false;
   }
-  return (
-    CallingxModule.isSetup &&
-    CallingxModule.isTelecomBacked &&
-    (isRingingTypeCall || CallingxModule.isOngoingCallsEnabled)
-  );
+  // Trust Telecom's actual per-call registration. A call that never registered
+  // (e.g. Telecom registration failed) is not managed, so start() falls through
+  // to the classic path — this is where audio recovery happens.
+  return CallingxModule.isCallTracked(cid);
 };
 
 const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
@@ -75,43 +88,101 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
     joinCall: joinCallingxCall,
     endCall: endCallingxCall,
     registerOutgoingCall: registerOutgoingCall,
+    wireAudioEngineSubscription: wireAudioEngineSubscription,
+    unwireAudioEngineSubscription: unwireAudioEngineSubscription,
   },
   callManager: {
-    setup: ({ defaultDevice, isRingingTypeCall }) => {
-      if (shouldBypassForCallKit({ isRingingTypeCall })) {
-        // Forward the sticky preference; callingx reads it on next CallKit activation.
-        CallingxModule?.setDefaultAudioDeviceEndpointType(defaultDevice);
-        return;
+    setup: ({ defaultDevice, isRingingTypeCall, cid }) => {
+      const isTelecomManaged = isAndroidTelecomManaged({ cid });
+      const isCallKitManaged = shouldBypassForCallKit({ isRingingTypeCall });
+      if (Platform.OS === 'android') {
+        StreamInCallManagerNativeModule.setTelecomManagedMode(isTelecomManaged);
       }
-      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 (isTelecomManaged || isCallKitManaged) {
+        safeNativeCall('setup defaultAudioDevice (callingx)', () =>
+          CallingxModule?.setDefaultAudioDeviceEndpointType(defaultDevice),
+        );
       }
-      if (Platform.OS === 'android') {
-        StreamInCallManagerNativeModule.setTelecomManagedMode(false);
+
+      if (!isTelecomManaged) {
+        safeNativeCall('setup defaultAudioDevice', () =>
+          StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
+            defaultDevice,
+          ),
+        );
       }
-      StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
-        defaultDevice,
-      );
-      StreamInCallManagerNativeModule.setup();
     },
-    start: ({ isRingingTypeCall }) => {
+    start: ({ isRingingTypeCall, cid }) => {
+      // Apply the audio config a consumer recorded via `callManager.start(config)` at this single
+      // join-time start, before the native audio manager is activated.
+      const config = publicCallManager.getStoredConfig();
+      const deviceOverride =
+        config?.audioRole === 'communicator'
+          ? config.deviceEndpointType
+          : undefined;
+
       if (shouldBypassForCallKit({ isRingingTypeCall })) {
+        // CallKit owns activation. Only forward an explicit endpoint override; the
+        // SpeakerManager-derived default was already forwarded via `setup`.
+        if (deviceOverride) {
+          safeNativeCall('start defaultAudioDevice (callingx)', () =>
+            CallingxModule?.setDefaultAudioDeviceEndpointType(deviceOverride),
+          );
+          safeNativeCall('start defaultAudioDevice', () =>
+            StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
+              deviceOverride,
+            ),
+          );
+        }
         return;
       }
-      // Android telecom-managed calls still start (for proximity/keep-screen-on);
-      // the native side skips routing/focus internally.
+
+      const isTelecomManaged = isAndroidTelecomManaged({ cid });
+      if (Platform.OS === 'android') {
+        StreamInCallManagerNativeModule.setTelecomManagedMode(isTelecomManaged);
+      }
+      if (config?.audioRole) {
+        StreamInCallManagerNativeModule.setAudioRole(config.audioRole);
+      }
+      if (deviceOverride) {
+        // Override the SpeakerManager-derived default device (set via `setup`).
+        if (isTelecomManaged) {
+          safeNativeCall('start defaultAudioDevice (callingx)', () =>
+            CallingxModule?.setDefaultAudioDeviceEndpointType(deviceOverride),
+          );
+        } else {
+          safeNativeCall('start defaultAudioDevice', () =>
+            StreamInCallManagerNativeModule.setDefaultAudioDeviceEndpointType(
+              deviceOverride,
+            ),
+          );
+        }
+      }
+
+      const stereoOutput = config?.audioRole === 'listener';
+      StreamInCallManagerNativeModule.setEnableStereoAudioOutput(stereoOutput);
       StreamInCallManagerNativeModule.start();
     },
-    stop: ({ isRingingTypeCall }) => {
-      if (shouldBypassForCallKit({ isRingingTypeCall })) {
-        return;
+    stop: ({ isRingingTypeCall, shouldStopCallManager }) => {
+      // Clear the stored audio config so it doesn't carry into the next call.
+      publicCallManager.stop();
+
+      // We want to interact with ADM only when it was instantiated. This guards a case when
+      // leave is invoked for ringing call - in this case PC Factory and ADM are not yet created.
+      if (shouldStopCallManager) {
+        // Teardown of setMutedRecordingPrepared. Done here (before the CallKit gate)
+        // so it runs on both paths and while the call factory is still alive: leave()
+        // calls stop() before disposing the engine, so the ADM resolves to the call's
+        // factory rather than a default.
+        if (Platform.OS === 'ios') {
+          StreamInCallManagerNativeModule.setRecordingAlwaysPreparedMode(false);
+        }
+        if (shouldBypassForCallKit({ isRingingTypeCall })) {
+          return;
+        }
+        StreamInCallManagerNativeModule.stop();
       }
-      StreamInCallManagerNativeModule.stop();
     },
     // iOS-only. Keep the AVAudioEngine mic-input (voice-processing) chain
     // prepared while muted so the engine stays full-duplex and remote audio
@@ -125,11 +196,11 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
       if (enabled) {
         // Mute via the voice-processing unit (it's the default, fail safe config here) so the input chain
         // stays built while muted, rather than tearing the engine down.
-        AudioDeviceModule.setMuteMode(
+        StreamInCallManagerNativeModule.setMuteMode(
           AudioEngineMuteMode.VoiceProcessing,
-        ).catch(() => {});
+        );
       }
-      AudioDeviceModule.setRecordingAlwaysPreparedMode(enabled).catch(() => {});
+      StreamInCallManagerNativeModule.setRecordingAlwaysPreparedMode(enabled);
     },
   },
   permissions: {
@@ -169,4 +240,6 @@ export function registerSDKGlobals() {
   if (!globalThis.streamRNVideoSDK) {
     globalThis.streamRNVideoSDK = streamRNVideoSDKGlobals;
   }
+
+  registerCallMediaEngine();
 }

package/src/utils/push/android.ts

@@ -1,20 +1,8 @@
-import {
-  CallingState,
-  StreamVideoClient,
-  videoLoggerSystem,
-} from '@stream-io/video-client';
-import { AppState, Platform } from 'react-native';
+import { StreamVideoClient, videoLoggerSystem } from '@stream-io/video-client';
+import { Platform } from 'react-native';
 import type { StreamVideoConfig } from '../StreamVideoRN/types';
-import {
-  type FirebaseMessagingTypes,
-  getFirebaseMessagingLib,
-  getFirebaseMessagingLibNoThrow,
-} from './libs';
-import { pushUnsubscriptionCallbacks } from './internal/constants';
-import { canListenToWS, shouldCallBeClosed } from './internal/utils';
+import { getFirebaseMessagingLib } from './libs';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
-import { StreamVideoRN } from '../StreamVideoRN';
-import { getCallingxLib } from './libs/callingx';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
@@ -60,248 +48,27 @@ export async function initAndroidPushToken(
     await client.addDevice(token, 'firebase', push_provider_name);
   };
 
-  const messaging = pushConfig.isExpo
-    ? getFirebaseMessagingLibNoThrow(true)
-    : getFirebaseMessagingLib();
-  if (messaging) {
-    logger.debug(`setting firebase token listeners`);
-    const unsubscribe = messaging().onTokenRefresh((refreshedToken) =>
-      setDeviceToken(refreshedToken),
-    );
-    setUnsubscribeListener(unsubscribe);
-    const token = await messaging().getToken();
-    await setDeviceToken(token);
-  }
+  const messaging = getFirebaseMessagingLib();
+  logger.debug(`setting firebase token listeners`);
+  const unsubscribe = messaging().onTokenRefresh((refreshedToken) =>
+    setDeviceToken(refreshedToken),
+  );
+  setUnsubscribeListener(unsubscribe);
+  const token = await messaging().getToken();
+  await setDeviceToken(token);
 }
 
+let firebaseDataHandlerDeprecationLogged = false;
 /**
- * Creates notification from the push message data.
- * For Ringing and Non-Ringing calls.
+ * @deprecated Ring notifications are now handled by the SDK internally. This method is a no-op;
+ * you can safely remove `firebaseDataHandler(...)` wiring from your Firebase messaging handlers.
  */
-
-export const firebaseDataHandler = async (
-  data: FirebaseMessagingTypes.RemoteMessage['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 logger = videoLoggerSystem.getLogger('firebaseDataHandler');
-  const pushConfig = StreamVideoRN.getConfig().push;
-  if (!pushConfig || !data || data.sender !== 'stream.video') {
-    return;
-  }
-
-  if (data.type === 'call.ring') {
-    const call_cid = data.call_cid as string;
-    const callingx = getCallingxLib();
-
-    const client = await pushConfig.createStreamVideoClient();
-    if (!client) {
-      logger.debug(
-        `video client not found, skipping the call.ring notification`,
-      );
-      await callingx.stopService();
-      return;
-    }
-
-    const asForegroundService = canListenToWS();
-
-    if (asForegroundService) {
-      // 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(
-              `Ending call with callCid: ${call_cid} endCallReason: ${endCallReason}`,
-              'debug',
-            );
-            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;
-          }
-
-          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);
-              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 from callingState callCid: ${call_cid} callingState: ${callingState}`,
-                );
-                unsubscribeFunctions.forEach((fn) => fn());
-                callingx.log(
-                  `Ending call with callCid: ${call_cid} callingState: ${callingState}`,
-                  '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',
-                );
-                finishBackgroundTask();
-              }
-            },
-          );
-
-          //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) {
-          callingx.log(
-            `Failed to start background task with callCid: ${call_cid} error: ${error}`,
-            'error',
-          );
-          finishBackgroundTask();
-        }
-      })();
-    }
-
-    if (asForegroundService) {
-      // no need to check if call has be closed as that will be handled by the fg service
-      return;
-    }
-
-    const callFromPush = await client.onRingingCall(call_cid);
-
-    const { mustEndCall, endCallReason } = shouldCallBeClosed(
-      callFromPush,
-      data,
+export const firebaseDataHandler = async (data?: any) => {
+  void data;
+  if (!firebaseDataHandlerDeprecationLogged) {
+    firebaseDataHandlerDeprecationLogged = true;
+    console.warn(
+      '[@stream-io/video-react-native-sdk] `firebaseDataHandler` is deprecated. Ring notifications are now handled by the SDK internally — you can remove calls to it from your Firebase messaging handlers.',
     );
-    if (mustEndCall) {
-      logger.debug(
-        `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) => {
-        logger.error(
-          `Failed to leave already-ended ringing call ${call_cid}: ${error}`,
-        );
-      });
-    }
   }
 };