@sbhjt-gr/react-native-webrtc 137.0.2

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

@@ -0,0 +1,493 @@
+package com.oney.WebRTCModule;
+
+import android.util.Base64;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.DataPacketCryptor;
+import org.webrtc.FrameCryptor;
+import org.webrtc.FrameCryptorAlgorithm;
+import org.webrtc.FrameCryptorFactory;
+import org.webrtc.FrameCryptorKeyProvider;
+import org.webrtc.RtpReceiver;
+import org.webrtc.RtpSender;
+
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+public class RTCCryptoManager {
+    private static final String TAG = "RTCFrameCryptor";
+    private final Map<String, FrameCryptor> frameCryptos = new HashMap<>();
+    private final Map<String, FrameCryptorStateObserver> frameCryptoObservers = new HashMap<>();
+    private final Map<String, FrameCryptorKeyProvider> keyProviders = new HashMap<>();
+    private final Map<String, DataPacketCryptorManager> dataPacketCryptors = new HashMap<>();
+    private final WebRTCModule webRTCModule;
+
+    public RTCCryptoManager(WebRTCModule webRTCModule) {
+        this.webRTCModule = webRTCModule;
+    }
+
+    private void sendEvent(String eventName, WritableMap params) {
+        webRTCModule.sendEvent(eventName, params);
+    }
+
+    class FrameCryptorStateObserver implements FrameCryptor.Observer {
+        public FrameCryptorStateObserver(String frameCryptorId) {
+            this.frameCryptorId = frameCryptorId;
+        }
+
+        private final String frameCryptorId;
+
+        private String frameCryptorErrorStateToString(FrameCryptor.FrameCryptionState state) {
+            switch (state) {
+                case NEW:
+                    return "new";
+                case OK:
+                    return "ok";
+                case DECRYPTIONFAILED:
+                    return "decryptionFailed";
+                case ENCRYPTIONFAILED:
+                    return "encryptionFailed";
+                case INTERNALERROR:
+                    return "internalError";
+                case KEYRATCHETED:
+                    return "keyRatcheted";
+                case MISSINGKEY:
+                    return "missingKey";
+                default:
+                    throw new IllegalArgumentException("Unknown FrameCryptorErrorState: " + state);
+            }
+        }
+
+        @Override
+        public void onFrameCryptionStateChanged(String participantId, FrameCryptor.FrameCryptionState state) {
+            WritableMap event = Arguments.createMap();
+            event.putString("event", "frameCryptionStateChanged");
+            event.putString("participantId", participantId);
+            event.putString("state", frameCryptorErrorStateToString(state));
+            event.putString("frameCryptorId", frameCryptorId);
+            sendEvent("frameCryptionStateChanged", event);
+        }
+    }
+    //
+
+    private FrameCryptorAlgorithm frameCryptorAlgorithmFromInt(int algorithm) {
+        switch (algorithm) {
+            case 0:
+                return FrameCryptorAlgorithm.AES_GCM;
+            // case 1:
+            //     return FrameCryptorAlgorithm.AES_CBC;
+            default:
+                return FrameCryptorAlgorithm.AES_GCM;
+        }
+    }
+
+    public String frameCryptorFactoryCreateFrameCryptor(ReadableMap params) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            Log.w(TAG, "frameCryptorFactoryCreateFrameCryptorFailed: keyProvider not found");
+            return null;
+        }
+        int peerConnectionId = params.getInt("peerConnectionId");
+        PeerConnectionObserver pco = webRTCModule.getPeerConnectionObserver(peerConnectionId);
+        if (pco == null) {
+            Log.w(TAG, "frameCryptorFactoryCreateFrameCryptorFailed: peerConnection not found");
+            return null;
+        }
+        String participantId = params.getString("participantId");
+        String type = params.getString("type");
+        int algorithm = params.getInt("algorithm");
+        String rtpSenderId = params.getString("rtpSenderId");
+        String rtpReceiverId = params.getString("rtpReceiverId");
+
+        if (type == null || !(type.equals("sender") || type.equals("receiver"))) {
+            Log.w(TAG, "frameCryptorFactoryCreateFrameCryptorFailed: type must be sender or receiver");
+            return null;
+        } else if (type.equals("sender")) {
+            RtpSender rtpSender = pco.getSender(rtpSenderId);
+
+            FrameCryptor frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpSender(webRTCModule.mFactory,
+                    rtpSender,
+                    participantId,
+                    frameCryptorAlgorithmFromInt(algorithm),
+                    keyProvider);
+            String frameCryptorId = UUID.randomUUID().toString();
+            frameCryptos.put(frameCryptorId, frameCryptor);
+            FrameCryptorStateObserver observer = new FrameCryptorStateObserver(frameCryptorId);
+            frameCryptor.setObserver(observer);
+            frameCryptoObservers.put(frameCryptorId, observer);
+
+            return frameCryptorId;
+        } else {
+            RtpReceiver rtpReceiver = pco.getReceiver(rtpReceiverId);
+
+            FrameCryptor frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpReceiver(webRTCModule.mFactory,
+                    rtpReceiver,
+                    participantId,
+                    frameCryptorAlgorithmFromInt(algorithm),
+                    keyProvider);
+            String frameCryptorId = UUID.randomUUID().toString();
+            frameCryptos.put(frameCryptorId, frameCryptor);
+            FrameCryptorStateObserver observer = new FrameCryptorStateObserver(frameCryptorId);
+            frameCryptor.setObserver(observer);
+            frameCryptoObservers.put(frameCryptorId, observer);
+
+            return frameCryptorId;
+        }
+    }
+
+    public void frameCryptorSetKeyIndex(ReadableMap params, @NonNull Promise result) {
+        String frameCryptorId = params.getString("frameCryptorId");
+        FrameCryptor frameCryptor = frameCryptos.get(frameCryptorId);
+        if (frameCryptor == null) {
+            result.reject("frameCryptorSetKeyIndexFailed", "frameCryptor not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = params.getInt("keyIndex");
+        frameCryptor.setKeyIndex(keyIndex);
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("result", true);
+        result.resolve(paramsResult);
+    }
+
+    public void frameCryptorGetKeyIndex(ReadableMap params, @NonNull Promise result) {
+        String frameCryptorId = params.getString("frameCryptorId");
+        FrameCryptor frameCryptor = frameCryptos.get(frameCryptorId);
+        if (frameCryptor == null) {
+            result.reject("frameCryptorGetKeyIndexFailed", "frameCryptor not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = frameCryptor.getKeyIndex();
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putInt("keyIndex", keyIndex);
+        result.resolve(paramsResult);
+    }
+
+    public void frameCryptorSetEnabled(ReadableMap params, @NonNull Promise result) {
+        String frameCryptorId = params.getString("frameCryptorId");
+        FrameCryptor frameCryptor = frameCryptos.get(frameCryptorId);
+        if (frameCryptor == null) {
+            result.reject("frameCryptorSetEnabledFailed", "frameCryptor not found", (Throwable) null);
+            return;
+        }
+        boolean enabled = params.getBoolean("enabled");
+        frameCryptor.setEnabled(enabled);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("result", enabled);
+        result.resolve(paramsResult);
+    }
+
+    public void frameCryptorGetEnabled(ReadableMap params, @NonNull Promise result) {
+        String frameCryptorId = params.getString("frameCryptorId");
+        FrameCryptor frameCryptor = frameCryptos.get(frameCryptorId);
+        if (frameCryptor == null) {
+            result.reject("frameCryptorGetEnabledFailed", "frameCryptor not found", (Throwable) null);
+            return;
+        }
+        boolean enabled = frameCryptor.isEnabled();
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("enabled", enabled);
+        result.resolve(paramsResult);
+    }
+
+    public void frameCryptorDispose(ReadableMap params, @NonNull Promise result) {
+        String frameCryptorId = params.getString("frameCryptorId");
+        FrameCryptor frameCryptor = frameCryptos.get(frameCryptorId);
+        if (frameCryptor == null) {
+            result.reject("frameCryptorDisposeFailed", "frameCryptor not found", (Throwable) null);
+            return;
+        }
+        frameCryptor.dispose();
+        frameCryptos.remove(frameCryptorId);
+        frameCryptoObservers.remove(frameCryptorId);
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", "success");
+        result.resolve(paramsResult);
+    }
+
+    @Nullable
+    public String frameCryptorFactoryCreateKeyProvider(ReadableMap keyProviderOptions) {
+        String keyProviderId = UUID.randomUUID().toString();
+
+        if (keyProviderOptions == null) {
+            Log.w(TAG, "frameCryptorFactoryCreateKeyProvider: keyProviderOptions is null!");
+            return null;
+        }
+        boolean sharedKey = keyProviderOptions.getBoolean("sharedKey");
+        int ratchetWindowSize = keyProviderOptions.getInt("ratchetWindowSize");
+        int failureTolerance = keyProviderOptions.getInt("failureTolerance");
+
+        byte[] ratchetSalt = getBytesFromMap(keyProviderOptions, "ratchetSalt", "ratchetSaltIsBase64");
+
+        byte[] uncryptedMagicBytes = new byte[0];
+        if (keyProviderOptions.hasKey("uncryptedMagicBytes")) {
+            uncryptedMagicBytes = Base64.decode(keyProviderOptions.getString("uncryptedMagicBytes"), Base64.DEFAULT);
+        }
+        int keyRingSize = (int) keyProviderOptions.getInt("keyRingSize");
+        boolean discardFrameWhenCryptorNotReady =
+                (boolean) keyProviderOptions.getBoolean("discardFrameWhenCryptorNotReady");
+        FrameCryptorKeyProvider keyProvider = FrameCryptorFactory.createFrameCryptorKeyProvider(sharedKey,
+                ratchetSalt,
+                ratchetWindowSize,
+                uncryptedMagicBytes,
+                failureTolerance,
+                keyRingSize,
+                discardFrameWhenCryptorNotReady);
+        keyProviders.put(keyProviderId, keyProvider);
+        return keyProviderId;
+    }
+
+    public void keyProviderSetSharedKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderSetKeySharedFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = params.getInt("keyIndex");
+        byte[] key = getBytesFromMap(params, "key", "keyIsBase64");
+        keyProvider.setSharedKey(keyIndex, key);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("result", true);
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderRatchetSharedKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderRatchetSharedKeyFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = params.getInt("keyIndex");
+
+        byte[] newKey = keyProvider.ratchetSharedKey(keyIndex);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", Base64.encodeToString(newKey, Base64.NO_WRAP));
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderExportSharedKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderExportSharedKeyFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = params.getInt("keyIndex");
+
+        byte[] key = keyProvider.exportSharedKey(keyIndex);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", Base64.encodeToString(key, Base64.NO_WRAP));
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderSetKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderSetKeyFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        int keyIndex = params.getInt("keyIndex");
+        String participantId = params.getString("participantId");
+        byte[] key = getBytesFromMap(params, "key", "keyIsBase64");
+        keyProvider.setKey(participantId, keyIndex, key);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("result", true);
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderRatchetKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderSetKeysFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        String participantId = params.getString("participantId");
+        int keyIndex = params.getInt("keyIndex");
+
+        byte[] newKey = keyProvider.ratchetKey(participantId, keyIndex);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", Base64.encodeToString(newKey, Base64.NO_WRAP));
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderExportKey(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderExportKeyFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        String participantId = params.getString("participantId");
+        int keyIndex = params.getInt("keyIndex");
+
+        byte[] key = keyProvider.exportKey(participantId, keyIndex);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", Base64.encodeToString(key, Base64.NO_WRAP));
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderSetSifTrailer(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderSetSifTrailerFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        byte[] sifTrailer = Base64.decode(params.getString("sifTrailer"), Base64.NO_WRAP);
+        keyProvider.setSifTrailer(sifTrailer);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putBoolean("result", true);
+        result.resolve(paramsResult);
+    }
+
+    public void keyProviderDispose(ReadableMap params, @NonNull Promise result) {
+        String keyProviderId = params.getString("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject("keyProviderDisposeFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+        keyProvider.dispose();
+        keyProviders.remove(keyProviderId);
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", "success");
+        result.resolve(paramsResult);
+    }
+
+    public void dataPacketCryptorFactoryCreateDataPacketCryptor(ReadableMap params, @NonNull Promise result) {
+        int algorithm = params.getInt("algorithm");
+        String keyProviderId = params.getString("keyProviderId");
+
+        FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
+        if (keyProvider == null) {
+            result.reject(
+                    "dataPacketCryptorFactoryCreateDataPacketCryptorFailed", "keyProvider not found", (Throwable) null);
+            return;
+        }
+
+        DataPacketCryptorManager cryptor =
+                new DataPacketCryptorManager(frameCryptorAlgorithmFromInt(algorithm), keyProvider);
+
+        String dataPacketCryptorId = UUID.randomUUID().toString();
+        dataPacketCryptors.put(dataPacketCryptorId, cryptor);
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("dataPacketCryptorId", dataPacketCryptorId);
+        result.resolve(paramsResult);
+    }
+
+    public void dataPacketCryptorEncrypt(ReadableMap params, @NonNull Promise result) {
+        String dataPacketCryptorId = params.getString("dataPacketCryptorId");
+        String participantId = params.getString("participantId");
+        int keyIndex = params.getInt("keyIndex");
+        byte[] data = getBytesFromMap(params, "data", null);
+
+        DataPacketCryptorManager cryptor = dataPacketCryptors.get(dataPacketCryptorId);
+
+        if (cryptor == null) {
+            result.reject("dataPacketCryptorEncryptFailed", "data packet cryptor not found", (Throwable) null);
+            return;
+        }
+
+        DataPacketCryptor.EncryptedPacket packet = cryptor.encrypt(participantId, keyIndex, data);
+
+        if (packet == null) {
+            result.reject("dataPacketCryptorEncryptFailed", "null packet", (Throwable) null);
+            return;
+        }
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("payload", Base64.encodeToString(packet.payload, Base64.NO_WRAP));
+        paramsResult.putString("iv", Base64.encodeToString(packet.iv, Base64.NO_WRAP));
+        paramsResult.putInt("keyIndex", packet.keyIndex);
+        result.resolve(paramsResult);
+    }
+
+    public void dataPacketCryptorDecrypt(ReadableMap params, @NonNull Promise result) {
+        String dataPacketCryptorId = params.getString("dataPacketCryptorId");
+        String participantId = params.getString("participantId");
+        int keyIndex = params.getInt("keyIndex");
+        byte[] payload = getBytesFromMap(params, "payload", null);
+        byte[] iv = getBytesFromMap(params, "iv", null);
+
+        DataPacketCryptorManager cryptor = dataPacketCryptors.get(dataPacketCryptorId);
+
+        if (cryptor == null) {
+            result.reject("dataPacketCryptorDecryptFailed", "data packet cryptor not found", (Throwable) null);
+            return;
+        }
+
+        DataPacketCryptor.EncryptedPacket packet = new DataPacketCryptor.EncryptedPacket(payload, iv, keyIndex);
+
+        byte[] decryptedData = cryptor.decrypt(participantId, packet);
+
+        if (decryptedData == null) {
+            result.reject("dataPacketCryptorDecryptFailed", "null decrypted data", (Throwable) null);
+            return;
+        }
+
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("data", Base64.encodeToString(decryptedData, Base64.NO_WRAP));
+        result.resolve(paramsResult);
+    }
+
+    public void dataPacketCryptorDispose(ReadableMap params, @NonNull Promise result) {
+        String dataPacketCryptorId = params.getString("dataPacketCryptorId");
+
+        DataPacketCryptorManager cryptor = dataPacketCryptors.get(dataPacketCryptorId);
+
+        if (cryptor == null) {
+            result.reject("dataPacketCryptorDisposeFailed", "data packet cryptor not found", (Throwable) null);
+            return;
+        }
+
+        cryptor.dispose();
+        dataPacketCryptors.remove(dataPacketCryptorId);
+        WritableMap paramsResult = Arguments.createMap();
+        paramsResult.putString("result", "success");
+
+        result.resolve(paramsResult);
+    }
+
+    private byte[] getBytesFromMap(ReadableMap map, String key, @Nullable String isBase64Key) {
+        boolean isBase64;
+
+        if (isBase64Key != null) {
+            isBase64 = map.getBoolean(isBase64Key);
+        } else {
+            isBase64 = true;
+        }
+
+        byte[] bytes;
+
+        if (isBase64) {
+            bytes = Base64.decode(map.getString(key), Base64.DEFAULT);
+        } else {
+            bytes = Objects.requireNonNull(map.getString(key)).getBytes(StandardCharsets.UTF_8);
+        }
+        return bytes;
+    }
+}

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

@@ -0,0 +1,98 @@
+package com.oney.WebRTCModule;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RTCVideoViewManager extends SimpleViewManager<WebRTCView> {
+    private static final String REACT_CLASS = "RTCVideoView";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public WebRTCView createViewInstance(ThemedReactContext context) {
+        return new WebRTCView(context);
+    }
+
+    /**
+     * Sets the indicator which determines whether a specific {@link WebRTCView}
+     * is to mirror the video specified by {@code streamURL} during its rendering.
+     * For more details, refer to the documentation of the {@code mirror} property
+     * of the JavaScript counterpart of {@code WebRTCView} i.e. {@code RTCView}.
+     *
+     * @param view The {@code WebRTCView} on which the specified {@code mirror} is
+     * to be set.
+     * @param mirror If the specified {@code WebRTCView} is to mirror the video
+     * specified by its associated {@code streamURL} during its rendering,
+     * {@code true}; otherwise, {@code false}.
+     */
+    @ReactProp(name = "mirror")
+    public void setMirror(WebRTCView view, boolean mirror) {
+        view.setMirror(mirror);
+    }
+
+    /**
+     * In the fashion of
+     * https://www.w3.org/TR/html5/embedded-content-0.html#dom-video-videowidth
+     * and https://www.w3.org/TR/html5/rendering.html#video-object-fit, resembles
+     * the CSS style {@code object-fit}.
+     *
+     * @param view The {@code WebRTCView} on which the specified {@code objectFit}
+     * is to be set.
+     * @param objectFit For details, refer to the documentation of the
+     * {@code objectFit} property of the JavaScript counterpart of
+     * {@code WebRTCView} i.e. {@code RTCView}.
+     */
+    @ReactProp(name = "objectFit")
+    public void setObjectFit(WebRTCView view, String objectFit) {
+        view.setObjectFit(objectFit);
+    }
+
+    @ReactProp(name = "streamURL")
+    public void setStreamURL(WebRTCView view, String streamURL) {
+        view.setStreamURL(streamURL);
+    }
+
+    /**
+     * Sets the z-order of a specific {@link WebRTCView} in the stacking space of
+     * all {@code WebRTCView}s. For more details, refer to the documentation of
+     * the {@code zOrder} property of the JavaScript counterpart of
+     * {@code WebRTCView} i.e. {@code RTCView}.
+     *
+     * @param view The {@code WebRTCView} on which the specified {@code zOrder} is
+     * to be set.
+     * @param zOrder The z-order to set on the specified {@code WebRTCView}.
+     */
+    @ReactProp(name = "zOrder")
+    public void setZOrder(WebRTCView view, int zOrder) {
+        view.setZOrder(zOrder);
+    }
+
+    /**
+     * Sets the callback for when video dimensions change.
+     *
+     * @param view The {@code WebRTCView} on which the callback is to be set.
+     * @param onDimensionsChange The callback to be called when video dimensions change.
+     */
+    @ReactProp(name = "onDimensionsChange")
+    public void setOnDimensionsChange(WebRTCView view, boolean onDimensionsChange) {
+        view.setOnDimensionsChange(onDimensionsChange);
+    }
+
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        Map<String, Object> eventTypeConstants = new HashMap<>();
+        Map<String, String> dimensionsChangeEvent = new HashMap<>();
+        dimensionsChangeEvent.put("registrationName", "onDimensionsChange");
+        eventTypeConstants.put("onDimensionsChange", dimensionsChangeEvent);
+        return eventTypeConstants;
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.oney.WebRTCModule;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+public class ReactBridgeUtil {
+    /**
+     * Reads a value from given <tt>ReadableMap</tt> and returns it as
+     * a <tt>String</tt>. Note that integer value is converted to double, before
+     * it gets converted to a string.
+     * @param map the <tt>ReadableMap</tt> from which the value will be obtained
+     * @param key the map's key under which the value has been mapped.
+     * @return a <tt>String</tt> representation of the value if exists or
+     * <tt>null</tt> if there is no value mapped for given <tt>key</tt>.
+     */
+    public static String getMapStrValue(ReadableMap map, String key) {
+        if (!map.hasKey(key)) {
+            return null;
+        }
+        ReadableType type = map.getType(key);
+        switch (type) {
+            case Boolean:
+                return String.valueOf(map.getBoolean(key));
+            case Number:
+                // Don't know how to distinguish between Int and Double from
+                // ReadableType.Number. 'getInt' will fail on double value,
+                // while 'getDouble' works for both.
+                // return String.valueOf(map.getInt(key));
+                return String.valueOf(map.getDouble(key));
+            case String:
+                return map.getString(key);
+            default:
+                return null;
+        }
+    }
+}