@stream-io/video-react-native-sdk 1.37.1-beta.0 → 1.38.1

package/ios/StreamInCallManager.swift

@@ -2,6 +2,7 @@ import Foundation
 import React
 import UIKit
 import AVFoundation
+import Combine
 import stream_react_native_webrtc
 import AVKit
 import MediaPlayer
@@ -29,6 +30,10 @@ private enum Constants {
     static let stereoRefreshDebounceSeconds: TimeInterval = 0.5
 }
 
+private enum StreamInCallManagerEvents {
+    static let audioInterruption = "StreamInCallManagerAudioInterruption"
+}
+
 @objc(StreamInCallManager)
 class StreamInCallManager: RCTEventEmitter {
 
@@ -47,7 +52,11 @@ class StreamInCallManager: RCTEventEmitter {
     }
 
     private var hasRegisteredRouteObserver = false
+    private var hasRegisteredInterruptionObserver = false
     private var stereoRefreshWorkItem: DispatchWorkItem?
+    /// Combine subscription to the AudioDeviceModule's engine-lifecycle publisher.
+    /// Wired in `setup()`; torn down in `stop()`.
+    private var engineSubscription: AnyCancellable?
 
     override func invalidate() {
         stop()
@@ -91,69 +100,168 @@ class StreamInCallManager: RCTEventEmitter {
         }
     }
     
+    /// Builds the audio config for the current role/device and sets it as WebRTC's default.
+    private func makeAudioConfiguration() -> RTCAudioSessionConfiguration {
+        let category: AVAudioSession.Category
+        let mode: AVAudioSession.Mode
+        let options: AVAudioSession.CategoryOptions
+
+        if callAudioRole == .listener {
+            // High quality audio playback, microphone disabled.
+            // .spokenAudio + .mixWithOthers: listener flow is passive spoken-audio
+            // playback, so let other apps' audio coexist (music keeps playing under it)
+            // and let the system handle ducking semantics for spoken content.
+            category = .playback
+            mode = .spokenAudio
+            options = [.mixWithOthers]
+            // TODO: for stereo we should disallow BluetoothHFP and allow only allowBluetoothA2DP
+            // note: this is the behaviour of iOS native SDK, but fails here with (OSStatus error -50.)
+            // options = self.enableStereo ? [.allowBluetoothA2DP] : []
+        } else if !micPermissionGranted() {
+            // Communicator without mic permission (denied or not yet asked): use a
+            // pure-output, no-VPIO session so the output-only AVAudioEngine renders
+            // remote audio. Mirrors stream-video-swift
+            // (isRecordingEnabled ? .playAndRecord : .playback). We can't record anyway.
+            // Self-heals: granting permission + unmuting rebuilds the engine.
+            // Known gap: .playback can't route to the receiver (earpiece) — that route
+            // only exists under .playAndRecord.
+            category = .playback
+            mode = .spokenAudio
+            options = []
+        } else {
+            // XCode 16 and older don't expose .allowBluetoothHFP
+            // https://forums.swift.org/t/xcode-26-avaudiosession-categoryoptions-allowbluetooth-deprecated/80956
+            #if compiler(>=6.2) // For Xcode 26.0+
+                let bluetoothOption: AVAudioSession.CategoryOptions = .allowBluetoothHFP
+            #else
+                let bluetoothOption: AVAudioSession.CategoryOptions = .allowBluetooth
+            #endif
+            category = .playAndRecord
+            mode = .voiceChat
+            options = defaultAudioDevice == .speaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
+        }
+
+        let rtcConfig = RTCAudioSessionConfiguration.webRTC()
+        rtcConfig.category = category.rawValue
+        rtcConfig.mode = mode.rawValue
+        rtcConfig.categoryOptions = options
+        // Keep WebRTC's internal state consistent during interruptions/route changes.
+        RTCAudioSessionConfiguration.setWebRTC(rtcConfig)
+        return rtcConfig
+    }
+
+    private func micPermissionGranted() -> Bool {
+        if #available(iOS 17.0, *) {
+            return AVAudioApplication.shared.recordPermission == .granted
+        } else {
+            return AVAudioSession.sharedInstance().recordPermission == .granted
+        }
+    }
+
     @objc
     func setup() {
         audioSessionQueue.async { [self] in
-            let intendedCategory: AVAudioSession.Category!
-            let intendedMode: AVAudioSession.Mode!
-            let intendedOptions: AVAudioSession.CategoryOptions!
-            
             let adm = getAudioDeviceModule()
-            let wasRecording = adm.isRecording
-            let wasPlaying = adm.isPlaying
-            adm.reset()
 
-            if (callAudioRole == .listener) {
-                // enables high quality audio playback but disables microphone
-                intendedCategory = .playback
-                intendedMode = .default
-                intendedOptions = []
-                // TODO: for stereo we should disallow BluetoothHFP and allow only allowBluetoothA2DP
-                // note: this is the behaviour of iOS native SDK, but fails here with (OSStatus error -50.)
-                // intendedOptions = self.enableStereo ? [.allowBluetoothA2DP] : []
-                if (self.enableStereo) {
-                    adm.setStereoPlayoutPreference(true)
-                }
-            } else {
-                intendedCategory = .playAndRecord
-                intendedMode = .voiceChat
-                
-                // XCode 16 and older don't expose .allowBluetoothHFP
-                // https://forums.swift.org/t/xcode-26-avaudiosession-categoryoptions-allowbluetooth-deprecated/80956
-                #if compiler(>=6.2) // For Xcode 26.0+
-                    let bluetoothOption: AVAudioSession.CategoryOptions = .allowBluetoothHFP
-                #else
-                    let bluetoothOption: AVAudioSession.CategoryOptions = .allowBluetooth
-                #endif
-                intendedOptions = defaultAudioDevice == .speaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
+            // Stereo is listener-only and applies live. Cleared by stop()'s reset().
+            if callAudioRole == .listener && enableStereo {
+                adm.setStereoPlayoutPreference(true)
             }
-            log("Setup with category: \(intendedCategory.rawValue), mode: \(intendedMode.rawValue), options: \(String(describing: intendedOptions))")
-            let rtcConfig = RTCAudioSessionConfiguration.webRTC()
-            rtcConfig.category = intendedCategory.rawValue
-            rtcConfig.mode = intendedMode.rawValue
-            rtcConfig.categoryOptions = intendedOptions
-            // This ensures WebRTC's internal state stays consistent during interruptions/route changes
-            RTCAudioSessionConfiguration.setWebRTC(rtcConfig)
-            
+
+            let rtcConfig = makeAudioConfiguration()
+            log("Setup with category: \(rtcConfig.category), mode: \(rtcConfig.mode), options: \(rtcConfig.categoryOptions)")
+
+            // Set category only — the sink owns setActive().
             let session = RTCAudioSession.sharedInstance()
             session.lockForConfiguration()
-            defer {
-                session.unlockForConfiguration()
-            }
+            defer { session.unlockForConfiguration() }
             do {
                 try session.setConfiguration(rtcConfig)
-                if (wasRecording) {
-                    try adm.setRecording(wasRecording)
-                }
-                if (wasPlaying) {
-                    try adm.setPlayout(wasPlaying)
-                }
             } catch {
-                log("Error setting audio session: \(error.localizedDescription)")
+                // String(describing:) shows the real error; localizedDescription prints a useless "error 0".
+                log("Error setting audio session: \(String(describing: error))")
+            }
+
+            // Subscribe to the AudioDeviceModule's engine lifecycle (idempotent).
+            // The sink does the authoritative reapply on every engine rebuild
+            // (interruption recovery, mode swap) and owns `setActive(true/false)`
+            // since there's no CallKit on this path.
+            // Skipped when callingx owns the session (CallKit-managed call active).
+            if engineSubscription == nil {
+                #if DEBUG
+                NSLog("%@","[StreamInCallManager][wireEngineSubscription]")
+                #endif
+                engineSubscription = adm.publisher.sink { [weak self] event in
+                    guard let self else { return }
+                    self.audioSessionQueue.async {
+                        switch event {
+                        case .willEnableAudioEngine:
+                            self.applyConfigForEngineEnable()
+                        case .didDisableAudioEngine:
+                            self.applyConfigForEngineDisable()
+                        default:
+                            // .willStartAudioEngine / .didStopAudioEngine intentionally ignored:
+                            // WebRTC's engine stop/restart around interruptions — it re-activates the
+                            // session itself via AVAudioEngine.start(). We only (re)apply config +
+                            // setActive on enable/disable.
+                            break
+                        }
+                    }
+                }
             }
         }
     }
 
+    // MARK: - Engine Lifecycle Handlers (non-CallKit path)
+
+    /// Reapplies the same `AVAudioSessionConfiguration` that `setup()` writes
+    /// on every engine rebuild, then activates the session.
+    /// No-ops when callingx owns the session.
+    private func applyConfigForEngineEnable() {
+        if Self.callingxOwnsSession() {
+            log("engineWillEnable: callingx owns the session, skipping")
+            return
+        }
+
+        let rtcConfig = makeAudioConfiguration()
+        let session = RTCAudioSession.sharedInstance()
+        session.lockForConfiguration()
+        defer { session.unlockForConfiguration() }
+        do {
+            try session.setConfiguration(rtcConfig)
+            try session.setActive(true)
+            log("engineWillEnable: applied category=\(rtcConfig.category) mode=\(rtcConfig.mode) activated=true")
+        } catch {
+            log("engineWillEnable error: \(String(describing: error))")
+        }
+    }
+
+    private func applyConfigForEngineDisable() {
+        if Self.callingxOwnsSession() {
+            return
+        }
+
+        let session = RTCAudioSession.sharedInstance()
+        session.lockForConfiguration()
+        defer { session.unlockForConfiguration() }
+        do {
+            try session.setActive(false)
+            log("engineDidDisable: deactivated session")
+        } catch {
+            log("engineDidDisable error: \(String(describing: error))")
+        }
+    }
+
+    /// Runtime KVC lookup of `CallingxSessionOwnership.callingxOwnsSession`.
+    /// `@stream-io/react-native-callingx` is an optional peer dep, so a direct
+    /// Swift `import` is not safe
+    private static func callingxOwnsSession() -> Bool {
+        guard let cls = NSClassFromString("Callingx.CallingxSessionOwnership") else {
+            return false
+        }
+        return ((cls as AnyObject).value(forKey: "callingxOwnsSession") as? Bool) ?? false
+    }
+
     @objc
     func start() {
         setup()
@@ -166,25 +274,23 @@ class StreamInCallManager: RCTEventEmitter {
                 UIApplication.shared.isIdleTimerDisabled = true
                 // Register for audio route changes to turn off screen when earpiece is connected
                 self.registerAudioRouteObserver()
+                self.registerInterruptionObserver()
                 self.updateProximityMonitoring()
                 self.log("Wake lock enabled (idle timer disabled)")
                 self.log("defaultAudioDevice: \(self.defaultAudioDevice)")
             }
-            let session = RTCAudioSession.sharedInstance()
-            session.lockForConfiguration()
-            defer {
-                session.unlockForConfiguration()
-            }
+            // setPlayout(true) triggers .willEnableAudioEngine, whose sink
+            // applies the preset and calls setActive(true). No explicit
+            // session.setActive(true) here.
             do {
-                try session.setActive(true)
-                self.log("audio session activated")
                 let adm = getAudioDeviceModule()
                 try adm.setPlayout(true)
                 self.log("adm.setPlayout(true) done")
             } catch {
-                log("Error activating audio session: \(error.localizedDescription)")
+                // String(describing:) surfaces the real error code (see setup()).
+                log("Error starting playout: \(String(describing: error))")
             }
-            
+
             audioManagerActivated = true
         }
     }
@@ -195,18 +301,13 @@ class StreamInCallManager: RCTEventEmitter {
             if !audioManagerActivated {
                 return
             }
-            let session = RTCAudioSession.sharedInstance()
-            session.lockForConfiguration()
-            defer {
-                session.unlockForConfiguration()
-            }
-            do {
-                try session.setActive(false)
-                let adm = getAudioDeviceModule()
-                adm.reset()
-            } catch {
-                log("Error deactivating audio session: \(error.localizedDescription)")
-            }
+            let adm = getAudioDeviceModule()
+            adm.reset()
+            // Deactivate directly: the .didDisableAudioEngine sink is async and we cancel it below.
+            applyConfigForEngineDisable()
+            // Tear down the engine-observer subscription so a re-setup wires a fresh one.
+            engineSubscription?.cancel()
+            engineSubscription = nil
             // Cancel any pending debounced stereo refresh
             stereoRefreshWorkItem?.cancel()
             stereoRefreshWorkItem = nil
@@ -220,6 +321,7 @@ class StreamInCallManager: RCTEventEmitter {
             // Disable proximity monitoring to disable earpiece detection
             self.setProximityMonitoringEnabled(false)
             self.unregisterAudioRouteObserver()
+            self.unregisterInterruptionObserver()
             // Disable wake lock to allow the screen to dim/lock again
             UIApplication.shared.isIdleTimerDisabled = false
             self.log("Wake lock disabled (idle timer enabled)")
@@ -391,6 +493,66 @@ class StreamInCallManager: RCTEventEmitter {
         log("Unregistered AVAudioSession.routeChangeNotification observer")
     }
 
+    // MARK: - Interruption Handling
+
+    /// Observes `AVAudioSession.interruptionNotification` to trace and log *why* an interruption fired
+    /// (mic-mute / route-disconnect / PSTN-Siri). Recovery is NOT done here: WebRTC's
+    /// AudioEngineDevice owns it — it stops the engine on interruption-begin and restarts it on
+    /// interruption-end (re-activating the session itself via AVAudioEngine.start)
+    private func registerInterruptionObserver() {
+        if hasRegisteredInterruptionObserver { return }
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAudioInterruption(_:)),
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+        hasRegisteredInterruptionObserver = true
+    }
+
+    private func unregisterInterruptionObserver() {
+        if !hasRegisteredInterruptionObserver { return }
+        NotificationCenter.default.removeObserver(self, name: AVAudioSession.interruptionNotification, object: nil)
+        hasRegisteredInterruptionObserver = false
+    }
+
+    @objc
+    private func handleAudioInterruption(_ notification: Notification) {
+        guard let info = notification.userInfo,
+              let typeRaw = info[AVAudioSessionInterruptionTypeKey] as? UInt,
+              let type = AVAudioSession.InterruptionType(rawValue: typeRaw) else {
+            return
+        }
+
+        let reason = interruptionReason(info)
+        var payload: [String: Any] = ["source": "callmanager"]
+        if let reason {
+            payload["reason"] = reason
+        }
+
+        switch type {
+        case .began:
+            payload["phase"] = "began"
+            sendEvent(withName: StreamInCallManagerEvents.audioInterruption, body: payload)
+            #if DEBUG
+            log("Audio interruption began (reason=\(reason ?? "n/a")). Recovery owned by WebRTC AudioEngineDevice.")
+            #endif
+        case .ended:
+            var shouldResume = false
+            if let optsRaw = info[AVAudioSessionInterruptionOptionKey] as? UInt {
+                shouldResume = AVAudioSession.InterruptionOptions(rawValue: optsRaw).contains(.shouldResume)
+            }
+            payload["phase"] = "ended"
+            payload["shouldResume"] = shouldResume
+            sendEvent(withName: StreamInCallManagerEvents.audioInterruption, body: payload)
+            #if DEBUG
+            log("Audio interruption ended (shouldResume=\(shouldResume)). WebRTC restarts the engine.")
+            #endif
+        @unknown default:
+            break
+        }
+    }
+
     @objc
     private func handleAudioRouteChange(_ notification: Notification) {
         guard let userInfo = notification.userInfo,
@@ -454,18 +616,7 @@ class StreamInCallManager: RCTEventEmitter {
     // MARK: - RCTEventEmitter
 
     override func supportedEvents() -> [String]! {
-        // TODO: list events that can be sent to JS
-        return []
-    }
-
-    @objc
-    override func addListener(_ eventName: String!) {
-        super.addListener(eventName)
-    }
-
-    @objc
-    override func removeListeners(_ count: Double) {
-        super.removeListeners(count)
+        return [StreamInCallManagerEvents.audioInterruption]
     }
 
     // MARK: - Helper Methods
@@ -511,6 +662,30 @@ class StreamInCallManager: RCTEventEmitter {
         }
     }
 
+    /// Best-effort name for the iOS 14.5+ `AVAudioSessionInterruptionReasonKey`.
+    /// Names the iOS 17 cases we care about and falls back to the raw value otherwise.
+    private func interruptionReason(_ info: [AnyHashable: Any]) -> String? {
+        guard #available(iOS 14.5, *),
+              let reasonRaw = info[AVAudioSessionInterruptionReasonKey] as? UInt,
+              let reason = AVAudioSession.InterruptionReason(rawValue: reasonRaw) else {
+            return nil
+        }
+        if #available(iOS 17.0, *) {
+            switch reason {
+            case .builtInMicMuted:
+                return "builtInMicMuted"
+            case .routeDisconnected:
+                return "routeDisconnected"
+            default:
+                break
+            }
+        }
+        if reason == .default {
+            return "default"
+        }
+        return "raw(\(reason.rawValue))"
+    }
+
     // MARK: - Logging Helper
     private func log(_ message: String) {
         NSLog("InCallManager: %@", message)

package/ios/StreamVideoReactNative-Bridging-Header.h

@@ -11,8 +11,6 @@
 #import <WebRTC/RTCVideoTrack.h>
 #import <WebRTC/RTCVideoRenderer.h>
 #import <WebRTC/RTCVideoFrameBuffer.h>
-#import <WebRTC/RTCAudioTrack.h>
-#import <WebRTC/RTCAudioRenderer.h>
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
 

package/ios/StreamVideoReactNative.m

@@ -20,13 +20,6 @@
 #import <stream_react_native_webrtc/stream_react_native_webrtc-Swift.h>
 #endif
 
-// Import Swift-generated header for TracksRecorderManager and friends.
-#if __has_include("stream_video_react_native-Swift.h")
-#import "stream_video_react_native-Swift.h"
-#elif __has_include(<stream_video_react_native/stream_video_react_native-Swift.h>)
-#import <stream_video_react_native/stream_video_react_native-Swift.h>
-#endif
-
 // Do not change these consts, it is what is used react-native-webrtc
 NSNotificationName const kBroadcastStartedNotification = @"iOS_BroadcastStarted";
 NSNotificationName const kBroadcastStoppedNotification = @"iOS_BroadcastStopped";
@@ -692,78 +685,4 @@ RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
     resolve(nil);
 }
 
-#pragma mark - Track Recording
-
-RCT_EXPORT_METHOD(startTrackRecording:(NSDictionary *)options
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
-    if (!webrtcModule) {
-        reject(@"recording_error", @"WebRTCModule not available", nil);
-        return;
-    }
-
-    NSString *videoTrackId = options[@"videoTrackId"];
-    if (![videoTrackId isKindOfClass:[NSString class]]) videoTrackId = nil;
-
-    NSNumber *maxDuration = options[@"maxDurationMs"];
-    NSInteger maxDurationMs = ([maxDuration isKindOfClass:[NSNumber class]])
-        ? [maxDuration integerValue] : 5000;
-
-    NSNumber *targetW = options[@"targetWidth"];
-    NSInteger targetWidth = ([targetW isKindOfClass:[NSNumber class]])
-        ? [targetW integerValue] : 0;
-
-    NSNumber *targetH = options[@"targetHeight"];
-    NSInteger targetHeight = ([targetH isKindOfClass:[NSNumber class]])
-        ? [targetH integerValue] : 0;
-
-    [[TracksRecorderManager shared]
-        startRecordingWithVideoTrackId:videoTrackId
-                         maxDurationMs:maxDurationMs
-                           targetWidth:targetWidth
-                          targetHeight:targetHeight
-                          webRTCModule:webrtcModule
-                            completion:^(NSURL * _Nullable fileURL, NSError * _Nullable err) {
-        if (err) {
-            reject(@"recording_error", err.localizedDescription, err);
-        } else {
-            resolve(fileURL ? fileURL.absoluteString : [NSNull null]);
-        }
-    }];
-}
-
-RCT_EXPORT_METHOD(stopTrackRecording:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-    [[TracksRecorderManager shared] stopRecordingWithCompletion:^{
-        resolve(nil);
-    }];
-}
-
-RCT_EXPORT_METHOD(clearStreamRecordings:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-    [[TracksRecorderManager shared] clearRecordingsDirectoryWithCompletion:^(NSError * _Nullable err) {
-        if (err) {
-            reject(@"clear_error", err.localizedDescription, err);
-        } else {
-            resolve(nil);
-        }
-    }];
-}
-
-RCT_EXPORT_METHOD(getStreamRecordings:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-    NSArray<NSURL *> *urls = [[TracksRecorderManager shared] listRecordings];
-    NSMutableArray<NSString *> *result = [NSMutableArray arrayWithCapacity:urls.count];
-    for (NSURL *url in urls) {
-        NSString *abs = url.absoluteString;
-        if (abs) [result addObject:abs];
-    }
-    resolve(result);
-}
-
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.37.1-beta.0",
+  "version": "1.38.1",
   "description": "Stream Video SDK for React Native",
   "author": "https://getstream.io",
   "homepage": "https://getstream.io/video/docs/react-native/",
@@ -50,8 +50,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.52.1-beta.0",
-    "@stream-io/video-react-bindings": "1.16.3-beta.0",
+    "@stream-io/video-client": "1.53.1",
+    "@stream-io/video-react-bindings": "1.16.4",
     "intl-pluralrules": "2.0.1",
     "react-native-url-polyfill": "^3.0.0",
     "rxjs": "~7.8.2",
@@ -63,7 +63,7 @@
     "@react-native-firebase/messaging": ">=17.5.0",
     "@stream-io/noise-cancellation-react-native": ">=0.1.0",
     "@stream-io/react-native-callingx": ">=0.1.0",
-    "@stream-io/react-native-webrtc": ">=137.2.2",
+    "@stream-io/react-native-webrtc": "^145.0.0",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
     "expo-build-properties": "*",
@@ -116,20 +116,20 @@
     "@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.7.0",
-    "@stream-io/react-native-callingx": "0.4.0",
-    "@stream-io/react-native-webrtc": "137.2.2-alpha.0",
-    "@stream-io/video-filters-react-native": "0.12.4",
+    "@stream-io/noise-cancellation-react-native": "^0.8.0",
+    "@stream-io/react-native-callingx": "^0.5.1",
+    "@stream-io/react-native-webrtc": "145.0.0",
+    "@stream-io/video-filters-react-native": "^0.13.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.6",
     "@types/jest": "^29.5.14",
     "@types/react": "~19.2.15",
     "@types/react-test-renderer": "^19.1.0",
-    "expo": "~56.0.8",
-    "expo-build-properties": "~56.0.16",
+    "expo": "~56.0.9",
+    "expo-build-properties": "~56.0.17",
     "expo-module-scripts": "^56.0.3",
-    "expo-notifications": "~56.0.15",
+    "expo-notifications": "~56.0.16",
     "jest": "^29.7.0",
     "react": "19.2.3",
     "react-native": "0.85.3",

package/src/hooks/index.ts

@@ -7,7 +7,6 @@ export * from './useIsInPiPMode';
 export * from './useAutoEnterPiPEffect';
 export * from './useScreenShareButton';
 export * from './useScreenShareAudioMixing';
-export * from './useLoopbackRecording';
 export * from './useTrackDimensions';
 export * from './useScreenshot';
 export * from './useModeration';

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

@@ -1,10 +1,15 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
-import { AudioDeviceStatus, StreamInCallManagerConfig } from './types';
+import type {
+  AudioDeviceStatus,
+  IOSAudioInterruptionEvent,
+  StreamInCallManagerConfig,
+} from './types';
 import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
 import { videoLoggerSystem } from '@stream-io/video-client';
 
 const NativeManager = NativeModules.StreamInCallManager;
 const CallingxModule = getCallingxLibIfAvailable();
+const AUDIO_INTERRUPTION_EVENT = 'StreamInCallManagerAudioInterruption';
 
 const invariant = (condition: boolean, message: string) => {
   if (!condition) throw new Error(message);
@@ -46,6 +51,8 @@ class AndroidCallManager {
 }
 
 class IOSCallManager {
+  private eventEmitter?: NativeEventEmitter;
+
   /**
    * Will trigger the iOS device selector.
    */
@@ -53,6 +60,23 @@ class IOSCallManager {
     invariant(Platform.OS === 'ios', 'Supported only on iOS');
     NativeManager.showAudioRoutePicker();
   };
+
+  /**
+   * Register a listener for iOS audio interruptions.
+   *
+   * @param onInterruption callback to be called when iOS reports an audio interruption.
+   */
+  addAudioInterruptionListener = (
+    onInterruption: (event: IOSAudioInterruptionEvent) => void,
+  ): (() => void) => {
+    invariant(Platform.OS === 'ios', 'Supported only on iOS');
+    this.eventEmitter ??= new NativeEventEmitter(NativeManager);
+    const s = this.eventEmitter.addListener(
+      AUDIO_INTERRUPTION_EVENT,
+      onInterruption,
+    );
+    return () => s.remove();
+  };
 }
 
 class SpeakerManager {

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

@@ -15,6 +15,13 @@ export type AudioDeviceStatus = {
 export type AudioRole = 'communicator' | 'listener';
 export type DeviceEndpointType = 'speaker' | 'earpiece';
 
+export type IOSAudioInterruptionEvent = {
+  source: 'callmanager' | 'callingx';
+  phase: 'began' | 'ended';
+  reason?: 'default' | 'builtInMicMuted' | 'routeDisconnected' | (string & {});
+  shouldResume?: boolean;
+};
+
 export type StreamInCallManagerConfig =
   | {
       audioRole: 'communicator';