@sbhjt-gr/react-native-webrtc 137.0.2

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