@sbhjt-gr/react-native-webrtc 137.0.2

package/.clang-format

@@ -0,0 +1,11 @@
+---
+BasedOnStyle: Chromium
+BinPackArguments: 'false'
+ColumnLimit: '120'
+IndentWidth: '4'
+ObjCBlockIndentWidth: '4'
+ObjCSpaceBeforeProtocolList: 'false'
+PointerAlignment: Right
+UseTab: Never
+
+...

package/.eslintignore

@@ -0,0 +1,6 @@
+examples
+lib
+tools
+
+metro.*.js
+react-native.config.js

package/.nvmrc

@@ -0,0 +1 @@
+22

package/ISSUE_TEMPLATE.md

@@ -0,0 +1,40 @@
+<!--
+If you have any questions then please use our Community Discourse: https://react-native-webrtc.discourse.group/  
+Otherwise you are in the right place for reporting bugs.
+
+Please include as much information as possible and make the issue title as descriptive as you can.
+But most of all please take your time and explain to the best of your abilities.
+
+Code samples can be very helpful but even more so if displayed correctly.
+Here is an example of how you can use syntax highlighting.
+
+```javascript
+
+console.log( 'Hello World' );
+
+```
+
+More info can be found over here.
+https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#syntax-highlighting
+-->
+
+#### Expected Behavior:
+<!--
+Explain what you expect to happen.
+-->
+
+#### Observed Behavior:
+<!--
+Explain what is actually happening.
+-->
+
+#### Steps to reproduce the issue:
+<!--
+Explain how the issue can be reproduced.
+If we manage to reproduce the issue then it is more likely to be addressed in an update.
+-->
+
+#### Platform Information  
+* **React Native Version**: 
+* **WebRTC Module Version**: 
+* **Platform OS + Version**: <!-- Android / iOS / macOS / Web / Expo -->

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present React Native WebRTC Community
+Copyright (c) 2015-2017 Howard Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+[<img src="https://avatars.githubusercontent.com/u/42463376" alt="React Native WebRTC" style="height: 6em;" />](https://github.com/react-native-webrtc/react-native-webrtc)
+
+# React-Native-WebRTC
+[![npm version](https://img.shields.io/npm/v/@sbhjt-gr/react-native-webrtc)](https://www.npmjs.com/package/@sbhjt-gr/react-native-webrtc)
+[![Discourse topics](https://img.shields.io/discourse/topics?server=https%3A%2F%2Freact-native-webrtc.discourse.group%2F)](https://react-native-webrtc.discourse.group/)
+
+A WebRTC module for React Native.
+
+> [!NOTE]
+> This is a fork of [livekit/react-native-webrtc](https://github.com/livekit/react-native-webrtc) with additional audio interception features for real-time translation.
+
+## Feature Overview
+
+|  | Android | iOS | tvOS | macOS* | Windows* | Web* | Expo* |
+| :- | :-: | :-: | :-: | :-: | :-: | :-: | :-: |
+| Audio/Video | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | - | - | :heavy_check_mark: | :heavy_check_mark: |
+| Data Channels | :heavy_check_mark: | :heavy_check_mark: | - | - | - | :heavy_check_mark: | :heavy_check_mark: |
+| Screen Capture | :heavy_check_mark: | :heavy_check_mark: | - | - | - | :heavy_check_mark: | :heavy_check_mark: |
+| Plan B | - | - | - | - | - | - | - |
+| Unified Plan* | :heavy_check_mark: | :heavy_check_mark: | - | - | - | :heavy_check_mark: | :heavy_check_mark: |
+| Simulcast* | :heavy_check_mark: | :heavy_check_mark: | - | - | - | :heavy_check_mark: | :heavy_check_mark: |
+
+> **macOS** - We don't currently actively support macOS at this time.  
+Support might return in the future.
+
+> **Windows** - We don't currently support the [react-native-windows](https://github.com/microsoft/react-native-windows) platform at this time.  
+Anyone interested in getting the ball rolling? We're open to contributions.
+
+> **Web** - The [react-native-webrtc-web-shim](https://github.com/react-native-webrtc/react-native-webrtc-web-shim) project provides a shim for [react-native-web](https://github.com/necolas/react-native-web) support.  
+Which will allow you to use [(almost)](https://github.com/react-native-webrtc/react-native-webrtc-web-shim/tree/main#setup) the exact same code in your [react-native-web](https://github.com/necolas/react-native-web) project as you would with [react-native](https://reactnative.dev/) directly.  
+
+> **Expo** - As this module includes native code it is not available in the [Expo Go](https://expo.dev/client) app by default.  
+However you can get things working via the [expo-dev-client](https://docs.expo.dev/development/getting-started/) library and out-of-tree [config-plugins/react-native-webrtc](https://github.com/expo/config-plugins/tree/master/packages/react-native-webrtc) package.  
+
+> **Unified Plan** - As of version 106.0.0 Unified Plan is the only supported mode.  
+Those still in need of Plan B will need to use an older release.
+
+> **Simulcast** - As of version 111.0.0 Simulcast is now possible with ease.  
+Software encode/decode factories have been enabled by default.
+
+## WebRTC Revision
+
+* Currently used revision: [M125](https://github.com/webrtc-sdk/webrtc/tree/m125_release)
+* Supported architectures
+  * Android: armeabi-v7a, arm64-v8a, x86, x86_64
+  * iOS: arm64, x86_64
+  * tvOS: arm64
+  * macOS: arm64, x86_64
+
+## Getting Started
+
+Use one of the following preferred package install methods to immediately get going.  
+Don't forget to follow platform guides below to cover any extra required steps.  
+
+**npm:** `npm install @sbhjt-gr/react-native-webrtc --save`  
+**yarn:** `yarn add @sbhjt-gr/react-native-webrtc`  
+**pnpm:** `pnpm install @sbhjt-gr/react-native-webrtc`  
+
+## Guides
+
+- [Android Install](./Documentation/AndroidInstallation.md)
+- [iOS Install](./Documentation/iOSInstallation.md)
+- [tvOS Install](./Documentation/tvOSInstallation.md)
+- [Basic Usage](./Documentation/BasicUsage.md)
+- [Step by Step Call Guide](./Documentation/CallGuide.md)
+- [Improving Call Reliability](./Documentation/ImprovingCallReliability.md)
+- [Migrating to Unified Plan](https://docs.google.com/document/d/1-ZfikoUtoJa9k-GZG1daN0BU3IjIanQ_JSscHxQesvU/edit#heading=h.wuu7dx8tnifl)
+
+## Example Projects
+
+We have some very basic example projects included in the [examples](./examples) directory.  
+Don't worry, there are plans to include a much more broader example with backend included.  
+
+## Community
+
+Come join our [Discourse Community](https://react-native-webrtc.discourse.group/) if you want to discuss any React Native and WebRTC related topics.  
+Everyone is welcome and every little helps.  
+
+## Related Projects
+
+Looking for extra functionality coverage?  
+The [react-native-webrtc](https://github.com/react-native-webrtc) organization provides a number of packages which are more than useful when developing Real Time Communication applications.  

package/android/build.gradle

@@ -0,0 +1,36 @@
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+      namespace "com.oney.WebRTCModule"
+    }
+
+    compileSdkVersion safeExtGet('compileSdkVersion', 24)
+    buildToolsVersion safeExtGet('buildToolsVersion', "23.0.1")
+
+    defaultConfig {
+        minSdkVersion 24
+        targetSdkVersion safeExtGet('targetSdkVersion', 24)
+        versionCode 1
+        versionName "1.0"
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    // WebRTC requires Java 8 features
+    // https://groups.google.com/forum/?utm_medium=email&utm_source=footer#!msg/discuss-webrtc/V1h2uQMDCkA/RA-uzncVAAAJ
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-android:+"
+    api 'io.github.webrtc-sdk:android:137.7151.04'
+    implementation "androidx.core:core:1.7.0"
+}

package/android/consumer-rules.pro

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

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.oney.WebRTCModule"
+          xmlns:tools="http://schemas.android.com/tools"
+    >
+    <application>
+        <service
+                android:name=".MediaProjectionService"
+                android:foregroundServiceType="mediaProjection">
+        </service>
+    </application>
+</manifest>

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

@@ -0,0 +1,113 @@
+package com.oney.WebRTCModule;
+
+import androidx.annotation.Nullable;
+import androidx.core.util.Consumer;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.VideoCapturer;
+
+public abstract class AbstractVideoCaptureController {
+    protected int targetWidth;
+    protected int targetHeight;
+    protected int targetFps;
+
+    protected int actualWidth;
+    protected int actualHeight;
+    protected int actualFps;
+
+    /**
+     * {@link VideoCapturer} which this controller manages.
+     */
+    protected VideoCapturer videoCapturer;
+
+    protected CapturerEventsListener capturerEventsListener;
+
+    public AbstractVideoCaptureController(int width, int height, int fps) {
+        this.targetWidth = width;
+        this.targetHeight = height;
+        this.targetFps = fps;
+        this.actualWidth = width;
+        this.actualHeight = height;
+        this.actualFps = fps;
+    }
+
+    public void initializeVideoCapturer() {
+        videoCapturer = createVideoCapturer();
+    }
+
+    @Nullable
+    public abstract String getDeviceId();
+
+    public void dispose() {
+        if (videoCapturer != null) {
+            videoCapturer.dispose();
+            videoCapturer = null;
+        }
+    }
+
+    public int getHeight() {
+        return actualHeight;
+    }
+
+    public int getWidth() {
+        return actualWidth;
+    }
+
+    public int getFrameRate() {
+        return actualFps;
+    }
+
+    public WritableMap getSettings() {
+        WritableMap settings = Arguments.createMap();
+        settings.putString("deviceId", getDeviceId());
+        settings.putString("groupId", "");
+        settings.putInt("height", getHeight());
+        settings.putInt("width", getWidth());
+        settings.putInt("frameRate", getFrameRate());
+        return settings;
+    }
+
+    public VideoCapturer getVideoCapturer() {
+        return videoCapturer;
+    }
+
+    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.
+        }
+    }
+
+    public boolean stopCapture() {
+        try {
+            videoCapturer.stopCapture();
+            return true;
+        } catch (InterruptedException e) {
+            return false;
+        }
+    }
+
+    public void applyConstraints(ReadableMap constraints, @Nullable Consumer<Exception> onFinishedCallback) {
+        if (onFinishedCallback != null) {
+            onFinishedCallback.accept(
+                    new UnsupportedOperationException("This video track does not support applyConstraints."));
+        }
+    }
+
+    public void setCapturerEventsListener(CapturerEventsListener listener) {
+        this.capturerEventsListener = listener;
+    }
+
+    protected abstract VideoCapturer createVideoCapturer();
+
+    public interface CapturerEventsListener {
+        /** Called when the capturer is ended and in an irrecoverable state. */
+        public void onCapturerEnded();
+    }
+}

package/android/src/main/java/com/oney/WebRTCModule/CameraCaptureController.java

@@ -0,0 +1,338 @@
+package com.oney.WebRTCModule;
+
+import android.content.Context;
+import android.hardware.camera2.CameraManager;
+import android.util.Log;
+import android.util.Pair;
+
+import androidx.annotation.Nullable;
+import androidx.core.util.Consumer;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.Camera1Capturer;
+import org.webrtc.Camera1Helper;
+import org.webrtc.Camera2Capturer;
+import org.webrtc.Camera2Helper;
+import org.webrtc.CameraEnumerator;
+import org.webrtc.CameraVideoCapturer;
+import org.webrtc.Size;
+import org.webrtc.VideoCapturer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class CameraCaptureController extends AbstractVideoCaptureController {
+    /**
+     * The {@link Log} tag with which {@code CameraCaptureController} is to log.
+     */
+    private static final String TAG = CameraCaptureController.class.getSimpleName();
+
+    private boolean isFrontFacing;
+
+    /**
+     * Equivalent to the camera index as a String
+     */
+    @Nullable
+    private String currentDeviceId;
+
+    private final Context context;
+    private final CameraEnumerator cameraEnumerator;
+
+    private final String constraintDeviceId;
+    private final String constraintFacingMode;
+    private ReadableMap constraints;
+
+    /**
+     * The {@link CameraEventsHandler} used with
+     * {@link CameraEnumerator#createCapturer}.
+     */
+    private final CameraEventsHandler cameraEventsHandler = new CameraEventsHandler() {
+        @Override
+        public void onCameraOpening(String cameraName) {
+            super.onCameraOpening(cameraName);
+            int cameraIndex = findCameraIndex(cameraName);
+            updateActualSize(cameraIndex, cameraName, videoCapturer);
+            CameraCaptureController.this.currentDeviceId = cameraIndex == -1 ? null : String.valueOf(cameraIndex);
+        }
+    };
+
+    public CameraCaptureController(Context context, CameraEnumerator cameraEnumerator, ReadableMap constraints) {
+        super(constraints.getInt("width"), constraints.getInt("height"), constraints.getInt("frameRate"));
+
+        this.context = context;
+        this.cameraEnumerator = cameraEnumerator;
+        this.constraints = constraints;
+
+        this.constraintDeviceId = ReactBridgeUtil.getMapStrValue(this.constraints, "deviceId");
+        this.constraintFacingMode = ReactBridgeUtil.getMapStrValue(this.constraints, "facingMode");
+    }
+
+    @Nullable
+    @Override
+    public String getDeviceId() {
+        return currentDeviceId;
+    }
+
+    private int findCameraIndex(String cameraName) {
+        String[] deviceNames = cameraEnumerator.getDeviceNames();
+        for (int i = 0; i < deviceNames.length; i++) {
+            if (Objects.equals(deviceNames[i], cameraName)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public WritableMap getSettings() {
+        WritableMap settings = super.getSettings();
+        settings.putString("facingMode", isFrontFacing ? "user" : "environment");
+        return settings;
+    }
+
+    @Override
+    public void applyConstraints(ReadableMap constraints, @Nullable Consumer<Exception> onFinishedCallback) {
+        ReadableMap oldConstraints = this.constraints;
+        int oldTargetWidth = this.targetWidth;
+        int oldTargetHeight = this.targetHeight;
+        int oldTargetFps = this.targetFps;
+
+        // Don't save constraints yet, since we may fail to find a fit.
+        Runnable saveConstraints = () -> {
+            this.constraints = constraints;
+            this.targetWidth = constraints.getInt("width");
+            this.targetHeight = constraints.getInt("height");
+            this.targetFps = constraints.getInt("frameRate");
+        };
+
+        if (videoCapturer == null) {
+            // No existing capturer, just let it initialize normally.
+            saveConstraints.run();
+            if (onFinishedCallback != null) {
+                onFinishedCallback.accept(null);
+            }
+            return;
+        }
+
+        // Find target camera to switch to.
+        String[] deviceNames = cameraEnumerator.getDeviceNames();
+
+        // Use the initial deviceId/facingMode. It is a constraint violation to change these through applyConstraints.
+        final String deviceId = constraintDeviceId;
+        final String facingMode = constraintFacingMode;
+        int cameraIndex = -1;
+        String cameraName = null;
+
+        // If deviceId is specified, then it takes precedence over facingMode.
+        if (deviceId != null) {
+            try {
+                cameraIndex = Integer.parseInt(deviceId);
+                cameraName = deviceNames[cameraIndex];
+            } catch (Exception e) {
+                Log.d(TAG, "failed to find device with id: " + deviceId);
+            }
+        }
+
+        // Otherwise, use facingMode (defaulting to front/user facing).
+        if (cameraName == null) {
+            cameraIndex = -1;
+            final boolean isFrontFacing = facingMode == null || facingMode.equals("user");
+            for (String name : deviceNames) {
+                cameraIndex++;
+                if (cameraEnumerator.isFrontFacing(name) == isFrontFacing) {
+                    cameraName = name;
+                    break;
+                }
+            }
+        }
+
+        if (cameraName == null) {
+            if (onFinishedCallback != null) {
+                onFinishedCallback.accept(new Exception("OverconstrainedError: could not find camera with deviceId: "
+                        + deviceId + " or facingMode: " + facingMode));
+            }
+            return;
+        }
+
+        // For lambda reference
+        final int finalCameraIndex = cameraIndex;
+        final String finalCameraName = cameraName;
+        boolean shouldSwitchCamera = false;
+        try {
+            int currentCameraIndex = Integer.parseInt(currentDeviceId);
+            shouldSwitchCamera = cameraIndex != currentCameraIndex;
+        } catch (Exception e) {
+            shouldSwitchCamera = true;
+            Log.d(TAG, "Forcing camera switch, couldn't parse current device id: " + currentDeviceId);
+        }
+
+        CameraVideoCapturer capturer = (CameraVideoCapturer) videoCapturer;
+        Runnable changeFormatIfNeededAndFinish = () -> {
+            saveConstraints.run();
+            if (targetWidth != oldTargetWidth || targetHeight != oldTargetHeight || targetFps != oldTargetFps) {
+                updateActualSize(finalCameraIndex, finalCameraName, videoCapturer);
+                capturer.changeCaptureFormat(targetWidth, targetHeight, targetFps);
+            }
+            if (onFinishedCallback != null) {
+                onFinishedCallback.accept(null);
+            }
+        };
+
+        if (shouldSwitchCamera) {
+            capturer.switchCamera(new CameraVideoCapturer.CameraSwitchHandler() {
+                @Override
+                public void onCameraSwitchDone(boolean isFrontCamera) {
+                    CameraCaptureController.this.isFrontFacing = isFrontCamera;
+                    changeFormatIfNeededAndFinish.run();
+                }
+
+                @Override
+                public void onCameraSwitchError(String s) {
+                    Exception e = new Exception("Error switching camera: " + s);
+                    Log.e(TAG, "OnCameraSwitchError", e);
+                    if (onFinishedCallback != null) {
+                        onFinishedCallback.accept(e);
+                    }
+                }
+            }, cameraName);
+        } else {
+            // No camera switch needed, just change format if needed.
+            changeFormatIfNeededAndFinish.run();
+        }
+    }
+
+    @Override
+    protected VideoCapturer createVideoCapturer() {
+        CreateCapturerResult result = createVideoCapturer(constraintDeviceId, constraintFacingMode);
+        if (result == null) {
+            return null;
+        }
+
+        updateActualSize(result.cameraIndex, result.cameraName, result.videoCapturer);
+
+        return result.videoCapturer;
+    }
+
+    private void updateActualSize(int cameraIndex, String cameraName, VideoCapturer videoCapturer) {
+        // Find actual capture format.
+        Size actualSize = null;
+        if (videoCapturer instanceof Camera1Capturer) {
+            actualSize = Camera1Helper.findClosestCaptureFormat(cameraIndex, targetWidth, targetHeight);
+        } else if (videoCapturer instanceof Camera2Capturer) {
+            CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+            actualSize = Camera2Helper.findClosestCaptureFormat(cameraManager, cameraName, targetWidth, targetHeight);
+        }
+
+        if (actualSize != null) {
+            actualWidth = actualSize.width;
+            actualHeight = actualSize.height;
+        }
+    }
+
+    /**
+     * Constructs a new {@code VideoCapturer} instance attempting to satisfy
+     * specific constraints.
+     *
+     * @param deviceId   the ID of the requested video device. If not
+     *                   {@code null} and a {@code VideoCapturer} can be created for it, then
+     *                   {@code facingMode} is ignored.
+     * @param facingMode the facing of the requested video source such as
+     * {@code user} and {@code environment}. If {@code null}, "user" is
+     * presumed.
+     * @return a pair containing the deviceId and {@code VideoCapturer} satisfying the {@code facingMode} or
+     * {@code deviceId} constraint, or null.
+     */
+    @Nullable
+    private CreateCapturerResult createVideoCapturer(String deviceId, String facingMode) {
+        String[] deviceNames = cameraEnumerator.getDeviceNames();
+        List<String> failedDevices = new ArrayList<>();
+
+        String cameraName = null;
+        int cameraIndex = -1;
+        try {
+            cameraIndex = Integer.parseInt(deviceId);
+            cameraName = deviceNames[cameraIndex];
+        } catch (Exception e) {
+            Log.d(TAG, "failed to find device with id: " + deviceId);
+        }
+
+        // If deviceId is specified, then it takes precedence over facingMode.
+        if (cameraName != null) {
+            VideoCapturer videoCapturer = cameraEnumerator.createCapturer(cameraName, cameraEventsHandler);
+            String message = "Create user-specified camera " + cameraName;
+            if (videoCapturer != null) {
+                Log.d(TAG, message + " succeeded");
+                this.isFrontFacing = cameraEnumerator.isFrontFacing(cameraName);
+                this.currentDeviceId = String.valueOf(cameraIndex);
+                return new CreateCapturerResult(cameraIndex, cameraName, videoCapturer);
+            } else {
+                // fallback to facingMode
+                Log.d(TAG, message + " failed");
+                failedDevices.add(cameraName);
+            }
+        }
+
+        // Otherwise, use facingMode (defaulting to front/user facing).
+        final boolean isFrontFacing = facingMode == null || facingMode.equals("user");
+        cameraIndex = -1;
+        for (String name : deviceNames) {
+            cameraIndex++;
+            if (failedDevices.contains(name)) {
+                continue;
+            }
+            if (cameraEnumerator.isFrontFacing(name) != isFrontFacing) {
+                continue;
+            }
+            VideoCapturer videoCapturer = cameraEnumerator.createCapturer(name, cameraEventsHandler);
+            String message = "Create camera " + name;
+            if (videoCapturer != null) {
+                Log.d(TAG, message + " succeeded");
+                this.isFrontFacing = cameraEnumerator.isFrontFacing(name);
+                this.currentDeviceId = String.valueOf(cameraIndex);
+                return new CreateCapturerResult(cameraIndex, name, videoCapturer);
+            } else {
+                Log.d(TAG, message + " failed");
+                failedDevices.add(name);
+            }
+        }
+
+        cameraIndex = -1;
+        // Fallback to any available camera.
+        for (String name : deviceNames) {
+            cameraIndex++;
+            if (!failedDevices.contains(name)) {
+                VideoCapturer videoCapturer = cameraEnumerator.createCapturer(name, cameraEventsHandler);
+                String message = "Create fallback camera " + name;
+                if (videoCapturer != null) {
+                    Log.d(TAG, message + " succeeded");
+                    this.isFrontFacing = cameraEnumerator.isFrontFacing(name);
+                    this.currentDeviceId = String.valueOf(cameraIndex);
+                    return new CreateCapturerResult(cameraIndex, name, videoCapturer);
+                } else {
+                    Log.d(TAG, message + " failed");
+                    failedDevices.add(name);
+                }
+            }
+        }
+
+        currentDeviceId = null;
+        Log.w(TAG, "Unable to identify a suitable camera.");
+
+        return null;
+    }
+
+    private static class CreateCapturerResult {
+        public final int cameraIndex;
+        public final String cameraName;
+        public final VideoCapturer videoCapturer;
+
+        public CreateCapturerResult(int cameraIndex, String cameraName, VideoCapturer videoCapturer) {
+            this.cameraIndex = cameraIndex;
+            this.cameraName = cameraName;
+            this.videoCapturer = videoCapturer;
+        }
+    }
+}