@stream-io/video-react-native-sdk 1.30.4 → 1.31.0

package/dist/typescript/hooks/useScreenShareButton.d.ts

@@ -1,8 +1,41 @@
 import React from 'react';
+/**
+ * The type of screen sharing to use on iOS.
+ *
+ * - `'broadcast'` — Uses a Broadcast Upload Extension (RPSystemBroadcastPickerView).
+ *   Captures the entire device screen, works across all apps. Requires an extension target.
+ * - `'inApp'` — Uses RPScreenRecorder.startCapture to capture the current app's screen.
+ *   Only captures the current app. Supports `.audioApp` sample buffers for audio mixing.
+ *
+ * On Android, this option is ignored — the system screen capture dialog is always used.
+ */
+export type ScreenShareType = 'broadcast' | 'inApp';
+/**
+ * Options for screen share behavior.
+ */
+export type ScreenShareOptions = {
+    /**
+     * The type of screen sharing on iOS. Default: `'broadcast'`.
+     * On Android this is ignored.
+     */
+    type?: ScreenShareType;
+    /**
+     * Whether to capture and mix system/app audio into the microphone audio track.
+     * When `true`, remote participants will hear media audio from the shared screen
+     * (e.g., YouTube video audio) mixed with the user's microphone.
+     *
+     * - iOS in-app: Audio captured from RPScreenRecorder `.audioApp` buffers.
+     * - iOS broadcast: Audio mixing is **not** currently supported.
+     * - Android: Audio captured via AudioPlaybackCaptureConfiguration (API 29+).
+     *
+     * Default: `false`.
+     */
+    includeAudio?: boolean;
+};
 export declare const useScreenShareButton: (
 /**
  * Ref of the ScreenCapturePickerView component.
- *
+ * Required for iOS broadcast screen sharing. Can be `null` for in-app mode.
  */
 screenCapturePickerViewiOSRef: React.MutableRefObject<any>, 
 /**
@@ -19,7 +52,11 @@ onScreenShareStoppedHandler?: () => void,
  * Handler to be called when the permissions to stream screen share media is missing
  *
  */
-onMissingScreenShareStreamPermission?: () => void) => {
+onMissingScreenShareStreamPermission?: () => void, 
+/**
+ * Options for screen share behavior (type, includeAudio).
+ */
+screenShareOptions?: ScreenShareOptions) => {
     onPress: undefined;
     hasPublishedScreenShare: boolean;
 } | {

package/dist/typescript/hooks/useScreenShareButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScreenShareButton.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenShareButton.ts"],"names":[],"mappings":"AAMA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAWjD,eAAO,MAAM,oBAAoB;AAC/B;;;GAGG;AACH,+BAA+B,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC;AAC1D;;;GAGG;AACH,8BAA8B,MAAM,IAAI;AACxC;;;GAGG;AACH,8BAA8B,MAAM,IAAI;AACxC;;;GAGG;AACH,uCAAuC,MAAM,IAAI;;;;;;CAuFlD,CAAC"}
+{"version":3,"file":"useScreenShareButton.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenShareButton.ts"],"names":[],"mappings":"AAMA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAMjD;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,OAAO,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAQF,eAAO,MAAM,oBAAoB;AAC/B;;;GAGG;AACH,+BAA+B,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC;AAC1D;;;GAGG;AACH,8BAA8B,MAAM,IAAI;AACxC;;;GAGG;AACH,8BAA8B,MAAM,IAAI;AACxC;;;GAGG;AACH,uCAAuC,MAAM,IAAI;AACjD;;GAEG;AACH,qBAAqB,kBAAkB;;;;;;CAoIxC,CAAC"}

package/dist/typescript/modules/ScreenShareAudioManager.d.ts

@@ -0,0 +1,28 @@
+export declare class ScreenShareAudioManager {
+    /**
+     * Starts mixing screen share audio into the microphone audio track.
+     * On iOS, this enables audio buffer processing on the prepared mixer.
+     * On Android, this registers an audio processor that captures system media
+     * audio via AudioPlaybackCaptureConfiguration and mixes it into the mic buffer.
+     */
+    startScreenShareAudioMixing(): Promise<void>;
+    /**
+     * Stops mixing screen share audio into the microphone audio track
+     * and restores the original audio pipeline.
+     */
+    stopScreenShareAudioMixing(): Promise<void>;
+    /**
+     * Starts in-app screen capture using RPScreenRecorder (iOS only).
+     * Unlike broadcast screen sharing, in-app capture runs in the main app process
+     * and can directly provide `.audioApp` sample buffers for mixing.
+     *
+     * @param includeAudio Whether to capture and mix app audio.
+     */
+    startInAppScreenCapture(includeAudio: boolean): Promise<void>;
+    /**
+     * Stops in-app screen capture (iOS only).
+     */
+    stopInAppScreenCapture(): Promise<void>;
+}
+export declare const screenShareAudioMixingManager: ScreenShareAudioManager;
+//# sourceMappingURL=ScreenShareAudioManager.d.ts.map

package/dist/typescript/modules/ScreenShareAudioManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenShareAudioManager.d.ts","sourceRoot":"","sources":["../../../src/modules/ScreenShareAudioManager.ts"],"names":[],"mappings":"AAIA,qBAAa,uBAAuB;IAClC;;;;;OAKG;IACG,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlD;;;OAGG;IACG,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjD;;;;;;OAMG;IACG,uBAAuB,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAOnE;;OAEG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;CAM9C;AAED,eAAO,MAAM,6BAA6B,yBAAgC,CAAC"}

package/dist/typescript/providers/StreamCall/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/providers/StreamCall/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAa,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAY/C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AACF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,qBAGxB,iBAAiB,CAAC,eAAe,CAAC,sBAWpC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/providers/StreamCall/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAa,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAa/C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AACF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,qBAGxB,iBAAiB,CAAC,eAAe,CAAC,sBAYpC,CAAC"}

package/dist/typescript/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.30.4";
+export declare const version = "1.31.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/StreamVideoReactNative.m

@@ -7,9 +7,17 @@
 #import "StreamVideoReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
+#import "InAppScreenCapturer.h"
 #import <AVFoundation/AVFoundation.h>
 #import <AudioToolbox/AudioToolbox.h>
 
+// Import Swift-generated header for ScreenShareAudioMixer
+#if __has_include(<stream_react_native_webrtc/stream_react_native_webrtc-Swift.h>)
+#import <stream_react_native_webrtc/stream_react_native_webrtc-Swift.h>
+#elif __has_include("stream_react_native_webrtc-Swift.h")
+#import "stream_react_native_webrtc-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";
@@ -626,22 +634,22 @@ RCT_EXPORT_METHOD(stopBusyTone:(RCTPromiseResolveBlock)resolve rejecter:(RCTProm
 
 - (void)audioSessionInterrupted:(NSNotification *)notification {
     AVAudioSessionInterruptionType interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
-    
+
     switch (interruptionType) {
         case AVAudioSessionInterruptionTypeBegan:
             if (_busyTonePlayer && _busyTonePlayer.isPlaying) {
                 [_busyTonePlayer pause];
             }
             break;
-            
+
         case AVAudioSessionInterruptionTypeEnded: {
             AVAudioSessionInterruptionOptions options = [notification.userInfo[AVAudioSessionInterruptionOptionKey] unsignedIntegerValue];
-            
+
             if (options & AVAudioSessionInterruptionOptionShouldResume) {
                 // Reactivate audio session
                 NSError *error = nil;
                 [[AVAudioSession sharedInstance] setActive:YES error:&error];
-                
+
                 if (!error && _busyTonePlayer) {
                     [_busyTonePlayer play];
                 } else if (error) {
@@ -653,4 +661,85 @@ RCT_EXPORT_METHOD(stopBusyTone:(RCTPromiseResolveBlock)resolve rejecter:(RCTProm
     }
 }
 
+#pragma mark - In-App Screen Capture
+
+RCT_EXPORT_METHOD(startInAppScreenCapture:(BOOL)includeAudio
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
+    options.useInAppScreenCapture = YES;
+    options.includeScreenShareAudio = includeAudio;
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(stopInAppScreenCapture:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
+    options.useInAppScreenCapture = NO;
+    options.includeScreenShareAudio = NO;
+    resolve(nil);
+}
+
+#pragma mark - Screen Share Audio Mixing
+
+RCT_EXPORT_METHOD(startScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
+    WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
+
+    ScreenShareAudioMixer *mixer = webrtcModule.audioDeviceModule.screenShareAudioMixer;
+
+    // Wire mixer as capturePostProcessingDelegate on the audio processing module.
+    id<RTCAudioProcessingModule> apmId = options.audioProcessingModule;
+    if (apmId && [apmId isKindOfClass:[RTCDefaultAudioProcessingModule class]]) {
+        RTCDefaultAudioProcessingModule *apm = (RTCDefaultAudioProcessingModule *)apmId;
+        apm.capturePostProcessingDelegate = mixer;
+        NSLog(@"[SSAMixer] Set capturePostProcessingDelegate on APM");
+    } else {
+        NSLog(@"[SSAMixer] WARNING: No RTCDefaultAudioProcessingModule available, mixing will not work");
+    }
+
+    [mixer startMixing];
+
+    // Wire audio buffer handler on the active capturer → mixer.enqueue
+    InAppScreenCapturer *capturer = options.activeInAppScreenCapturer;
+    if (capturer) {
+        capturer.audioBufferHandler = ^(CMSampleBufferRef sampleBuffer) {
+            [mixer enqueue:sampleBuffer];
+        };
+    }
+
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
+    WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
+
+    // Stop feeding audio to the mixer
+    InAppScreenCapturer *capturer = options.activeInAppScreenCapturer;
+    if (capturer) {
+        capturer.audioBufferHandler = nil;
+    }
+
+    // Stop mixing
+    ScreenShareAudioMixer *mixer = webrtcModule.audioDeviceModule.screenShareAudioMixer;
+    [mixer stopMixing];
+
+    // Clear capturePostProcessingDelegate
+    id<RTCAudioProcessingModule> apmId = options.audioProcessingModule;
+    if (apmId && [apmId isKindOfClass:[RTCDefaultAudioProcessingModule class]]) {
+        RTCDefaultAudioProcessingModule *apm = (RTCDefaultAudioProcessingModule *)apmId;
+        apm.capturePostProcessingDelegate = nil;
+        NSLog(@"[SSAMixer] Cleared capturePostProcessingDelegate on APM");
+    }
+
+    resolve(nil);
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.30.4",
+  "version": "1.31.0",
   "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.44.4",
-    "@stream-io/video-react-bindings": "1.13.13",
+    "@stream-io/video-client": "1.44.5",
+    "@stream-io/video-react-bindings": "1.13.14",
     "intl-pluralrules": "2.0.1",
     "react-native-url-polyfill": "^3.0.0",
     "rxjs": "~7.8.2",
@@ -64,7 +64,7 @@
     "@react-native-firebase/app": ">=17.5.0",
     "@react-native-firebase/messaging": ">=17.5.0",
     "@stream-io/noise-cancellation-react-native": ">=0.1.0",
-    "@stream-io/react-native-webrtc": ">=137.1.0",
+    "@stream-io/react-native-webrtc": ">=137.1.3",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
     "expo-build-properties": "*",
@@ -129,9 +129,9 @@
     "@react-native-firebase/app": "^23.4.0",
     "@react-native-firebase/messaging": "^23.4.0",
     "@react-native/babel-preset": "^0.81.5",
-    "@stream-io/noise-cancellation-react-native": "^0.5.1",
-    "@stream-io/react-native-webrtc": "137.1.0",
-    "@stream-io/video-filters-react-native": "^0.10.1",
+    "@stream-io/noise-cancellation-react-native": "^0.6.0",
+    "@stream-io/react-native-webrtc": "137.1.3",
+    "@stream-io/video-filters-react-native": "^0.11.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.4",

package/src/components/Call/CallControls/ScreenShareToggleButton.tsx

@@ -5,7 +5,10 @@ import { ScreenShare } from '../../../icons/ScreenShare';
 import { StopScreenShare } from '../../../icons/StopScreenShare';
 import { CallControlsButton } from './CallControlsButton';
 import { useTheme } from '../../../contexts/ThemeContext';
-import { useScreenShareButton } from '../../../hooks/useScreenShareButton';
+import {
+  useScreenShareButton,
+  type ScreenShareOptions,
+} from '../../../hooks/useScreenShareButton';
 import { IconWrapper } from '../../../icons';
 
 /**
@@ -22,6 +25,10 @@ export type ScreenShareToggleButtonProps = {
    *
    */
   onScreenShareStoppedHandler?: () => void;
+  /**
+   * Options for screen share behavior (type, includeAudio).
+   */
+  screenShareOptions?: ScreenShareOptions;
 };
 
 /**
@@ -31,6 +38,7 @@ export type ScreenShareToggleButtonProps = {
 export const ScreenShareToggleButton = ({
   onScreenShareStartedHandler,
   onScreenShareStoppedHandler,
+  screenShareOptions,
 }: ScreenShareToggleButtonProps) => {
   const {
     theme: { colors, screenShareToggleButton, variants },
@@ -42,6 +50,8 @@ export const ScreenShareToggleButton = ({
     screenCapturePickerViewiOSRef,
     onScreenShareStartedHandler,
     onScreenShareStoppedHandler,
+    undefined,
+    screenShareOptions,
   );
 
   if (!onPress) return null;

package/src/hooks/index.ts

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

package/src/hooks/useScreenShareAudioMixing.ts

@@ -0,0 +1,130 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { hasScreenShare, videoLoggerSystem } from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+import { screenShareAudioMixingManager } from '../modules/ScreenShareAudioManager';
+import { NoiseCancellationWrapper } from '../providers/NoiseCancellation/lib';
+
+const logger = videoLoggerSystem.getLogger('useScreenShareAudioMixing');
+
+/**
+ * Tries to disable noise cancellation so screen audio passes through
+ * unfiltered. Returns true if NC was disabled (and should be re-enabled later).
+ */
+async function disableNoiseCancellation(): Promise<boolean> {
+  try {
+    const nc = NoiseCancellationWrapper.getInstance();
+    const wasEnabled = await nc.isEnabled();
+    if (wasEnabled) {
+      await nc.disable();
+      logger.info('Noise cancellation disabled for screen share audio');
+    }
+    return wasEnabled;
+  } catch {
+    // NC module not installed or not configured — nothing to do
+    return false;
+  }
+}
+
+/**
+ * Re-enables noise cancellation if it was previously disabled.
+ */
+async function restoreNoiseCancellation() {
+  try {
+    const nc = NoiseCancellationWrapper.getInstance();
+    await nc.enable();
+    logger.info('Noise cancellation re-enabled after screen share audio');
+  } catch {
+    // NC module not installed — nothing to do
+  }
+}
+
+/**
+ * Hook that manages the lifecycle of screen share audio mixing.
+ *
+ * When screen share is active and audio mixing is enabled
+ * (via `call.screenShare.enableScreenShareAudio()`), this hook
+ * calls the native module to mix captured screen/app audio
+ * into the microphone audio track.
+ *
+ * Noise cancellation is temporarily disabled while screen audio mixing
+ * is active so that all captured sounds (music, game audio, etc.)
+ * pass through without being filtered.
+ */
+export const useScreenShareAudioMixing = () => {
+  const call = useCall();
+  const { useLocalParticipant } = useCallStateHooks();
+  const localParticipant = useLocalParticipant();
+  const isScreenSharing =
+    localParticipant != null && hasScreenShare(localParticipant);
+
+  const [audioEnabled, setAudioEnabled] = useState(
+    () => call?.screenShare.state.audioEnabled ?? false,
+  );
+
+  const isMixingActiveRef = useRef(false);
+  const ncWasEnabledRef = useRef(false);
+
+  useEffect(() => {
+    if (!call) return;
+    const sub = call.screenShare.state.audioEnabled$.subscribe(setAudioEnabled);
+    return () => sub.unsubscribe();
+  }, [call]);
+
+  const startMixing = useCallback(async () => {
+    if (isMixingActiveRef.current) return;
+    try {
+      // Disable NC before starting mixing so screen audio is not filtered
+      ncWasEnabledRef.current = await disableNoiseCancellation();
+
+      logger.info('Starting screen share audio mixing');
+      await screenShareAudioMixingManager.startScreenShareAudioMixing();
+      isMixingActiveRef.current = true;
+    } catch (error) {
+      logger.warn('Failed to start screen share audio mixing', error);
+      if (ncWasEnabledRef.current) {
+        restoreNoiseCancellation().catch(() => {});
+        ncWasEnabledRef.current = false;
+      }
+    }
+  }, []);
+
+  const stopMixing = useCallback(async () => {
+    if (!isMixingActiveRef.current) return;
+    try {
+      logger.info('Stopping screen share audio mixing');
+      await screenShareAudioMixingManager.stopScreenShareAudioMixing();
+      isMixingActiveRef.current = false;
+
+      if (ncWasEnabledRef.current) {
+        await restoreNoiseCancellation();
+        ncWasEnabledRef.current = false;
+      }
+    } catch (error) {
+      logger.warn('Failed to stop screen share audio mixing', error);
+    }
+  }, []);
+
+  // Start/stop audio mixing based on screen share status and audio preference
+  useEffect(() => {
+    if (isScreenSharing && audioEnabled) {
+      startMixing();
+    } else {
+      stopMixing();
+    }
+  }, [isScreenSharing, audioEnabled, startMixing, stopMixing]);
+
+  useEffect(() => {
+    return () => {
+      if (isMixingActiveRef.current) {
+        screenShareAudioMixingManager
+          .stopScreenShareAudioMixing()
+          .catch(() => {});
+        isMixingActiveRef.current = false;
+        if (ncWasEnabledRef.current) {
+          restoreNoiseCancellation().catch(() => {});
+          ncWasEnabledRef.current = false;
+        }
+      }
+    };
+  }, []);
+};

package/src/hooks/useScreenShareButton.ts

@@ -8,6 +8,42 @@ import React, { useEffect, useRef } from 'react';
 import { findNodeHandle, NativeModules, Platform } from 'react-native';
 import { usePrevious } from '../utils/hooks';
 import { useIsIosScreenshareBroadcastStarted } from './useIsIosScreenshareBroadcastStarted';
+import { screenShareAudioMixingManager } from '../modules/ScreenShareAudioManager';
+
+/**
+ * The type of screen sharing to use on iOS.
+ *
+ * - `'broadcast'` — Uses a Broadcast Upload Extension (RPSystemBroadcastPickerView).
+ *   Captures the entire device screen, works across all apps. Requires an extension target.
+ * - `'inApp'` — Uses RPScreenRecorder.startCapture to capture the current app's screen.
+ *   Only captures the current app. Supports `.audioApp` sample buffers for audio mixing.
+ *
+ * On Android, this option is ignored — the system screen capture dialog is always used.
+ */
+export type ScreenShareType = 'broadcast' | 'inApp';
+
+/**
+ * Options for screen share behavior.
+ */
+export type ScreenShareOptions = {
+  /**
+   * The type of screen sharing on iOS. Default: `'broadcast'`.
+   * On Android this is ignored.
+   */
+  type?: ScreenShareType;
+  /**
+   * Whether to capture and mix system/app audio into the microphone audio track.
+   * When `true`, remote participants will hear media audio from the shared screen
+   * (e.g., YouTube video audio) mixed with the user's microphone.
+   *
+   * - iOS in-app: Audio captured from RPScreenRecorder `.audioApp` buffers.
+   * - iOS broadcast: Audio mixing is **not** currently supported.
+   * - Android: Audio captured via AudioPlaybackCaptureConfiguration (API 29+).
+   *
+   * Default: `false`.
+   */
+  includeAudio?: boolean;
+};
 
 // ios >= 14.0 or android - platform restrictions
 const CanDeviceScreenShare =
@@ -18,7 +54,7 @@ const CanDeviceScreenShare =
 export const useScreenShareButton = (
   /**
    * Ref of the ScreenCapturePickerView component.
-   *
+   * Required for iOS broadcast screen sharing. Can be `null` for in-app mode.
    */
   screenCapturePickerViewiOSRef: React.MutableRefObject<any>,
   /**
@@ -36,6 +72,10 @@ export const useScreenShareButton = (
    *
    */
   onMissingScreenShareStreamPermission?: () => void,
+  /**
+   * Options for screen share behavior (type, includeAudio).
+   */
+  screenShareOptions?: ScreenShareOptions,
 ) => {
   const call = useCall();
   const { useLocalParticipant, useCallSettings, useOwnCapabilities } =
@@ -47,6 +87,9 @@ export const useScreenShareButton = (
   );
   const isScreenSharingEnabledInCall = callSettings?.screensharing.enabled;
 
+  const screenShareType = screenShareOptions?.type ?? 'broadcast';
+  const includeAudio = screenShareOptions?.includeAudio ?? false;
+
   const onScreenShareStartedHandlerRef = useRef(onScreenShareStartedHandler);
   onScreenShareStartedHandlerRef.current = onScreenShareStartedHandler;
   const onScreenShareStoppedHandlerRef = useRef(onScreenShareStoppedHandler);
@@ -62,15 +105,22 @@ export const useScreenShareButton = (
     localParticipant && hasScreenShare(localParticipant);
 
   // listens to iOS screen share broadcast started event from the system
+  // (only relevant for broadcast mode)
   useEffect(() => {
     if (Platform.OS !== 'ios') {
       return;
     }
+    if (screenShareType !== 'broadcast') {
+      return;
+    }
     if (
       iosScreenShareStartedFromSystem &&
       !prevIosScreenShareStartedFromSystem
     ) {
       onScreenShareStartedHandlerRef.current?.();
+      if (includeAudio) {
+        call?.screenShare.enableScreenShareAudio();
+      }
       call?.screenShare.enable();
     } else if (
       !iosScreenShareStartedFromSystem &&
@@ -81,6 +131,8 @@ export const useScreenShareButton = (
     }
   }, [
     call,
+    includeAudio,
+    screenShareType,
     iosScreenShareStartedFromSystem,
     prevIosScreenShareStartedFromSystem,
   ]);
@@ -92,14 +144,43 @@ export const useScreenShareButton = (
         'User does not have permissions to stream the screen share media, calling onMissingScreenShareStreamPermission handler if present',
       );
       onMissingScreenShareStreamPermission?.();
+      return;
     }
+
     if (!hasPublishedScreenShare) {
-      if (Platform.OS === 'ios') {
+      // Set audio mixing preference before starting screen share
+      if (includeAudio) {
+        call?.screenShare.enableScreenShareAudio();
+      } else {
+        try {
+          await call?.screenShare.disableScreenShareAudio();
+        } catch (error) {
+          const logger = videoLoggerSystem.getLogger('useScreenShareButton');
+          logger.warn('Failed to disable screen share audio', error);
+        }
+      }
+
+      if (Platform.OS === 'ios' && screenShareType === 'inApp') {
+        // In-app screen sharing on iOS — uses RPScreenRecorder directly
+        try {
+          await screenShareAudioMixingManager.startInAppScreenCapture(
+            includeAudio,
+          );
+          await call?.screenShare.enable();
+          onScreenShareStartedHandler?.();
+        } catch (error) {
+          await screenShareAudioMixingManager.stopInAppScreenCapture();
+          const logger = videoLoggerSystem.getLogger('useScreenShareButton');
+          logger.warn('Failed to start in-app screen capture', error);
+        }
+      } else if (Platform.OS === 'ios') {
+        // Broadcast screen sharing on iOS — shows the system picker
         const reactTag = findNodeHandle(screenCapturePickerViewiOSRef.current);
         await NativeModules.ScreenCapturePickerViewManager.show(reactTag);
         // After this the iOS screen share broadcast started/stopped event will be triggered
         // and the useEffect listener will handle the rest
       } else {
+        // Android screen sharing
         try {
           await call?.screenShare.enable();
           onScreenShareStartedHandler?.();
@@ -114,6 +195,10 @@ export const useScreenShareButton = (
       }
     } else if (hasPublishedScreenShare) {
       onScreenShareStoppedHandler?.();
+      // Stop in-app screen capture if it was active (iOS only)
+      if (Platform.OS === 'ios' && screenShareType === 'inApp') {
+        await screenShareAudioMixingManager.stopInAppScreenCapture();
+      }
       await call?.screenShare.disable(true);
     }
   };

package/src/modules/ScreenShareAudioManager.ts

@@ -0,0 +1,49 @@
+import { NativeModules, Platform } from 'react-native';
+
+const StreamVideoReactNative = NativeModules.StreamVideoReactNative;
+
+export class ScreenShareAudioManager {
+  /**
+   * Starts mixing screen share audio into the microphone audio track.
+   * On iOS, this enables audio buffer processing on the prepared mixer.
+   * On Android, this registers an audio processor that captures system media
+   * audio via AudioPlaybackCaptureConfiguration and mixes it into the mic buffer.
+   */
+  async startScreenShareAudioMixing(): Promise<void> {
+    return StreamVideoReactNative?.startScreenShareAudioMixing();
+  }
+
+  /**
+   * Stops mixing screen share audio into the microphone audio track
+   * and restores the original audio pipeline.
+   */
+  async stopScreenShareAudioMixing(): Promise<void> {
+    return StreamVideoReactNative?.stopScreenShareAudioMixing();
+  }
+
+  /**
+   * Starts in-app screen capture using RPScreenRecorder (iOS only).
+   * Unlike broadcast screen sharing, in-app capture runs in the main app process
+   * and can directly provide `.audioApp` sample buffers for mixing.
+   *
+   * @param includeAudio Whether to capture and mix app audio.
+   */
+  async startInAppScreenCapture(includeAudio: boolean): Promise<void> {
+    if (Platform.OS !== 'ios') {
+      return;
+    }
+    return StreamVideoReactNative?.startInAppScreenCapture(includeAudio);
+  }
+
+  /**
+   * Stops in-app screen capture (iOS only).
+   */
+  async stopInAppScreenCapture(): Promise<void> {
+    if (Platform.OS !== 'ios') {
+      return;
+    }
+    return StreamVideoReactNative?.stopInAppScreenCapture();
+  }
+}
+
+export const screenShareAudioMixingManager = new ScreenShareAudioManager();