chore: merge with upstream

android/src/main/java/com/oney/WebRTCModule/GetUserMediaImpl.java

@@ -103,6 +103,15 @@ public void onServiceDisconnected(ComponentName name) {
             public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
                 super.onActivityResult(activity, requestCode, resultCode, data);
                 if (requestCode == PERMISSION_REQUEST_CODE) {
+                    // Guard against a duplicate onActivityResult dispatch. Some hosts (e.g.
+                    // react-native-navigation) forward the activity result to every registered
+                    // ActivityEventListener more than once, so this callback can fire twice for a
+                    // single getDisplayMedia() request. The first pass consumes displayMediaPromise;
+                    // a second pass would call reject()/resolve() on a null promise and crash.
+                    if (displayMediaPromise == null) {
+                        return;
+                    }
+
                     if (resultCode != Activity.RESULT_OK) {
                         displayMediaPromise.reject("DOMException", "NotAllowedError");
                         displayMediaPromise = null;
@@ -429,12 +438,19 @@ public void run() {
     }
 
     private void createScreenStream() {
+        // A duplicate dispatch (see onActivityResult above) can schedule this more than once: a
+        // repeated launch() rebinds the service, so onServiceConnected can fire twice. The
+        // single-threaded executor runs them in order, so by the time a duplicate runs the first has
+        // already consumed displayMediaPromise. Bail out instead of dereferencing a null promise or
+        // creating a second screen stream.
+        if (displayMediaPromise == null) {
+            return;
+        }
+
         final PeerConnectionFactoryProvider factoryProvider = displayMediaFactory;
         if (factoryProvider == null || factoryProvider.isDisposed()) {
-            if (displayMediaPromise != null) {
-                displayMediaPromise.reject("ERR_MODULE_DISPOSED", "WebRTCModule disposed during getDisplayMedia");
-                displayMediaPromise = null;
-            }
+            displayMediaPromise.reject("ERR_MODULE_DISPOSED", "WebRTCModule disposed during getDisplayMedia");
+            displayMediaPromise = null;
             displayMediaFactory = null;
             return;
         }

ios/RCTWebRTC/ScreenCapturePickerViewManager.m

@@ -1,6 +1,6 @@
 #if TARGET_OS_IOS
 
-#import <React/RCTUIManager.h>
+#import <React/RCTLog.h>
 #import <ReplayKit/ReplayKit.h>
 
 #import "ScreenCapturePickerViewManager.h"
@@ -30,29 +30,28 @@ - (NSString *)preferredExtension {
 }
 
 RCT_EXPORT_METHOD(show : (nonnull NSNumber *)reactTag) {
-    [self.bridge.uiManager
-        addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-            id view = viewRegistry[reactTag];
-            if (![view isKindOfClass:[RPSystemBroadcastPickerView class]]) {
-                RCTLogError(@"Invalid view returned from registry, expecting "
-                            @"RPSystemBroadcastPickerView, got: %@",
-                            view);
-            } else {
-                // Simulate a click
-                UIButton *btn = nil;
-
-                for (UIView *subview in ((RPSystemBroadcastPickerView *)view).subviews) {
-                    if ([subview isKindOfClass:[UIButton class]]) {
-                        btn = (UIButton *)subview;
-                    }
-                }
-                if (btn != nil) {
-                    [btn sendActionsForControlEvents:UIControlEventTouchUpInside];
-                } else {
-                    RCTLogError(@"RPSystemBroadcastPickerView button not found");
-                }
+    dispatch_async(dispatch_get_main_queue(), ^{
+        RPSystemBroadcastPickerView *picker = self->_broadcastPickerView;
+        if (![picker isKindOfClass:[RPSystemBroadcastPickerView class]]) {
+            RCTLogError(@"Invalid broadcast picker view, expecting "
+                        @"RPSystemBroadcastPickerView, got: %@",
+                        picker);
+            return;
+        }
+
+        UIButton *btn = nil;
+
+        for (UIView *subview in picker.subviews) {
+            if ([subview isKindOfClass:[UIButton class]]) {
+                btn = (UIButton *)subview;
             }
-        }];
+        }
+        if (btn != nil) {
+            [btn sendActionsForControlEvents:UIControlEventTouchUpInside];
+        } else {
+            RCTLogError(@"RPSystemBroadcastPickerView button not found");
+        }
+    });
 }
 
 @end

ios/RCTWebRTC/VideoCaptureController.m

@@ -52,9 +52,40 @@ - (void)startCapture {
         return;
     }
 
+    // Enable Center Stage when the device supports it; cooperative with Control Center.
+    if (@available(iOS 16.0, *)) {
+        BOOL centerStageSupported = NO;
+        for (AVCaptureDeviceFormat *fmt in [RTCCameraVideoCapturer supportedFormatsForDevice:self.device]) {
+            if (fmt.isCenterStageSupported) {
+                centerStageSupported = YES;
+                break;
+            }
+        }
+        if (centerStageSupported) {
+            AVCaptureDevice.centerStageControlMode = AVCaptureCenterStageControlModeCooperative;
+            AVCaptureDevice.centerStageEnabled = YES;
+        } else if (AVCaptureDevice.isCenterStageEnabled) {
+            AVCaptureDevice.centerStageEnabled = NO;
+        }
+    }
+
     AVCaptureDeviceFormat *format = [self selectFormatForDevice:self.device
                                                 withTargetWidth:self.width
                                                withTargetHeight:self.height];
+
+    // On multi cam devices selectFormatForDevice also requires format.multiCamSupported, and that set
+    // can be disjoint from the Center Stage one, leaving nothing to pick. Give up Center Stage rather
+    // than the capture: the control mode is cooperative above, so we are allowed to turn it off, and
+    // doing so lets AVFoundation accept a non-Center-Stage activeFormat.
+    if (@available(iOS 16.0, *)) {
+        if (!format && AVCaptureDevice.isCenterStageEnabled) {
+            RCTLogWarn(@"[VideoCaptureController] No Center Stage format for device %@, disabling Center Stage",
+                       self.device);
+            AVCaptureDevice.centerStageEnabled = NO;
+            format = [self selectFormatForDevice:self.device withTargetWidth:self.width withTargetHeight:self.height];
+        }
+    }
+
     if (!format) {
         RCTLogWarn(@"[VideoCaptureController] No valid formats for device %@", self.device);
 
@@ -63,6 +94,17 @@ - (void)startCapture {
 
     self.selectedFormat = format;
 
+    // Clamp fps to the range Center Stage allows for this format.
+    int fps = self.frameRate;
+    if (@available(iOS 16.0, *)) {
+        if (AVCaptureDevice.isCenterStageEnabled) {
+            AVFrameRateRange *csRange = format.videoFrameRateRangeForCenterStage;
+            if (csRange) {
+                fps = MAX((int)csRange.minFrameRate, MIN(fps, (int)csRange.maxFrameRate));
+            }
+        }
+    }
+
     AVCaptureSession *session = self.capturer.captureSession;
     if (@available(iOS 16.0, *)) {
         BOOL enable = self.enableMultitaskingCameraAccess;
@@ -84,7 +126,7 @@ - (void)startCapture {
     __weak VideoCaptureController *weakSelf = self;
     [self.capturer startCaptureWithDevice:self.device
                                    format:format
-                                      fps:self.frameRate
+                                      fps:fps
                         completionHandler:^(NSError *err) {
                             if (err) {
                                 RCTLogError(@"[VideoCaptureController] Error starting capture: %@", err);
@@ -296,6 +338,11 @@ - (AVCaptureDeviceFormat *)selectFormatForDevice:(AVCaptureDevice *)device
     AVCaptureDeviceFormat *selectedFormat = nil;
     int currentDiff = INT_MAX;
 
+    BOOL centerStageEnabled = NO;
+    if (@available(iOS 16.0, *)) {
+        centerStageEnabled = AVCaptureDevice.isCenterStageEnabled;
+    }
+
     for (AVCaptureDeviceFormat *format in formats) {
         // Only use multi cam formats when on multi cam supported devices.
         if (@available(iOS 13.0, macOS 14.0, tvOS 17.0, *)) {
@@ -304,6 +351,13 @@ - (AVCaptureDeviceFormat *)selectFormatForDevice:(AVCaptureDevice *)device
             }
         }
 
+        // Center Stage only permits supported formats.
+        if (@available(iOS 16.0, *)) {
+            if (centerStageEnabled && !format.isCenterStageSupported) {
+                continue;
+            }
+        }
+
         CMVideoDimensions dimension = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
         FourCharCode pixelFormat = CMFormatDescriptionGetMediaSubType(format.formatDescription);
         int diff = abs(targetWidth - dimension.width) + abs(targetHeight - dimension.height);

package.json

@@ -53,7 +53,7 @@
     "build": "bob build",
     "lint": "eslint --max-warnings 0 . && tsc --noEmit",
     "lintfix": "eslint --max-warnings 0 --fix . && tsc --noEmit",
-    "prepare": "husky install && bob build",
+    "prepare": "husky install && bob build && node tools/postbuild.mjs",
     "format": "tools/format.sh",
     "semantic-release": "semantic-release"
   },

src/MediaStreamTrack.ts

@@ -248,10 +248,19 @@ export default class MediaStreamTrack extends EventTarget<MediaStreamTrackEventM
             return;
         }
 
-        const normalized = normalizeConstraints({ video: constraints ?? true });
+        // Work on a copy: `constraints` belongs to the caller, who may have frozen it, and
+        // _constraints must not alias an object the caller can mutate after we return.
+        const effective: MediaTrackConstraints = { ...constraints };
+
+        // Preserve current facing mode when user doesn't specify one
+        if (constraints && !effective.facingMode && this._settings?.facingMode) {
+            effective.facingMode = this._settings.facingMode;
+        }
+
+        const normalized = normalizeConstraints({ video: constraints ? effective : true });
 
         this._settings = await WebRTCModule.mediaStreamTrackApplyConstraints(this.id, normalized.video);
-        this._constraints = constraints ?? {};
+        this._constraints = effective;
     }
 
     clone(): MediaStreamTrack {

src/RTCPeerConnection.ts

@@ -742,13 +742,6 @@ export default class RTCPeerConnection extends EventTarget<RTCPeerConnectionEven
             this.connectionState = ev.connectionState;
 
             this.dispatchEvent(new Event('connectionstatechange'));
-
-            if (ev.connectionState === 'closed') {
-                // This PeerConnection is done, clean up.
-                removeListener(this);
-
-                WebRTCModule.peerConnectionDispose(this._pcId);
-            }
         });
 
         addListener(this, 'peerConnectionSignalingStateChanged', (ev: any) => {
@@ -759,6 +752,13 @@ export default class RTCPeerConnection extends EventTarget<RTCPeerConnectionEven
             this.signalingState = ev.signalingState;
 
             this.dispatchEvent(new Event('signalingstatechange'));
+
+            if (ev.signalingState === 'closed') {
+                // This PeerConnection is done, clean up.
+                removeListener(this);
+
+                WebRTCModule.peerConnectionDispose(this._pcId);
+            }
         });
 
         // Consider moving away from this event: https://github.com/WebKit/WebKit/pull/3953

src/index.ts

@@ -92,8 +92,6 @@ function registerGlobals(): void {
     global.RTCIceCandidate = RTCIceCandidate;
     global.RTCCertificate = RTCCertificate;
     global.RTCPeerConnection = RTCPeerConnection;
-    global.RTCRtpReceiver = RTCRtpReceiver;
-    global.RTCRtpSender = RTCRtpReceiver;
     global.RTCSessionDescription = RTCSessionDescription;
     global.MediaStream = MediaStream;
     global.MediaStreamTrack = MediaStreamTrack;

tools/postbuild.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/**
+ * Fixes up the bob build output for the declaration files which are shipped as-is
+ * (currently the ones for the vendored event-target-shim). bob mishandles them in
+ * both directions, so for every .d.ts file in src/ we:
+ *
+ * - Copy it into the typescript output. That target builds with
+ *   `tsc --emitDeclarationOnly`, and tsc never emits output for .d.ts inputs, so the
+ *   relative imports pointing at them fail to resolve for consumers using the
+ *   declaration files, which silently strips the EventTarget members off our classes.
+ *
+ * - Delete the empty module babel emitted for it in the commonjs and module outputs.
+ *   Those targets compile every source file and rewrite the extension to .js, turning
+ *   index.d.ts into an index.d.js which holds no code and which nothing imports.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const root = path.resolve(import.meta.dirname, '..');
+const source = path.join(root, 'src');
+const output = path.join(root, 'lib');
+const declarationsOutput = path.join(output, 'typescript');
+const compiledOutputs = [ path.join(output, 'commonjs'), path.join(output, 'module') ];
+
+/**
+ * Finds every declaration file below the given directory, as paths relative to it.
+ */
+function findDeclarations(directory, prefix = '') {
+    return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+        const entryPath = path.join(prefix, entry.name);
+
+        if (entry.isDirectory()) {
+            return findDeclarations(path.join(directory, entry.name), entryPath);
+        }
+
+        return entry.name.endsWith('.d.ts') ? [ entryPath ] : [];
+    });
+}
+
+if (!fs.existsSync(output)) {
+    console.error(`${path.relative(root, output)} not found, run "bob build" first.`);
+    process.exit(1);
+}
+
+for (const declaration of findDeclarations(source)) {
+    const target = path.join(declarationsOutput, declaration);
+
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(path.join(source, declaration), target);
+
+    console.info(`Copied src/${declaration} -> ${path.relative(root, target)}`);
+
+    for (const compiledOutput of compiledOutputs) {
+        const compiled = path.join(compiledOutput, declaration.replace(/\.ts$/, '.js'));
+
+        for (const artifact of [ compiled, `${compiled}.map` ]) {
+            if (fs.existsSync(artifact)) {
+                fs.rmSync(artifact);
+
+                console.info(`Removed ${path.relative(root, artifact)}`);
+            }
+        }
+    }
+}