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

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

@@ -54,6 +54,7 @@ const RN_FIREBASE_SERVICE = 'io.invertase.firebase.messaging.ReactNativeFirebase
 /** 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 EXPO_NOTIFICATIONS_PACKAGE = 'expo-notifications';
 const MESSAGING_EVENT_ACTION = 'com.google.firebase.MESSAGING_EVENT';
 /**
  * The generated service lives in the `:app` module, which only has
@@ -99,13 +100,38 @@ function validateBaseClass(baseClass) {
     }
 }
 function isExpoNotificationsInstalled(projectRoot) {
+    return isPackageUsedByApp(EXPO_NOTIFICATIONS_PACKAGE, projectRoot);
+}
+/**
+ * Whether `packageName` belongs to this app's own dependency graph.
+ *
+ * Deliberately avoids `require.resolve`, which walks up the directory tree: in a
+ * workspace that also finds packages hoisted to the repo root by a *sibling*
+ * app. Those are not linked into this app's Android build, so extending their
+ * service generates Kotlin that cannot compile.
+ */
+function isPackageUsedByApp(packageName, projectRoot) {
+    if (!projectRoot) {
+        // No project context to scope the lookup to; plain resolution is all we have.
+        try {
+            require.resolve(`${packageName}/package.json`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     try {
-        require.resolve('expo-notifications/package.json', projectRoot ? { paths: [projectRoot] } : undefined);
-        return true;
+        const appPackageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+        // Only runtime dependencies: a devDependency is not linked into the build.
+        if (packageName in { ...appPackageJson?.dependencies }) {
+            return true;
+        }
     }
     catch {
-        return false;
+        // Unreadable app package.json: fall through to the filesystem check.
     }
+    return fs.existsSync(path.join(projectRoot, 'node_modules', packageName, 'package.json'));
 }
 function resolveBaseClass(value, projectRoot) {
     if (value === null) {

package/expo-config-plugin/dist/withIosScreenCapture/addBroadcastExtensionXcodeTarget.js

@@ -33,8 +33,88 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDeploymentTarget = exports.MIN_DEPLOYMENT_TARGET = void 0;
 exports.default = addBroadcastExtensionXcodeTarget;
 const util = __importStar(require("util"));
+/**
+ * The lowest iOS version the broadcast extension is built for.
+ */
+exports.MIN_DEPLOYMENT_TARGET = '15.0';
+/**
+ * A plain dotted version number, for example `15` or `16.4`. Anything else
+ * (`$(inherited)`, `16.4beta`) is not comparable and must not be adopted:
+ * `Number.parseInt` would silently accept a trailing suffix.
+ */
+const VERSION_PATTERN = /^\d+(?:\.\d+)*$/;
+/**
+ * Returns true when `candidate` is a higher iOS version than `current`.
+ * Values that are not plain version numbers are treated as not higher.
+ */
+const isHigherVersion = (candidate, current) => {
+    if (!VERSION_PATTERN.test(candidate)) {
+        return false;
+    }
+    const parse = (value) => value.split('.').map((part) => Number.parseInt(part, 10));
+    const parsedCandidate = parse(candidate);
+    const parsedCurrent = parse(current);
+    const length = Math.max(parsedCandidate.length, parsedCurrent.length);
+    for (let index = 0; index < length; index++) {
+        const left = parsedCandidate[index] ?? 0;
+        const right = parsedCurrent[index] ?? 0;
+        if (left !== right) {
+            return left > right;
+        }
+    }
+    return false;
+};
+/**
+ * Deployment targets declared by the host app target and by the project itself.
+ *
+ * Scoped to those two on purpose. `pbxXCBuildConfigurationSection()` also
+ * returns configurations belonging to unrelated targets (widgets, share or
+ * notification-service extensions), and adopting the highest of those could make
+ * the broadcast extension require a newer iOS than the app it ships inside,
+ * which would silently drop screen share on devices in between.
+ */
+const collectHostDeploymentTargets = (proj) => {
+    const configurations = (proj.pbxXCBuildConfigurationSection?.() ??
+        {});
+    const configurationLists = (proj.pbxXCConfigurationList?.() ?? {});
+    const listUuids = [
+        proj.getFirstTarget?.()?.firstTarget?.buildConfigurationList,
+        proj.getFirstProject?.()?.firstProject?.buildConfigurationList,
+    ].filter((uuid) => typeof uuid === 'string');
+    const values = [];
+    for (const listUuid of listUuids) {
+        const entries = configurationLists[listUuid]?.buildConfigurations ?? [];
+        for (const entry of entries) {
+            const value = configurations[entry?.value]?.buildSettings?.IPHONEOS_DEPLOYMENT_TARGET;
+            if (value === undefined || value === null) {
+                continue;
+            }
+            values.push(String(value).replace(/"/g, '').trim());
+        }
+    }
+    return values;
+};
+/**
+ * Resolves the deployment target to use for the broadcast extension.
+ *
+ * The extension mirrors the highest deployment target of its host app, so it
+ * never requires a newer iOS than the app itself and it satisfies the minimum
+ * the toolchain accepts (Xcode 27 rejects anything below 15.0). The value only
+ * ever moves up from {@link MIN_DEPLOYMENT_TARGET}.
+ */
+const resolveDeploymentTarget = (proj) => {
+    let resolved = exports.MIN_DEPLOYMENT_TARGET;
+    for (const candidate of collectHostDeploymentTargets(proj)) {
+        if (isHigherVersion(candidate, resolved)) {
+            resolved = candidate;
+        }
+    }
+    return resolved;
+};
+exports.resolveDeploymentTarget = resolveDeploymentTarget;
 function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extensionBundleIdentifier, currentProjectVersion, marketingVersion, developmentTeamId, }) {
     const targets = proj.getFirstProject().firstProject.targets ?? [];
     if (targets.length > 0 &&
@@ -50,6 +130,7 @@ function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extens
         marketingVersion,
         extensionName,
         appName,
+        developmentTeamId,
     });
     const productFile = addProductFile(proj, extensionName, groupName);
     const target = addToPbxNativeTargetSection(proj, {
@@ -74,7 +155,7 @@ function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extens
     });
     addPbxGroup(proj, productFile);
 }
-const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjectVersion, marketingVersion, extensionName, }) => {
+const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjectVersion, marketingVersion, extensionName, developmentTeamId, }) => {
     const commonBuildSettings = {
         CLANG_ANALYZER_NONNULL: 'YES',
         CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION: 'YES_AGGRESSIVE',
@@ -86,12 +167,13 @@ const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjec
         CODE_SIGN_ENTITLEMENTS: `${extensionName}/${extensionName}.entitlements`,
         CODE_SIGN_STYLE: 'Automatic',
         CURRENT_PROJECT_VERSION: currentProjectVersion,
+        DEVELOPMENT_TEAM: developmentTeamId,
         GCC_C_LANGUAGE_STANDARD: 'gnu11',
         GENERATE_INFOPLIST_FILE: 'YES',
         INFOPLIST_FILE: `${extensionName}/Info.plist`,
         INFOPLIST_KEY_CFBundleDisplayName: `${extensionName}`,
         INFOPLIST_KEY_NSHumanReadableCopyright: quoted(''),
-        IPHONEOS_DEPLOYMENT_TARGET: '14.0',
+        IPHONEOS_DEPLOYMENT_TARGET: (0, exports.resolveDeploymentTarget)(proj),
         LD_RUNPATH_SEARCH_PATHS: quoted('$(inherited) @executable_path/Frameworks @executable_path/../../Frameworks'),
         MARKETING_VERSION: marketingVersion,
         MTL_FAST_MATH: 'YES',

package/expo-config-plugin/dist/withIosScreenCapture/withPlistUpdates.js

@@ -6,8 +6,7 @@ exports.default = withPlistUpdates;
 // adds the app group identifier to the app's entitlements file
 const withAppEntitlements = (configuration) => {
     return (0, config_plugins_1.withEntitlementsPlist)(configuration, (config) => {
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
         config.modResults['com.apple.security.application-groups'] = [
             appGroupIdentifier,
         ];
@@ -16,10 +15,8 @@ const withAppEntitlements = (configuration) => {
 };
 const withInfoPlistRTC = (configuration) => {
     return (0, config_plugins_1.withInfoPlist)(configuration, (config) => {
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
-        const extensionBundleIdentifier = `${config.ios
-            .bundleIdentifier}.broadcast`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.broadcast`;
         config.modResults.RTCAppGroupIdentifier = appGroupIdentifier;
         config.modResults.RTCScreenSharingExtension = extensionBundleIdentifier;
         if (!config.modResults.UIBackgroundModes) {

package/expo-config-plugin/dist/withIosScreenCapture/withTarget.js

@@ -46,8 +46,7 @@ const withTarget = (configuration, props) => {
     return (0, config_plugins_1.withXcodeProject)(configuration, (config) => {
         const appName = config.modRequest.projectName;
         const extensionName = 'broadcast';
-        const extensionBundleIdentifier = `${config.ios
-            .bundleIdentifier}.broadcast`;
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.broadcast`;
         const currentProjectVersion = config.ios.buildNumber || '1';
         const marketingVersion = config.version;
         const proj = config.modResults;
@@ -63,8 +62,7 @@ const withTarget = (configuration, props) => {
             marketingVersion,
             developmentTeamId,
         });
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
         const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'broadcast');
         addBroadcastEntitlementsFile({
             proj,
@@ -103,6 +101,7 @@ const addBroadcastSourceFiles = ({ proj, extensionRootPath, appGroupIdentifier,
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'Atomic.swift'), path.join(extensionRootPath, 'Atomic.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'DarwinNotificationCenter.swift'), path.join(extensionRootPath, 'DarwinNotificationCenter.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SampleUploader.swift'), path.join(extensionRootPath, 'SampleUploader.swift'));
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'AudioUploader.swift'), path.join(extensionRootPath, 'AudioUploader.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SocketConnection.swift'), path.join(extensionRootPath, 'SocketConnection.swift'));
     // Update app group bundle id in SampleHandler code
     const code = fs.readFileSync(path.join(extensionRootPath, 'SampleHandler.swift'), { encoding: 'utf-8' });
@@ -126,6 +125,9 @@ const addBroadcastSourceFiles = ({ proj, extensionRootPath, appGroupIdentifier,
     proj.addSourceFile('SampleUploader.swift', {
         target: targetUuid,
     }, groupUuid);
+    proj.addSourceFile('AudioUploader.swift', {
+        target: targetUuid,
+    }, groupUuid);
     proj.addSourceFile('SocketConnection.swift', {
         target: targetUuid,
     }, groupUuid);

package/expo-config-plugin/static/AudioUploader.swift

@@ -0,0 +1,230 @@
+//
+//  AudioUploader.swift
+//  Broadcast Extension
+//
+
+import AudioToolbox
+import CoreMedia
+import Foundation
+import OSLog
+
+private enum AudioConstants {
+    static let bufferMaxLength = 10240
+    static let magic: UInt32 = 0x5353_4155 // "SSAU"
+    static let headerSize = 24
+}
+
+class AudioUploader {
+
+    @Atomic private var isReady = false
+    private var connection: SocketConnection
+
+    private var dataToSend: Data?
+    private var byteIndex = 0
+
+    private let serialQueue: DispatchQueue
+
+    init(connection: SocketConnection) {
+        self.connection = connection
+        self.serialQueue = DispatchQueue(label: "org.getstream.audioUploader")
+
+        setupConnection()
+    }
+
+    @discardableResult func send(sample buffer: CMSampleBuffer) -> Bool {
+        // Drop the incoming buffer while one is still in flight. Audio buffers
+        // are tiny (a few KB) so this is rare; staying current beats queuing.
+        guard isReady else { return false }
+        guard let data = AudioUploader.serialize(sample: buffer) else { return false }
+
+        isReady = false
+        serialQueue.async { [weak self] in
+            self?.dataToSend = data
+            self?.byteIndex = 0
+            self?.sendDataChunk()
+        }
+
+        return true
+    }
+}
+
+private extension AudioUploader {
+
+    func setupConnection() {
+        connection.didOpen = { [weak self] in
+            self?.isReady = true
+        }
+        connection.streamHasSpaceAvailable = { [weak self] in
+            self?.serialQueue.async {
+                if let success = self?.sendDataChunk() {
+                    self?.isReady = !success
+                }
+            }
+        }
+    }
+
+    @discardableResult func sendDataChunk() -> Bool {
+        guard let dataToSend = dataToSend else {
+            return false
+        }
+
+        var bytesLeft = dataToSend.count - byteIndex
+        var length = bytesLeft > AudioConstants.bufferMaxLength ? AudioConstants.bufferMaxLength : bytesLeft
+
+        length = dataToSend[byteIndex..<(byteIndex + length)].withUnsafeBytes {
+            guard let ptr = $0.bindMemory(to: UInt8.self).baseAddress else {
+                return 0
+            }
+            return connection.writeToStream(buffer: ptr, maxLength: length)
+        }
+
+        if length > 0 {
+            byteIndex += length
+            bytesLeft -= length
+
+            if bytesLeft == 0 {
+                self.dataToSend = nil
+                byteIndex = 0
+            }
+        } else {
+            os_log(.error, log: broadcastLogger, "audio writeBufferToStream failure")
+        }
+
+        return true
+    }
+
+    /// Extracts interleaved PCM + format from the sample buffer and frames it.
+    static func serialize(sample buffer: CMSampleBuffer) -> Data? {
+        guard let formatDescription = CMSampleBufferGetFormatDescription(buffer) else {
+            return nil
+        }
+        guard let asbdPtr = CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription) else {
+            return nil
+        }
+        let asbd = asbdPtr.pointee
+
+        let flags = asbd.mFormatFlags
+        let isFloat = (flags & kAudioFormatFlagIsFloat) != 0
+        let isSignedInt = (flags & kAudioFormatFlagIsSignedInteger) != 0
+        let isNonInterleaved = (flags & kAudioFormatFlagIsNonInterleaved) != 0
+        let isBigEndian = (flags & kAudioFormatFlagIsBigEndian) != 0
+        let bits = Int(asbd.mBitsPerChannel)
+        let channels = Int(asbd.mChannelsPerFrame)
+
+        guard asbd.mFormatID == kAudioFormatLinearPCM else {
+            return nil
+        }
+
+        // Only the two formats the app-side reconstruction understands.
+        let supported = (isFloat && bits == 32) || (isSignedInt && bits == 16)
+        guard supported, channels > 0 else {
+            return nil
+        }
+
+        guard var pcm = interleavedPCM(from: buffer, channels: channels, bitsPerChannel: bits, isNonInterleaved: isNonInterleaved) else {
+            return nil
+        }
+
+        if isBigEndian, bits > 8 {
+            pcm = byteSwapped(pcm, bytesPerSample: bits / 8)
+        }
+
+        // Build a length-prefixed binary frame (24-byte LE header + PCM body).
+        // We always emit interleaved PCM, so isInterleaved is 1.
+        var frame = Data(capacity: AudioConstants.headerSize + pcm.count)
+        appendLE(&frame, AudioConstants.magic)                       // 0:  magic
+        appendLE(&frame, asbd.mSampleRate.bitPattern)               // 4:  sampleRate (Float64 bits)
+        appendLE(&frame, UInt16(channels))                          // 12: channels
+        appendLE(&frame, UInt16(bits))                              // 14: bits
+        frame.append(isFloat ? 1 : 0)                              // 16: isFloat
+        frame.append(1)                                            // 17: isInterleaved
+        frame.append(0)                                            // 18: reserved
+        frame.append(0)                                            // 19: reserved
+        appendLE(&frame, UInt32(pcm.count))                        // 20: payloadLength
+        frame.append(pcm)                                          // 24: PCM body
+        return frame
+    }
+
+    /// Swaps byte order of each PCM sample (for 16- or 32-bit samples).
+    static func byteSwapped(_ data: Data, bytesPerSample: Int) -> Data {
+        guard bytesPerSample == 2 || bytesPerSample == 4 else { return data }
+        var out = data
+        out.withUnsafeMutableBytes { raw in
+            guard let base = raw.baseAddress else { return }
+            let count = raw.count
+            if bytesPerSample == 2 {
+                let p = base.assumingMemoryBound(to: UInt16.self)
+                for i in 0..<(count / 2) { p[i] = p[i].byteSwapped }
+            } else {
+                let p = base.assumingMemoryBound(to: UInt32.self)
+                for i in 0..<(count / 4) { p[i] = p[i].byteSwapped }
+            }
+        }
+        return out
+    }
+
+    // MARK: - Little-endian encoders
+
+    static func appendLE<T: FixedWidthInteger>(_ data: inout Data, _ value: T) {
+        var v = value.littleEndian
+        withUnsafeBytes(of: &v) { data.append(contentsOf: $0) }
+    }
+
+    static func interleavedPCM(from buffer: CMSampleBuffer, channels: Int, bitsPerChannel: Int, isNonInterleaved: Bool) -> Data? {
+        if !isNonInterleaved {
+            // Interleaved: the sample buffer's data buffer is already contiguous.
+            guard let blockBuffer = CMSampleBufferGetDataBuffer(buffer) else {
+                return nil
+            }
+            var length = 0
+            var dataPointer: UnsafeMutablePointer<Int8>?
+            let st = CMBlockBufferGetDataPointer(blockBuffer, atOffset: 0, lengthAtOffsetOut: nil, totalLengthOut: &length, dataPointerOut: &dataPointer)
+            guard st == kCMBlockBufferNoErr, let dataPointer = dataPointer, length > 0 else {
+                return nil
+            }
+            return Data(bytes: dataPointer, count: length)
+        }
+
+        // Non-interleaved (planar): use an AudioBufferList to reach each plane.
+        var blockBuffer: CMBlockBuffer?
+        let maxBuffers = max(channels, 1)
+        let buffers = AudioBufferList.allocate(maximumBuffers: maxBuffers)
+        defer { free(buffers.unsafeMutablePointer) }
+
+        let status = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
+            buffer,
+            bufferListSizeNeededOut: nil,
+            bufferListOut: buffers.unsafeMutablePointer,
+            bufferListSize: AudioBufferList.sizeInBytes(maximumBuffers: maxBuffers),
+            blockBufferAllocator: nil,
+            blockBufferMemoryAllocator: nil,
+            flags: kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment,
+            blockBufferOut: &blockBuffer
+        )
+        guard status == noErr else {
+            return nil
+        }
+
+        let bytesPerSample = bitsPerChannel / 8
+        guard bytesPerSample > 0, buffers.count == channels else {
+            return nil
+        }
+
+        let minPlaneBytes = buffers.reduce(Int.max) { min($0, Int($1.mDataByteSize)) }
+        let frameCount = minPlaneBytes / bytesPerSample
+        guard frameCount > 0 else { return nil }
+        var output = Data(count: frameCount * channels * bytesPerSample)
+        output.withUnsafeMutableBytes { dstRaw in
+            guard let dst = dstRaw.baseAddress else { return }
+            for ch in 0..<channels {
+                guard let src = buffers[ch].mData else { continue }
+                for frame in 0..<frameCount {
+                    let srcOffset = frame * bytesPerSample
+                    let dstOffset = (frame * channels + ch) * bytesPerSample
+                    memcpy(dst + dstOffset, src + srcOffset, bytesPerSample)
+                }
+            }
+        }
+        return output
+    }
+}

package/expo-config-plugin/static/SampleHandler.swift

@@ -2,6 +2,7 @@
 //  SampleHandler.swift
 //  Broadcast Extension
 //
+
 import ReplayKit
 import OSLog
 
@@ -9,26 +10,47 @@ let broadcastLogger = OSLog(subsystem: "io.getstream.reactnative", category: "Br
 private enum Constants {
     // the App Group ID value that the app and the broadcast extension targets are setup with. It differs for each app.
     static let appGroupIdentifier = "group.com.example.broadcast.appgroup"
+    static let videoSocketName = "rtc_SSFD"
+    static let audioSocketName = "rtc_SSFD_audio"
+    static let audioConnectMaxAttempts = 300
 }
 class SampleHandler: RPBroadcastSampleHandler {
 
-    private var clientConnection: SocketConnection?
-    private var uploader: SampleUploader?
+    private var videoClientConnection: SocketConnection?
+    private var videoUploader: SampleUploader?
+
+    private var audioClientConnection: SocketConnection?
+    private var audioUploader: AudioUploader?
 
     private var frameCount: Int = 0
 
+    private func socketFilePath(for name: String) -> String {
+        let sharedContainer = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: Constants.appGroupIdentifier)
+        return sharedContainer?.appendingPathComponent(name).path ?? ""
+    }
+
     var socketFilePath: String {
-      let sharedContainer = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: Constants.appGroupIdentifier)
-        return sharedContainer?.appendingPathComponent("rtc_SSFD").path ?? ""
+        socketFilePath(for: Constants.videoSocketName)
+    }
+
+    var audioSocketFilePath: String {
+        socketFilePath(for: Constants.audioSocketName)
     }
 
     override init() {
       super.init()
         if let connection = SocketConnection(filePath: socketFilePath) {
-          clientConnection = connection
-          setupConnection()
+          videoClientConnection = connection
+          setupVideoConnection()
 
-          uploader = SampleUploader(connection: connection)
+          videoUploader = SampleUploader(connection: connection)
+        }
+
+        if let connection = SocketConnection(filePath: audioSocketFilePath) {
+          audioClientConnection = connection
+          setupAudioConnection()
+
+          audioUploader = AudioUploader(connection: connection)
         }
         os_log(.debug, log: broadcastLogger, "%{public}s", socketFilePath)
     }
@@ -38,7 +60,8 @@ class SampleHandler: RPBroadcastSampleHandler {
         frameCount = 0
 
         DarwinNotificationCenter.shared.postNotification(.broadcastStarted)
-        openConnection()
+        openVideoConnection()
+        openAudioConnection()
     }
 
     override func broadcastPaused() {
@@ -52,14 +75,18 @@ class SampleHandler: RPBroadcastSampleHandler {
     override func broadcastFinished() {
         // User has requested to finish the broadcast.
         DarwinNotificationCenter.shared.postNotification(.broadcastStopped)
-        clientConnection?.close()
+        videoClientConnection?.close()
+        audioClientConnection?.close()
     }
 
     override func processSampleBuffer(_ sampleBuffer: CMSampleBuffer, with sampleBufferType: RPSampleBufferType) {
         switch sampleBufferType {
         case RPSampleBufferType.video:
-            uploader?.send(sample: sampleBuffer)
+            videoUploader?.send(sample: sampleBuffer)
+        case RPSampleBufferType.audioApp:
+            audioUploader?.send(sample: sampleBuffer)
         default:
+            // .audioMic is handled by the app's audio device module; ignore it here.
             break
         }
     }
@@ -67,8 +94,8 @@ class SampleHandler: RPBroadcastSampleHandler {
 
 private extension SampleHandler {
 
-    func setupConnection() {
-        clientConnection?.didClose = { [weak self] error in
+    func setupVideoConnection() {
+        videoClientConnection?.didClose = { [weak self] error in
             os_log(.debug, log: broadcastLogger, "client connection did close \(String(describing: error))")
 
             if let error = error {
@@ -82,12 +109,19 @@ private extension SampleHandler {
         }
     }
 
-    func openConnection() {
+    func setupAudioConnection() {
+        // closed audio socket must not tear down the whole broadcast.
+        audioClientConnection?.didClose = { error in
+            os_log(.debug, log: broadcastLogger, "audio connection did close \(String(describing: error))")
+        }
+    }
+
+    func openVideoConnection() {
         let queue = DispatchQueue(label: "broadcast.connectTimer")
         let timer = DispatchSource.makeTimerSource(queue: queue)
         timer.schedule(deadline: .now(), repeating: .milliseconds(100), leeway: .milliseconds(500))
         timer.setEventHandler { [weak self] in
-            guard self?.clientConnection?.open() == true else {
+            guard self?.videoClientConnection?.open() == true else {
                 return
             }
 
@@ -96,4 +130,23 @@ private extension SampleHandler {
 
         timer.resume()
     }
+
+    func openAudioConnection() {
+        let queue = DispatchQueue(label: "broadcast.audioConnectTimer")
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now(), repeating: .milliseconds(100), leeway: .milliseconds(500))
+        var attempts = 0
+        timer.setEventHandler { [weak self] in
+            attempts += 1
+            if self?.audioClientConnection?.open() == true {
+                timer.cancel()
+                return
+            }
+            if attempts >= Constants.audioConnectMaxAttempts {
+                timer.cancel()
+            }
+        }
+
+        timer.resume()
+    }
 }

package/ios/StreamInCallManager.swift

@@ -152,7 +152,7 @@ class StreamInCallManager: RCTEventEmitter {
             // only exists under .playAndRecord.
             category = .playback
             mode = .spokenAudio
-            options = []
+            options = [.mixWithOthers]
         } else {
             // XCode 16 and older don't expose .allowBluetoothHFP
             // https://forums.swift.org/t/xcode-26-avaudiosession-categoryoptions-allowbluetooth-deprecated/80956
@@ -170,7 +170,7 @@ class StreamInCallManager: RCTEventEmitter {
                 // then we always can't use defaultToSpeaker
                 mustSetDefaultToSpeaker = false
             }
-            options = mustSetDefaultToSpeaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
+            options = mustSetDefaultToSpeaker ? [bluetoothOption, .defaultToSpeaker, .mixWithOthers] : [bluetoothOption, .mixWithOthers]
         }
 
         let rtcConfig = RTCAudioSessionConfiguration.webRTC()