Merge upstream react-native-webrtc to 155.0.1

.gitignore

@@ -15,3 +15,4 @@ examples/GumTestApp_macOS/package-lock.json
 lib/
 src/*.js
 android/.gradle
+tmp/

.npmignore

@@ -7,3 +7,4 @@ android/build/
 *.tgz
 *.zip
 .github
+tmp/

Documentation/BasicUsage.md

@@ -112,6 +112,22 @@ try {
 };
 ```
 
+### Using Media Constraints on getDisplayMedia (Android Only)
+
+It is possible to use mediaConstraints on getDisplayMedia to restricts the user to capturing the default display using the custom boolean parameter `createConfigForDefaultDisplay`.
+A resolution scale can also be applied using `resolutionScale` parameter. Value is a number between 0 and 1.
+
+This configuration in only available for android, so will you have to add the 'android' key in constraints.
+
+```javascript
+	const displayMediaStreamConstraints = {
+		android: {
+			createConfigForDefaultDisplay: true,
+			resolutionScale: 0.5,
+		},
+	};
+```
+
 ## Destroying the Media Stream
 
 Cycling all of the tracks and stopping them is more than enough to clean up after a call has finished.  

android/consumer-rules.pro

@@ -1,3 +1,4 @@
 # WebRTC
 -keep class livekit.org.webrtc.** { *; }
 -keep class livekit.org.jni_zero.** { *; }
+-dontwarn livekit.org.jni_zero.**

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

@@ -1,5 +1,7 @@
 package com.oney.WebRTCModule;
 
+import android.util.Log;
+
 import androidx.annotation.Nullable;
 import androidx.core.util.Consumer;
 
@@ -10,6 +12,8 @@
 import livekit.org.webrtc.VideoCapturer;
 
 public abstract class AbstractVideoCaptureController {
+    private static final String TAG = AbstractVideoCaptureController.class.getSimpleName();
+
     protected int targetWidth;
     protected int targetHeight;
     protected int targetFps;
@@ -78,9 +82,7 @@ public void startCapture() {
         try {
             videoCapturer.startCapture(targetWidth, targetHeight, targetFps);
         } catch (RuntimeException e) {
-            // XXX This can only fail if we initialize the capturer incorrectly,
-            // which we don't. Thus, ignore any failures here since we trust
-            // ourselves.
+            Log.e(TAG, "Failed to start capture", e);
         }
     }
 

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

@@ -3,7 +3,11 @@
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
+import android.media.projection.MediaProjectionConfig;
 import android.media.projection.MediaProjectionManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.DisplayMetrics;
 import android.util.Log;
 
@@ -16,6 +20,7 @@
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
@@ -29,6 +34,9 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;
 
 import livekit.org.webrtc.*;
@@ -59,6 +67,8 @@ class GetUserMediaImpl {
 
     private Promise displayMediaPromise;
     private Intent mediaProjectionPermissionResultData;
+    private boolean createConfigForDefaultDisplay = false;
+    private float resolutionScale = 1.0f;
 
     GetUserMediaImpl(WebRTCModule webRTCModule, ReactApplicationContext reactContext) {
         this.webRTCModule = webRTCModule;
@@ -69,6 +79,15 @@ class GetUserMediaImpl {
             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;
@@ -77,10 +96,25 @@ public void onActivityResult(Activity activity, int requestCode, int resultCode,
 
                     mediaProjectionPermissionResultData = data;
 
-                    ThreadUtils.runOnExecutor(() -> {
-                        MediaProjectionService.launch(activity);
+                    CompletableFuture<Void> launchFuture = MediaProjectionService.launch(activity);
+
+                    // CompletableFuture.orTimeout() requires API 31; this is a no-op if already completed.
+                    new Handler(Looper.getMainLooper())
+                            .postDelayed(()
+                                                 -> launchFuture.completeExceptionally(new TimeoutException()),
+                                    TimeUnit.SECONDS.toMillis(10));
+
+                    launchFuture.whenCompleteAsync((value, error) -> {
+                        if (error != null) {
+                            Log.e(TAG, "Failed to start MediaProjection service", error);
+                            displayMediaPromise.reject("DOMException", "AbortError");
+                            displayMediaPromise = null;
+                            mediaProjectionPermissionResultData = null;
+                            return;
+                        }
+
                         createScreenStream();
-                    });
+                    }, ThreadUtils.getExecutor());
                 }
             }
         });
@@ -282,7 +316,41 @@ public void accept(Exception e) {
         }
     }
 
-    void getDisplayMedia(Promise promise) {
+    void initializeConstraints(ReadableMap constraints) {
+        // Handle the incoming params
+
+        ReadableMap androidConstraints = null;
+        if (constraints.hasKey("android") && constraints.getType("android") == ReadableType.Map) {
+            androidConstraints = constraints.getMap("android");
+        }
+
+        // Default values
+        boolean createConfigForDefaultDisplay = false;
+        float scale = 1.0f;
+
+        if (androidConstraints != null) {
+            // MediaProjectionConfig need API level 34
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
+                    && androidConstraints.hasKey("createConfigForDefaultDisplay")
+                    && androidConstraints.getType("createConfigForDefaultDisplay") == ReadableType.Boolean) {
+                createConfigForDefaultDisplay = androidConstraints.getBoolean("createConfigForDefaultDisplay");
+            }
+            if (androidConstraints.hasKey("resolutionScale")
+                    && androidConstraints.getType("resolutionScale") == ReadableType.Number) {
+                scale = (float) androidConstraints.getDouble("resolutionScale");
+            }
+        }
+
+        this.createConfigForDefaultDisplay = createConfigForDefaultDisplay;
+        // Force the value in [0, 1]
+        this.resolutionScale = Math.max(0.0f, Math.min(1.0f, scale));
+
+        Log.d(TAG,
+                "initializeConstraints: createConfigForDefaultDisplay=" + this.createConfigForDefaultDisplay
+                        + " resolutionScale=" + this.resolutionScale);
+    }
+
+    void getDisplayMedia(final ReadableMap constraints, Promise promise) {
         if (this.displayMediaPromise != null) {
             promise.reject(new RuntimeException("Another operation is pending."));
             return;
@@ -294,6 +362,8 @@ void getDisplayMedia(Promise promise) {
             return;
         }
 
+        this.initializeConstraints(constraints);
+
         this.displayMediaPromise = promise;
 
         MediaProjectionManager mediaProjectionManager =
@@ -304,8 +374,18 @@ void getDisplayMedia(Promise promise) {
             UiThreadUtil.runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
-                    currentActivity.startActivityForResult(
-                            mediaProjectionManager.createScreenCaptureIntent(), PERMISSION_REQUEST_CODE);
+                    if (createConfigForDefaultDisplay == true) {
+                        // MediaProjectionConfig need API level 34
+                        // Return mediaProjection which restricts the user to capturing the default display
+                        currentActivity.startActivityForResult(
+                                mediaProjectionManager.createScreenCaptureIntent(
+                                        MediaProjectionConfig.createConfigForDefaultDisplay()),
+                                PERMISSION_REQUEST_CODE);
+                    } else {
+                        // Return mediaProjection which allows the user to decide which region is captured
+                        currentActivity.startActivityForResult(
+                                mediaProjectionManager.createScreenCaptureIntent(), PERMISSION_REQUEST_CODE);
+                    }
                 }
             });
 
@@ -315,6 +395,14 @@ public void run() {
     }
 
     private void createScreenStream() {
+        // A duplicate onActivityResult dispatch (see onActivityResult above) can schedule this more
+        // than once. 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;
+        }
+
         VideoTrack track = createScreenTrack();
 
         if (track == null) {
@@ -392,7 +480,7 @@ private VideoTrack createScreenTrack() {
         int width = displayMetrics.widthPixels;
         int height = displayMetrics.heightPixels;
         ScreenCaptureController screenCaptureController = new ScreenCaptureController(
-                reactContext.getCurrentActivity(), width, height, mediaProjectionPermissionResultData);
+                reactContext.getCurrentActivity(), width, height, mediaProjectionPermissionResultData, resolutionScale);
         return createVideoTrack(screenCaptureController);
     }
 

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

@@ -11,6 +11,7 @@
 import android.util.Log;
 
 import java.util.Random;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * This class implements an Android {@link Service}, a foreground one specifically, and it's
@@ -24,11 +25,17 @@ public class MediaProjectionService extends Service {
 
     static final int NOTIFICATION_ID = new Random().nextInt(99999) + 10000;
 
-    public static void launch(Context context) {
+    private static volatile CompletableFuture<Void> startFuture;
+
+    public static CompletableFuture<Void> launch(Context context) {
         if (!WebRTCModuleOptions.getInstance().enableMediaProjectionService) {
-            return;
+            return CompletableFuture.completedFuture(null);
         }
 
+        CompletableFuture<Void> future = new CompletableFuture<>();
+
+        startFuture = future;
+
         MediaProjectionNotification.createNotificationChannel(context);
         Intent intent = new Intent(context, MediaProjectionService.class);
         ComponentName componentName;
@@ -43,14 +50,21 @@ public static void launch(Context context) {
             // Avoid crashing due to ForegroundServiceStartNotAllowedException (API level 31).
             // See: https://developer.android.com/guide/components/foreground-services#background-start-restrictions
             Log.w(TAG, "Media projection service not started", e);
-            return;
+            startFuture = null;
+            future.completeExceptionally(e);
+
+            return future;
         }
 
         if (componentName == null) {
             Log.w(TAG, "Media projection service not started");
+            startFuture = null;
+            future.completeExceptionally(new RuntimeException("Media projection service not started"));
         } else {
             Log.i(TAG, "Media projection service started");
         }
+
+        return future;
     }
 
     public static void abort(Context context) {
@@ -77,6 +91,13 @@ public int onStartCommand(Intent intent, int flags, int startId) {
             startForeground(NOTIFICATION_ID, notification);
         }
 
+        CompletableFuture<Void> fut = startFuture;
+
+        if (fut != null) {
+            startFuture = null;
+            fut.complete(null);
+        }
+
         return START_NOT_STICKY;
     }
 }

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

@@ -25,8 +25,9 @@ public class ScreenCaptureController extends AbstractVideoCaptureController {
 
     private final Context context;
 
-    public ScreenCaptureController(Context context, int width, int height, Intent mediaProjectionPermissionResultData) {
-        super(width, height, DEFAULT_FPS);
+    public ScreenCaptureController(
+            Context context, int width, int height, Intent mediaProjectionPermissionResultData, float resolutionScale) {
+        super((int) (width * resolutionScale), (int) (height * resolutionScale), DEFAULT_FPS);
 
         this.mediaProjectionPermissionResultData = mediaProjectionPermissionResultData;
 
@@ -36,8 +37,8 @@ public ScreenCaptureController(Context context, int width, int height, Intent me
             @Override
             public void onOrientationChanged(int orientation) {
                 DisplayMetrics displayMetrics = DisplayUtils.getDisplayMetrics((Activity) context);
-                final int width = displayMetrics.widthPixels;
-                final int height = displayMetrics.heightPixels;
+                final int width = (int) (displayMetrics.widthPixels * resolutionScale);
+                final int height = (int) (displayMetrics.heightPixels * resolutionScale);
                 if (width != ScreenCaptureController.this.actualWidth
                         || height != ScreenCaptureController.this.actualHeight) {
                     ScreenCaptureController.this.actualWidth = width;

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

@@ -13,6 +13,14 @@ final class ThreadUtils {
      */
     private static final ExecutorService executor = Executors.newSingleThreadExecutor();
 
+    /**
+     * Gets the executor used to run all WebRTC PeerConnection APIs.
+     * @return ExecutorService.
+     */
+    public static ExecutorService getExecutor() {
+        return executor;
+    }
+
     /**
      * Runs the given {@link Runnable} on the executor.
      * @param runnable