@sbhjt-gr/react-native-webrtc 124.0.0

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;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.oney.WebRTCModule;
+
+import android.util.Log;
+
+import org.webrtc.CameraVideoCapturer;
+
+class CameraEventsHandler implements CameraVideoCapturer.CameraEventsHandler {
+    /**
+     * The {@link Log} tag with which {@code CameraEventsHandler} is to log.
+     */
+    private final static String TAG = WebRTCModule.TAG;
+
+    // Callback invoked when camera closed.
+    @Override
+    public void onCameraClosed() {
+        Log.d(TAG, "CameraEventsHandler.onCameraClosed");
+    }
+
+    // Called when camera is disconnected.
+    @Override
+    public void onCameraDisconnected() {
+        Log.d(TAG, "CameraEventsHandler.onCameraDisconnected");
+    }
+
+    // Camera error handler - invoked when camera can not be opened or any
+    // camera exception happens on camera thread.
+    @Override
+    public void onCameraError(String errorDescription) {
+        Log.d(TAG, "CameraEventsHandler.onCameraError: errorDescription=" + errorDescription);
+    }
+
+    // Invoked when camera stops receiving frames
+    @Override
+    public void onCameraFreezed(String errorDescription) {
+        Log.d(TAG, "CameraEventsHandler.onCameraFreezed: errorDescription=" + errorDescription);
+    }
+
+    // Callback invoked when camera is opening.
+    @Override
+    public void onCameraOpening(String cameraName) {
+        Log.d(TAG, "CameraEventsHandler.onCameraOpening: cameraName=" + cameraName);
+    }
+
+    // Callback invoked when first camera frame is available after camera is opened.
+    @Override
+    public void onFirstFrameAvailable() {
+        Log.d(TAG, "CameraEventsHandler.onFirstFrameAvailable");
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.oney.WebRTCModule;
+
+import android.util.Base64;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.DataChannel;
+
+import java.nio.charset.StandardCharsets;
+
+class DataChannelWrapper implements DataChannel.Observer {
+    private final String reactTag;
+    private final DataChannel mDataChannel;
+    private final int peerConnectionId;
+    private final WebRTCModule webRTCModule;
+
+    DataChannelWrapper(WebRTCModule webRTCModule, int peerConnectionId, String reactTag, DataChannel dataChannel) {
+        this.webRTCModule = webRTCModule;
+        this.peerConnectionId = peerConnectionId;
+        this.reactTag = reactTag;
+        mDataChannel = dataChannel;
+    }
+
+    public DataChannel getDataChannel() {
+        return mDataChannel;
+    }
+
+    public String getReactTag() {
+        return reactTag;
+    }
+
+    @Nullable
+    public String dataChannelStateString(DataChannel.State dataChannelState) {
+        switch (dataChannelState) {
+            case CONNECTING:
+                return "connecting";
+            case OPEN:
+                return "open";
+            case CLOSING:
+                return "closing";
+            case CLOSED:
+                return "closed";
+        }
+        return null;
+    }
+
+    @Override
+    public void onBufferedAmountChange(long amount) {
+        WritableMap params = Arguments.createMap();
+        params.putString("reactTag", reactTag);
+        params.putInt("peerConnectionId", peerConnectionId);
+        params.putDouble("bufferedAmount", Long.valueOf(amount).doubleValue());
+
+        webRTCModule.sendEvent("dataChannelDidChangeBufferedAmount", params);
+    }
+
+    @Override
+    public void onMessage(DataChannel.Buffer buffer) {
+        WritableMap params = Arguments.createMap();
+        params.putString("reactTag", reactTag);
+        params.putInt("peerConnectionId", peerConnectionId);
+
+        byte[] bytes;
+        if (buffer.data.hasArray()) {
+            bytes = buffer.data.array();
+        } else {
+            bytes = new byte[buffer.data.remaining()];
+            buffer.data.get(bytes);
+        }
+
+        String type;
+        String data;
+        if (buffer.binary) {
+            type = "binary";
+            data = Base64.encodeToString(bytes, Base64.NO_WRAP);
+        } else {
+            type = "text";
+            data = new String(bytes, StandardCharsets.UTF_8);
+        }
+        params.putString("type", type);
+        params.putString("data", data);
+
+        webRTCModule.sendEvent("dataChannelReceiveMessage", params);
+    }
+
+    @Override
+    public void onStateChange() {
+        WritableMap params = Arguments.createMap();
+        params.putString("reactTag", reactTag);
+        params.putInt("peerConnectionId", peerConnectionId);
+        params.putInt("id", mDataChannel.id());
+        params.putString("state", dataChannelStateString(mDataChannel.state()));
+
+        webRTCModule.sendEvent("dataChannelStateChanged", params);
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.oney.WebRTCModule;
+
+import android.util.Log;
+
+import org.webrtc.DataPacketCryptor;
+import org.webrtc.DataPacketCryptorFactory;
+import org.webrtc.FrameCryptorAlgorithm;
+import org.webrtc.FrameCryptorKeyProvider;
+
+import javax.annotation.Nullable;
+
+public class DataPacketCryptorManager {
+    private static final String TAG = DataPacketCryptorManager.class.getSimpleName();
+    private final DataPacketCryptor dataPacketCryptor;
+    private boolean isDisposed = false;
+
+    public DataPacketCryptorManager(FrameCryptorAlgorithm algorithm, FrameCryptorKeyProvider keyProvider) {
+        dataPacketCryptor =
+                DataPacketCryptorFactory.createDataPacketCryptor(FrameCryptorAlgorithm.AES_GCM, keyProvider);
+    }
+
+    @Nullable
+    public synchronized DataPacketCryptor.EncryptedPacket encrypt(String participantId, int keyIndex, byte[] payload) {
+        if (isDisposed) {
+            return null;
+        }
+
+        DataPacketCryptor.EncryptedPacket packet = dataPacketCryptor.encrypt(participantId, keyIndex, payload);
+
+        if (packet == null) {
+            Log.i(TAG, "Error encrypting packet: null packet");
+            return null;
+        }
+
+        if (packet.payload == null) {
+            Log.i(TAG, "Error encrypting packet: null payload");
+            return null;
+        }
+        if (packet.iv == null) {
+            Log.i(TAG, "Error encrypting packet: null iv returned");
+            return null;
+        }
+
+        return packet;
+    }
+
+    @Nullable
+    public synchronized byte[] decrypt(String participantId, DataPacketCryptor.EncryptedPacket packet) {
+        if (isDisposed) {
+            return null;
+        }
+
+        return dataPacketCryptor.decrypt(participantId, packet);
+    }
+
+    public synchronized void dispose() {
+        if (isDisposed) {
+            return;
+        }
+        isDisposed = true;
+        dataPacketCryptor.dispose();
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.oney.WebRTCModule;
+
+import android.app.Activity;
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+public class DisplayUtils {
+    public static DisplayMetrics getDisplayMetrics(Activity activity) {
+        DisplayMetrics displayMetrics = new DisplayMetrics();
+        WindowManager windowManager =
+                (WindowManager) activity.getApplication().getSystemService(Context.WINDOW_SERVICE);
+        windowManager.getDefaultDisplay().getRealMetrics(displayMetrics);
+        return displayMetrics;
+    }
+}

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

@@ -0,0 +1,66 @@
+package com.oney.WebRTCModule;
+
+import android.os.Build.VERSION;
+import android.util.Log;
+
+import org.webrtc.EglBase;
+
+public class EglUtils {
+    /**
+     * The root {@link EglBase} instance shared by the entire application for
+     * the sake of reducing the utilization of system resources (such as EGL
+     * contexts). It selects between {@link EglBase10} and {@link EglBase14}
+     * by performing a runtime check.
+     */
+    private static EglBase rootEglBase;
+
+    /**
+     * Lazily creates and returns the one and only {@link EglBase} which will
+     * serve as the root for all contexts that are needed.
+     */
+    public static synchronized EglBase getRootEglBase() {
+        if (rootEglBase == null) {
+            // XXX EglBase14 will report that isEGL14Supported() but its
+            // getEglConfig() will fail with a RuntimeException with message
+            // "Unable to find any matching EGL config". Fall back to EglBase10
+            // in the described scenario.
+            EglBase eglBase = null;
+            int[] configAttributes = EglBase.CONFIG_PLAIN;
+            RuntimeException cause = null;
+
+            try {
+                // WebRTC internally does this check in isEGL14Supported, but it's no longer exposed
+                // in the public API
+                if (VERSION.SDK_INT >= 18) {
+                    eglBase = EglBase.createEgl14(configAttributes);
+                }
+            } catch (RuntimeException ex) {
+                // Fall back to EglBase10.
+                cause = ex;
+            }
+
+            if (eglBase == null) {
+                try {
+                    eglBase = EglBase.createEgl10(configAttributes);
+                } catch (RuntimeException ex) {
+                    // Neither EglBase14, nor EglBase10 succeeded to initialize.
+                    cause = ex;
+                }
+            }
+
+            if (cause != null) {
+                Log.e(EglUtils.class.getName(), "Failed to create EglBase", cause);
+            } else {
+                rootEglBase = eglBase;
+            }
+        }
+
+        return rootEglBase;
+    }
+
+    public static EglBase.Context getRootEglBaseContext() {
+        EglBase eglBase = getRootEglBase();
+
+        return eglBase == null ? null : eglBase.getEglBaseContext();
+    }
+}