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

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

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIREBASE_DEP_MARKER = exports.FIREBASE_BOM_FALLBACK_VERSION = exports.FIREBASE_MESSAGING_ARTIFACT = exports.STREAM_DEFAULT_SERVICE = exports.GENERATED_SERVICE_CLASS_NAME = exports.EXPO_NOTIFICATIONS_SERVICE = void 0;
+exports.updateManifest = updateManifest;
+exports.buildServiceSource = buildServiceSource;
+exports.validateBaseClass = validateBaseClass;
+exports.resolveBaseClass = resolveBaseClass;
+exports.isExpoNotificationsInstalled = isExpoNotificationsInstalled;
+exports.getGeneratedServiceFqcn = getGeneratedServiceFqcn;
+exports.addFirebaseMessagingDependency = addFirebaseMessagingDependency;
+exports.resolveFirebaseBomVersion = resolveFirebaseBomVersion;
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const GENERATED_SERVICE_CLASS_NAME = 'StreamVideoMessagingService';
+exports.GENERATED_SERVICE_CLASS_NAME = GENERATED_SERVICE_CLASS_NAME;
+const STREAM_DEFAULT_SERVICE = 'io.getstream.rn.callingx.StreamMessagingService';
+exports.STREAM_DEFAULT_SERVICE = STREAM_DEFAULT_SERVICE;
+/** React Native Firebase's own FCM service. */
+const RN_FIREBASE_SERVICE = 'io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService';
+/** expo-notifications' FCM service — the default base auto-detected when installed. */
+const EXPO_NOTIFICATIONS_SERVICE = 'expo.modules.notifications.service.ExpoFirebaseMessagingService';
+exports.EXPO_NOTIFICATIONS_SERVICE = EXPO_NOTIFICATIONS_SERVICE;
+const MESSAGING_EVENT_ACTION = 'com.google.firebase.MESSAGING_EVENT';
+/**
+ * The generated service lives in the `:app` module, which only has
+ * firebase-messaging on its *runtime* classpath (via callingx / RNFB /
+ * expo-notifications `implementation` deps). We add it as `compileOnly` so the
+ * app can compile a `FirebaseMessagingService` subclass. The runtime artifact is
+ * still supplied by those modules, so this avoids a version conflict.
+ */
+const FIREBASE_MESSAGING_ARTIFACT = 'com.google.firebase:firebase-messaging';
+exports.FIREBASE_MESSAGING_ARTIFACT = FIREBASE_MESSAGING_ARTIFACT;
+/**
+ * Fallback Firebase BOM version, used only when the live BOM cannot be resolved
+ * from @react-native-firebase/app. This is the BOM shipped by the minimum RNFB
+ * version we support: @stream-io/react-native-callingx declares a
+ * `@react-native-firebase/* >= 23.0.0` peer dependency, and RNFB `23.0.0` pins
+ * firebase-bom `34.0.0`. Keep in sync with that peer floor.
+ */
+const FIREBASE_BOM_FALLBACK_VERSION = '34.0.0';
+exports.FIREBASE_BOM_FALLBACK_VERSION = FIREBASE_BOM_FALLBACK_VERSION;
+/** Stable comment used to detect (and avoid duplicating) our gradle injection. */
+const FIREBASE_DEP_MARKER = '// Added by @stream-io/video-react-native-sdk for the generated FCM messaging service';
+exports.FIREBASE_DEP_MARKER = FIREBASE_DEP_MARKER;
+function getAndroidPackage(config) {
+    const modResults = config.modResults;
+    const pkg = config.android?.package ?? modResults?.manifest?.$?.package;
+    if (!pkg) {
+        throw new Error('[StreamVideo] Unable to resolve the Android package name required to generate ' +
+            'the FCM messaging service. Set "android.package" in your app config.');
+    }
+    return pkg;
+}
+function getGeneratedServiceFqcn(androidPackage) {
+    return `${androidPackage}.${GENERATED_SERVICE_CLASS_NAME}`;
+}
+function validateBaseClass(baseClass) {
+    if (typeof baseClass !== 'string' || baseClass.trim().length === 0) {
+        throw new Error('[StreamVideo] "androidMessagingServiceBaseClass" must be a non-empty string.');
+    }
+    if (!baseClass.includes('.')) {
+        throw new Error(`[StreamVideo] "androidMessagingServiceBaseClass" must be a fully-qualified class name ` +
+            `including its package (e.g. "expo.modules.notifications.service.ExpoFirebaseMessagingService"), ` +
+            `received "${baseClass}".`);
+    }
+}
+function isExpoNotificationsInstalled(projectRoot) {
+    try {
+        require.resolve('expo-notifications/package.json', projectRoot ? { paths: [projectRoot] } : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveBaseClass(value, projectRoot) {
+    if (value === null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        validateBaseClass(value);
+        return value;
+    }
+    return isExpoNotificationsInstalled(projectRoot)
+        ? EXPO_NOTIFICATIONS_SERVICE
+        : undefined;
+}
+/** Kotlin source for the generated messaging service. */
+function buildServiceSource(androidPackage, baseClassFqcn) {
+    const simpleName = baseClassFqcn.split('.').pop();
+    const shouldForwardNewToken = baseClassFqcn !== RN_FIREBASE_SERVICE;
+    const onNewToken = shouldForwardNewToken
+        ? `
+  override fun onNewToken(token: String) {
+    super.onNewToken(token)
+    // Keep Stream's device registration working under a non-RNFirebase base.
+    StreamMessagingHelper.forwardNewToken(token)
+  }
+`
+        : '';
+    return `package ${androidPackage}
+
+import android.annotation.SuppressLint
+import com.google.firebase.messaging.RemoteMessage
+import io.getstream.rn.callingx.StreamMessagingHelper
+import ${baseClassFqcn}
+
+/**
+ * AUTO-GENERATED by the @stream-io/video-react-native-sdk Expo config plugin.
+ * Do not edit — this file is regenerated on every \`expo prebuild\`.
+ *
+ * Extends the app-declared FCM service (${baseClassFqcn}) and injects Stream
+ * Video incoming-call (\`call.ring\`) handling. Stream's default
+ * ${STREAM_DEFAULT_SERVICE} is removed from the merged manifest so this class is
+ * the single FirebaseMessagingService for the app.
+ */
+@SuppressLint("MissingFirebaseInstanceTokenRefresh")
+class ${GENERATED_SERVICE_CLASS_NAME} : ${simpleName}() {
+  override fun onMessageReceived(remoteMessage: RemoteMessage) {
+    if (StreamMessagingHelper.isStreamCallRing(remoteMessage)) {
+      StreamMessagingHelper.handleMessage(applicationContext, remoteMessage)
+      return
+    }
+    super.onMessageReceived(remoteMessage)
+  }
+${onNewToken}}
+`;
+}
+function updateManifest(androidManifest, generatedFqcn, baseClassFqcn) {
+    const manifest = androidManifest.manifest;
+    if (!manifest ||
+        !Array.isArray(manifest.application) ||
+        !manifest.application[0]) {
+        throw new Error('[StreamVideo] Malformed AndroidManifest.xml: missing <application> element.');
+    }
+    manifest.$ = manifest.$ ?? {};
+    manifest.$['xmlns:tools'] =
+        manifest.$['xmlns:tools'] ?? 'http://schemas.android.com/tools';
+    // Services whose registration we strip so the generated service is the only
+    // MESSAGING_EVENT handler: Stream's default (from react-native-callingx) and
+    // the base class (its logic still runs — the generated service subclasses it).
+    const servicesToRemove = [
+        ...new Set([STREAM_DEFAULT_SERVICE, baseClassFqcn]),
+    ];
+    const application = manifest.application[0];
+    const existing = application.service ?? [];
+    // Drop our own previously-added entries so re-runs don't duplicate them.
+    const services = existing.filter((service) => {
+        const name = service?.$?.['android:name'];
+        return name !== generatedFqcn && !servicesToRemove.includes(name ?? '');
+    });
+    // The generated service becomes the single com.google.firebase.MESSAGING_EVENT handler.
+    services.push({
+        $: {
+            'android:name': generatedFqcn,
+            'android:exported': 'false',
+        },
+        'intent-filter': [
+            {
+                action: [{ $: { 'android:name': MESSAGING_EVENT_ACTION } }],
+            },
+        ],
+    });
+    // Remove the competing services so they don't win FCM delivery. `tools:node`
+    // is not part of the strict typing but is valid manifest merger syntax.
+    for (const name of servicesToRemove) {
+        services.push({
+            $: {
+                'android:name': name,
+                'tools:node': 'remove',
+            },
+        });
+    }
+    application.service = services;
+    return androidManifest;
+}
+const withGeneratedMessagingServiceFile = (config, value) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        (dangerousConfig) => {
+            const baseClassFqcn = resolveBaseClass(value, dangerousConfig.modRequest.projectRoot);
+            if (!baseClassFqcn) {
+                return dangerousConfig;
+            }
+            const androidPackage = getAndroidPackage(dangerousConfig);
+            const packagePath = androidPackage.replace(/\./g, path.sep);
+            const javaDir = path.join(dangerousConfig.modRequest.platformProjectRoot, 'app', 'src', 'main', 'java', packagePath);
+            fs.mkdirSync(javaDir, { recursive: true });
+            const destPath = path.join(javaDir, `${GENERATED_SERVICE_CLASS_NAME}.kt`);
+            fs.writeFileSync(destPath, buildServiceSource(androidPackage, baseClassFqcn), 'utf8');
+            return dangerousConfig;
+        },
+    ]);
+};
+const withMessagingServiceManifest = (config, value) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (androidConfig) => {
+        const baseClassFqcn = resolveBaseClass(value, androidConfig.modRequest.projectRoot);
+        if (!baseClassFqcn) {
+            return androidConfig;
+        }
+        const androidPackage = getAndroidPackage(androidConfig);
+        androidConfig.modResults = updateManifest(androidConfig.modResults, getGeneratedServiceFqcn(androidPackage), baseClassFqcn);
+        return androidConfig;
+    });
+};
+function resolveFirebaseBomVersion(projectRoot) {
+    try {
+        const pkgPath = require.resolve('@react-native-firebase/app/package.json', projectRoot ? { paths: [projectRoot] } : undefined);
+        const pkg = require(pkgPath);
+        const bom = pkg?.sdkVersions?.android?.firebase;
+        return typeof bom === 'string' && bom.length > 0 ? bom : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const DEPENDENCIES_BLOCK = /dependencies\s*\{/;
+function addFirebaseMessagingDependency(contents, bomVersion) {
+    if (contents.includes(FIREBASE_DEP_MARKER)) {
+        return contents;
+    }
+    if (!DEPENDENCIES_BLOCK.test(contents)) {
+        throw new Error('[StreamVideo] Could not find a "dependencies { }" block in the app build.gradle ' +
+            'to add the firebase-messaging compile dependency for the generated FCM service.');
+    }
+    const lines = `    ${FIREBASE_DEP_MARKER}\n` +
+        `    compileOnly(platform("com.google.firebase:firebase-bom:${bomVersion ?? FIREBASE_BOM_FALLBACK_VERSION}"))\n` +
+        `    compileOnly("${FIREBASE_MESSAGING_ARTIFACT}")`;
+    return contents.replace(DEPENDENCIES_BLOCK, (match) => `${match}\n${lines}`);
+}
+const withMessagingServiceGradle = (config, value) => {
+    return (0, config_plugins_1.withAppBuildGradle)(config, (gradleConfig) => {
+        const baseClassFqcn = resolveBaseClass(value, gradleConfig.modRequest.projectRoot);
+        if (!baseClassFqcn) {
+            return gradleConfig;
+        }
+        const bomVersion = resolveFirebaseBomVersion(gradleConfig.modRequest.projectRoot);
+        gradleConfig.modResults.contents = addFirebaseMessagingDependency(gradleConfig.modResults.contents, bomVersion);
+        return gradleConfig;
+    });
+};
+const withAndroidMessagingService = (config, props) => {
+    // The messaging-service override only matters for the ringing flow, skip it otherwise.
+    if (!props?.ringing) {
+        return config;
+    }
+    const value = props?.androidMessagingServiceBaseClass;
+    let updated = withGeneratedMessagingServiceFile(config, value);
+    updated = withMessagingServiceManifest(updated, value);
+    updated = withMessagingServiceGradle(updated, value);
+    return updated;
+};
+exports.default = withAndroidMessagingService;

package/ios/StreamInCallManager.m

@@ -17,6 +17,13 @@ RCT_EXTERN_METHOD(stop)
 
 RCT_EXTERN_METHOD(showAudioRoutePicker)
 
+RCT_EXTERN_METHOD(getAudioDeviceStatus:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(chooseAudioDeviceEndpoint:(NSString *)id)
+
+RCT_EXTERN_METHOD(reapplyAudioRoute)
+
 RCT_EXTERN_METHOD(setForceSpeakerphoneOn:(BOOL)enable)
 
 RCT_EXTERN_METHOD(setMicrophoneMute:(BOOL)enable)

package/ios/StreamInCallManager.swift

@@ -17,6 +17,20 @@ enum DefaultAudioDevice {
     case earpiece
 }
 
+/// An explicit output route chosen via the device picker.
+///
+/// `nil` (no explicit pick) means the call uses the category-driven default
+/// (`.defaultToSpeaker` when the default device is the speaker), which keeps the
+/// default route headphone-aware. Once the user picks a device we drive the route
+/// explicitly instead — `.defaultToSpeaker` is dropped so `overrideOutputAudioPort(.none)`
+/// can reach the earpiece (with `.defaultToSpeaker` present it resolves to the speaker).
+private enum OutputRouting {
+    case speaker
+    /// Built-in earpiece (the built-in mic uid), wired headset, or Bluetooth — all
+    /// reached via `overrideOutputAudioPort(.none)` + `setPreferredInput(port)`.
+    case input(uid: String)
+}
+
 private enum Constants {
     /// Debounce interval for refreshing stereo playout state after audio route changes.
     ///
@@ -32,6 +46,14 @@ private enum Constants {
 
 private enum StreamInCallManagerEvents {
     static let audioInterruption = "StreamInCallManagerAudioInterruption"
+    static let audioDeviceChanged = "onAudioDeviceChanged"
+}
+
+/// Stable device-id scheme for the JS layer. The built-in speaker is synthetic; every
+/// other device is keyed by its `AVAudioSessionPortDescription.uid` (the
+/// built-in earpiece is the built-in mic input routed with `.none`).
+private enum AudioDeviceId {
+    static let speaker = "speaker"
 }
 
 @objc(StreamInCallManager)
@@ -42,6 +64,9 @@ class StreamInCallManager: RCTEventEmitter {
     private var audioManagerActivated = false
     private var callAudioRole: CallAudioRole = .communicator
     private var defaultAudioDevice: DefaultAudioDevice = .speaker
+    /// The user's explicit output pick, or `nil` to use the category default.
+    /// Re-applied on every engine rebuild so the pick survives interruptions.
+    private var selectedOutput: OutputRouting?
     private var enableStereo: Bool = false
     private var previousVolume: Float = 0.75
 
@@ -101,7 +126,7 @@ class StreamInCallManager: RCTEventEmitter {
     }
     
     /// Builds the audio config for the current role/device and sets it as WebRTC's default.
-    private func makeAudioConfiguration() -> RTCAudioSessionConfiguration {
+    private func makeAudioConfiguration(for routing: OutputRouting?) -> RTCAudioSessionConfiguration {
         let category: AVAudioSession.Category
         let mode: AVAudioSession.Mode
         let options: AVAudioSession.CategoryOptions
@@ -138,7 +163,14 @@ class StreamInCallManager: RCTEventEmitter {
             #endif
             category = .playAndRecord
             mode = .voiceChat
-            options = defaultAudioDevice == .speaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
+            
+            var mustSetDefaultToSpeaker = defaultAudioDevice == .speaker
+            if case .input(let uid) = routing, isBuiltInMicUid(uid) {
+                // the selected output is a built-in mic
+                // then we always can't use defaultToSpeaker
+                mustSetDefaultToSpeaker = false
+            }
+            options = mustSetDefaultToSpeaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
         }
 
         let rtcConfig = RTCAudioSessionConfiguration.webRTC()
@@ -162,16 +194,21 @@ class StreamInCallManager: RCTEventEmitter {
     func setup() {
         audioSessionQueue.async { [self] in
             let adm = getAudioDeviceModule()
+            selectedOutput = nil
+
+            // This path (no CallKit) owns audio-session activation itself, so the
+            // engine must be allowed to start. Restores availability in case a
+            // prior CallKit call had gated it off.
+            _ = adm.setEngineAvailability(.default)
 
             // Stereo is listener-only and applies live. Cleared by stop()'s reset().
             if callAudioRole == .listener && enableStereo {
                 adm.setStereoPlayoutPreference(true)
             }
 
-            let rtcConfig = makeAudioConfiguration()
+            let rtcConfig = makeAudioConfiguration(for: selectedOutput)
             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() }
@@ -223,13 +260,16 @@ class StreamInCallManager: RCTEventEmitter {
             return
         }
 
-        let rtcConfig = makeAudioConfiguration()
+        let rtcConfig = makeAudioConfiguration(for: selectedOutput)
         let session = RTCAudioSession.sharedInstance()
         session.lockForConfiguration()
         defer { session.unlockForConfiguration() }
         do {
-            try session.setConfiguration(rtcConfig)
-            try session.setActive(true)
+            try session.setConfiguration(rtcConfig, active: true)
+            // Re-apply the explicit pick (if any) so it survives the engine rebuild.
+            if let selectedOutput {
+                try applyOutputRouting(selectedOutput)
+            }
             log("engineWillEnable: applied category=\(rtcConfig.category) mode=\(rtcConfig.mode) activated=true")
         } catch {
             log("engineWillEnable error: \(String(describing: error))")
@@ -252,6 +292,21 @@ class StreamInCallManager: RCTEventEmitter {
         }
     }
 
+    private func clearOutputRouting() {
+        if Self.callingxOwnsSession() {
+            return
+        }
+        let session = RTCAudioSession.sharedInstance()
+        session.lockForConfiguration()
+        defer { session.unlockForConfiguration() }
+        do {
+            try session.overrideOutputAudioPort(.none)
+            try AVAudioSession.sharedInstance().setPreferredInput(nil)
+        } catch {
+            log("clearOutputRouting 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
@@ -303,6 +358,7 @@ class StreamInCallManager: RCTEventEmitter {
             }
             let adm = getAudioDeviceModule()
             adm.reset()
+            clearOutputRouting()
             // 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.
@@ -313,6 +369,7 @@ class StreamInCallManager: RCTEventEmitter {
             stereoRefreshWorkItem = nil
             callAudioRole = .communicator
             defaultAudioDevice = .speaker
+            selectedOutput = nil
             enableStereo = false
             audioManagerActivated = false
         }
@@ -345,18 +402,21 @@ class StreamInCallManager: RCTEventEmitter {
 
     @objc(setForceSpeakerphoneOn:)
     func setForceSpeakerphoneOn(enable: Bool) {
-        audioSessionQueue.async { [weak self] in
+        audioSessionQueue.async { [self] in
             let session = RTCAudioSession.sharedInstance()
             session.lockForConfiguration()
             defer {
                 session.unlockForConfiguration()
             }
-            let avAudioSession = AVAudioSession.sharedInstance()
             do {
-                try avAudioSession.overrideOutputAudioPort(enable ? .speaker : .none)
-                try avAudioSession.setActive(true)
+                if enable {
+                    try applyOutputRouting(.speaker)
+                } else {
+                    try session.overrideOutputAudioPort(.none)
+                    try AVAudioSession.sharedInstance().setPreferredInput(nil)
+                }
             } catch {
-                self?.log("Error setting speakerphone: \(error)")
+                self.log("Error setting speakerphone: \(error)")
             }
         }
     }
@@ -367,6 +427,174 @@ class StreamInCallManager: RCTEventEmitter {
         log("iOS does not support setMicrophoneMute()")
     }
 
+    // MARK: - Audio Device Picker
+
+    @objc(getAudioDeviceStatus:reject:)
+    func getAudioDeviceStatus(resolve: @escaping RCTPromiseResolveBlock,
+                              reject: @escaping RCTPromiseRejectBlock) {
+        audioSessionQueue.async { [weak self] in
+            guard let self else {
+                resolve(["devices": [], "currentEndpointType": "Unknown"])
+                return
+            }
+            resolve(self.buildAudioDevicesState())
+        }
+    }
+
+    /// Switches the audio output to the device with the given id.
+    @objc(chooseAudioDeviceEndpoint:)
+    func chooseAudioDeviceEndpoint(id: String) {
+        audioSessionQueue.async { [self] in
+            guard callAudioRole == .communicator else {
+                log("chooseAudioDeviceEndpoint ignored: only supported in communicator role")
+                return
+            }
+
+            let routing: OutputRouting = id == AudioDeviceId.speaker ? .speaker : .input(uid: id)
+
+            let session = RTCAudioSession.sharedInstance()
+            session.lockForConfiguration()
+            defer { session.unlockForConfiguration() }
+            do {
+                // Reconfigure first so the live category matches the pick (e.g. the earpiece
+                // drops `.defaultToSpeaker`, otherwise overrideOutputAudioPort(.none) would
+                // resolve back to the speaker). Then drive the route.
+                try session.setConfiguration(makeAudioConfiguration(for: routing))
+                try applyOutputRouting(routing)
+                selectedOutput = routing
+            } catch {
+                // a failure leaves the previous route intact.
+                log("chooseAudioDeviceEndpoint error: \(String(describing: error))")
+            }
+        }
+    }
+
+    /// Re-applies the current output pick (`selectedOutput`) — category untouched, no setActive.
+    /// Called on interruption-end (via callingx's interruption event, forwarded from JS) to
+    /// restore a Bluetooth/wired route
+    @objc(reapplyAudioRoute)
+    func reapplyAudioRoute() {
+        audioSessionQueue.async { [self] in
+            guard callAudioRole == .communicator, let routing = selectedOutput else { return }
+            let session = RTCAudioSession.sharedInstance()
+            session.lockForConfiguration()
+            defer { session.unlockForConfiguration() }
+            do {
+                try applyOutputRouting(routing)
+            } catch {
+                log("reapplyAudioRoute error: \(String(describing: error))")
+            }
+        }
+    }
+
+    /// Whether `uid` is the built-in microphone (i.e. an earpiece pick, in our id scheme).
+    private func isBuiltInMicUid(_ uid: String) -> Bool {
+        AVAudioSession.sharedInstance().availableInputs?
+            .contains { $0.uid == uid && $0.portType == .builtInMic } ?? false
+    }
+
+    /// Drives the audio route. Throws if a session command fails, so callers can gate
+    /// committed state (e.g. `selectedOutput`) on the route actually being applied.
+    private func applyOutputRouting(_ routing: OutputRouting) throws {
+        let rtcSession = RTCAudioSession.sharedInstance()
+        let availableInputs = AVAudioSession.sharedInstance().availableInputs
+        switch routing {
+            case .speaker:
+                if let builtInMic = availableInputs?.first(where: { $0.portType == .builtInMic }) {
+                    try rtcSession.setPreferredInput(builtInMic)
+                }
+                try rtcSession.overrideOutputAudioPort(.speaker)
+            case .input(let uid):
+                try rtcSession.overrideOutputAudioPort(.none)
+                if let port = availableInputs?.first(where: { $0.uid == uid }) {
+                    try rtcSession.setPreferredInput(port)
+                } else {
+                    log("applyOutputRouting: no input found for id \(uid)")
+                }
+        }
+    }
+
+    /// Canonical endpoint-type string shared with the JS layer.M ust match with the Android implementation.
+    private func endpointType(for portType: AVAudioSession.Port) -> String {
+        switch portType {
+        case .builtInSpeaker: return "Speaker"
+        case .builtInMic, .builtInReceiver: return "Earpiece"
+        case .headphones, .headsetMic: return "Wired Headset"
+        case .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .carAudio: return "Bluetooth Device"
+        default: return "Unknown"
+        }
+    }
+
+    private func hasExternalAudioDevice(_ session: AVAudioSession) -> Bool {
+        let external: Set<AVAudioSession.Port> = [
+            .headphones, .headsetMic, .bluetoothHFP, .bluetoothA2DP, .bluetoothLE, .carAudio,
+        ]
+        if session.availableInputs?.contains(where: { external.contains($0.portType) }) == true {
+            return true
+        }
+        return session.currentRoute.outputs.contains { external.contains($0.portType) }
+    }
+
+    private func buildAudioDevicesState() -> [String: Any] {
+        let session = AVAudioSession.sharedInstance()
+        let inputs = session.availableInputs ?? []
+        let hasExternal = hasExternalAudioDevice(session)
+
+        var devices: [[String: String]] = [
+            ["id": AudioDeviceId.speaker, "name": "Speaker", "type": "Speaker"]
+        ]
+        for port in inputs {
+            let isBuiltInMic = port.portType == .builtInMic
+            // Hide the earpiece when a wired/BT device is present — it can't be routed to
+            // while one is connected, so listing it would be a dead, duplicate option.
+            if isBuiltInMic && hasExternal { continue }
+            devices.append([
+                "id": port.uid,
+                "name": isBuiltInMic ? "Earpiece" : port.portName,
+                "type": endpointType(for: port.portType),
+            ])
+        }
+
+        let output = session.currentRoute.outputs.first
+        let currentEndpointType = output.map { endpointType(for: $0.portType) } ?? "Unknown"
+
+        // Output-only routes (e.g. wired headphones without a mic) never appear in
+        // availableInputs. Add the active output when no listed device already represents
+        // its endpoint type, so it stays visible and selectable in the picker.
+        if let output,
+           output.portType != .builtInSpeaker,
+           !devices.contains(where: { $0["type"] == currentEndpointType }) {
+            devices.append([
+                "id": output.uid,
+                "name": output.portName,
+                "type": currentEndpointType,
+            ])
+        }
+
+        let selectedDeviceId: String?
+        if output?.portType == .builtInSpeaker {
+            selectedDeviceId = AudioDeviceId.speaker
+        } else if let inputUid = session.currentRoute.inputs.first?.uid,
+                  devices.contains(where: { $0["id"] == inputUid }) {
+            // The active input maps to a listed device (earpiece / wired / BT).
+            selectedDeviceId = inputUid
+        } else {
+            // Output is on a device whose active input differs from a listed one — e.g. BT is
+            // the output while the input stayed built-in mic. Match by the output's endpoint
+            // type so the picker highlights the actual output (not the earpiece).
+            selectedDeviceId = devices.first(where: { $0["type"] == currentEndpointType })?["id"]
+        }
+
+        var result: [String: Any] = [
+            "devices": devices,
+            "currentEndpointType": currentEndpointType,
+        ]
+        if let selectedDeviceId {
+            result["selectedDeviceId"] = selectedDeviceId
+        }
+        return result
+    }
+
     @objc
     func logAudioState() {
         log(getAudioStateLog())
@@ -580,7 +808,19 @@ class StreamInCallManager: RCTEventEmitter {
         }
 
         logAudioState()
-        
+
+        // Notify JS of the updated device list / selection.
+        audioSessionQueue.async { [weak self] in
+            guard let self,
+                  self.audioManagerActivated,
+                  self.callAudioRole == .communicator,
+                  !Self.callingxOwnsSession() else { return }
+            self.sendEvent(
+                withName: StreamInCallManagerEvents.audioDeviceChanged,
+                body: self.buildAudioDevicesState()
+            )
+        }
+
         // Route changes can arrive on arbitrary queues; ensure UI-safe work on main
         DispatchQueue.main.async { [weak self] in
             self?.updateProximityMonitoring()
@@ -616,7 +856,10 @@ class StreamInCallManager: RCTEventEmitter {
     // MARK: - RCTEventEmitter
 
     override func supportedEvents() -> [String]! {
-        return [StreamInCallManagerEvents.audioInterruption]
+        return [
+            StreamInCallManagerEvents.audioInterruption,
+            StreamInCallManagerEvents.audioDeviceChanged,
+        ]
     }
 
     // MARK: - Helper Methods