@sbhjt-gr/react-native-webrtc 124.0.0

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

@@ -0,0 +1,94 @@
+package com.oney.WebRTCModule;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.media.projection.MediaProjection;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.OrientationEventListener;
+
+import org.webrtc.ScreenCapturerAndroid;
+import org.webrtc.VideoCapturer;
+
+public class ScreenCaptureController extends AbstractVideoCaptureController {
+    /**
+     * The {@link Log} tag with which {@code ScreenCaptureController} is to log.
+     */
+    private static final String TAG = ScreenCaptureController.class.getSimpleName();
+
+    private static final int DEFAULT_FPS = 30;
+
+    private final Intent mediaProjectionPermissionResultData;
+
+    private final OrientationEventListener orientationListener;
+
+    private final Context context;
+
+    public ScreenCaptureController(Context context, int width, int height, Intent mediaProjectionPermissionResultData) {
+        super(width, height, DEFAULT_FPS);
+
+        this.mediaProjectionPermissionResultData = mediaProjectionPermissionResultData;
+
+        this.context = context;
+
+        this.orientationListener = new OrientationEventListener(context) {
+            @Override
+            public void onOrientationChanged(int orientation) {
+                DisplayMetrics displayMetrics = DisplayUtils.getDisplayMetrics((Activity) context);
+                final int width = displayMetrics.widthPixels;
+                final int height = displayMetrics.heightPixels;
+                if (width != ScreenCaptureController.this.actualWidth
+                        || height != ScreenCaptureController.this.actualHeight) {
+                    ScreenCaptureController.this.actualWidth = width;
+                    ScreenCaptureController.this.actualHeight = height;
+
+                    // Pivot to the executor thread because videoCapturer.changeCaptureFormat runs in the main
+                    // thread and may deadlock.
+                    ThreadUtils.runOnExecutor(() -> {
+                        try {
+                            videoCapturer.changeCaptureFormat(width, height, DEFAULT_FPS);
+                        } catch (Exception ex) {
+                            // We ignore exceptions here. The video capturer runs on its own
+                            // thread and we cannot synchronize with it.
+                        }
+                    });
+                }
+            }
+        };
+
+        if (this.orientationListener.canDetectOrientation()) {
+            this.orientationListener.enable();
+        }
+    }
+
+    @Override
+    public String getDeviceId() {
+        return "screen-capture";
+    }
+
+    @Override
+    public void dispose() {
+        MediaProjectionService.abort(context);
+        super.dispose();
+    }
+
+    @Override
+    protected VideoCapturer createVideoCapturer() {
+        VideoCapturer videoCapturer =
+                new ScreenCapturerAndroid(mediaProjectionPermissionResultData, new MediaProjection.Callback() {
+                    @Override
+                    public void onStop() {
+                        Log.w(TAG, "Media projection stopped.");
+                        orientationListener.disable();
+                        stopCapture();
+
+                        if (capturerEventsListener != null) {
+                            capturerEventsListener.onCapturerEnded();
+                        }
+                    }
+                });
+
+        return videoCapturer;
+    }
+}

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

@@ -0,0 +1,342 @@
+package com.oney.WebRTCModule;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class SerializeUtils {
+    /**
+     * Serialization APIs
+     */
+
+    public static ReadableMap serializeVideoCodecInfo(VideoCodecInfo info) {
+        WritableMap params = Arguments.createMap();
+        params.putString("mimeType", "video/" + info.name);
+        return params;
+    }
+
+    public static ReadableMap serializeStream(int pcId, String streamReactTag, MediaStream stream) {
+        WritableMap params = Arguments.createMap();
+        params.putString("streamId", stream.getId());
+        params.putString("streamReactTag", streamReactTag);
+
+        WritableArray tracks = Arguments.createArray();
+
+        for (VideoTrack track : stream.videoTracks) {
+            tracks.pushMap(SerializeUtils.serializeTrack(pcId, track));
+        }
+        for (AudioTrack track : stream.audioTracks) {
+            tracks.pushMap(SerializeUtils.serializeTrack(pcId, track));
+        }
+
+        params.putArray("tracks", tracks);
+
+        return params;
+    }
+
+    public static String serializeDirection(RtpTransceiver.RtpTransceiverDirection src) {
+        switch (src) {
+            case INACTIVE:
+                return "inactive";
+            case RECV_ONLY:
+                return "recvonly";
+            case SEND_ONLY:
+                return "sendonly";
+            case SEND_RECV:
+                return "sendrecv";
+            case STOPPED:
+                return "stopped";
+            default:
+                throw new Error("Invalid direction");
+        }
+    }
+
+    public static ReadableMap serializeTrack(int pcId, MediaStreamTrack track) {
+        WritableMap trackInfo = Arguments.createMap();
+        trackInfo.putString("id", track.id());
+        trackInfo.putInt("peerConnectionId", pcId);
+        trackInfo.putString("kind", track.kind());
+        trackInfo.putBoolean("enabled", track.enabled());
+        trackInfo.putString("readyState", track.state().toString().toLowerCase());
+        trackInfo.putBoolean("remote", true);
+        return trackInfo;
+    }
+
+    /**
+     * This method is currently missing serializing DtmfSender
+     * and transport.
+     * TODO: Add transport and dtmf fields to the serialized sender to match the web APIs.
+     */
+    public static ReadableMap serializeSender(int id, RtpSender sender) {
+        WritableMap res = Arguments.createMap();
+        res.putString("id", sender.id());
+        res.putInt("peerConnectionId", id);
+        if (sender.track() != null) {
+            res.putMap("track", SerializeUtils.serializeTrack(id, sender.track()));
+        }
+        res.putMap("rtpParameters", SerializeUtils.serializeRtpParameters(sender.getParameters()));
+        return res;
+    }
+
+    public static ReadableMap serializeReceiver(int id, RtpReceiver receiver) {
+        WritableMap res = Arguments.createMap();
+        res.putString("id", receiver.id());
+        res.putInt("peerConnectionId", id);
+        if (receiver.track() != null) {
+            res.putMap("track", SerializeUtils.serializeTrack(id, receiver.track()));
+        }
+        res.putMap("rtpParameters", SerializeUtils.serializeRtpParameters(receiver.getParameters()));
+        return res;
+    }
+
+    public static ReadableMap serializeTransceiver(int id, RtpTransceiver transceiver) {
+        WritableMap res = Arguments.createMap();
+        res.putString("id", transceiver.getSender().id());
+        res.putInt("peerConnectionId", id);
+        String mid = transceiver.getMid();
+        res.putString("mid", mid);
+        res.putString("direction", serializeDirection(transceiver.getDirection()));
+        RtpTransceiver.RtpTransceiverDirection currentDirection = transceiver.getCurrentDirection();
+        if (currentDirection != null) {
+            res.putString("currentDirection", SerializeUtils.serializeDirection(transceiver.getCurrentDirection()));
+        }
+        res.putBoolean("isStopped", transceiver.isStopped());
+        res.putMap("receiver", SerializeUtils.serializeReceiver(id, transceiver.getReceiver()));
+        res.putMap("sender", SerializeUtils.serializeSender(id, transceiver.getSender()));
+        return res;
+    }
+
+    public static ReadableMap serializeRtpParameters(RtpParameters params) {
+        WritableMap result = Arguments.createMap();
+        WritableArray encodings = Arguments.createArray();
+        WritableArray codecs = Arguments.createArray();
+        WritableArray headerExtensions = Arguments.createArray();
+        WritableMap rtcp = Arguments.createMap();
+
+        // Preparing RTCP
+        rtcp.putString("cname", params.getRtcp().getCname());
+        rtcp.putBoolean("reducedSize", params.getRtcp().getReducedSize());
+
+        // Preparing header extensions
+        params.getHeaderExtensions().forEach(extension -> {
+            WritableMap extensionMap = Arguments.createMap();
+            extensionMap.putInt("id", extension.getId());
+            extensionMap.putString("uri", extension.getUri());
+            extensionMap.putBoolean("encrypted", extension.getEncrypted());
+            headerExtensions.pushMap(extensionMap);
+        });
+
+        // Preparing encodings
+        params.encodings.forEach(encoding -> {
+            WritableMap encodingMap = Arguments.createMap();
+            encodingMap.putBoolean("active", encoding.active);
+            if (encoding.rid != null) {
+                encodingMap.putString("rid", encoding.rid);
+            }
+            // Since they return integer objects that are nullable,
+            // while the map does not accept nullable integer values.
+            if (encoding.maxBitrateBps != null) {
+                encodingMap.putInt("maxBitrate", encoding.maxBitrateBps);
+            }
+            if (encoding.maxFramerate != null) {
+                encodingMap.putInt("maxFramerate", encoding.maxFramerate);
+            }
+            if (encoding.scaleResolutionDownBy != null) {
+                encodingMap.putDouble("scaleResolutionDownBy", encoding.scaleResolutionDownBy);
+            }
+            encodings.pushMap(encodingMap);
+        });
+
+        // Preparing codecs
+        params.codecs.forEach(codec -> {
+            WritableMap codecMap = Arguments.createMap();
+            codecMap.putInt("payloadType", codec.payloadType);
+            codecMap.putString("mimeType", codec.name);
+            codecMap.putInt("clockRate", codec.clockRate);
+            if (codec.numChannels != null) {
+                codecMap.putInt("channels", codec.numChannels);
+            }
+            // Serializing sdpFmptLine.
+            if (!codec.parameters.isEmpty()) {
+                codecMap.putString("sdpFmtpLine", serializeSdpParameters(codec.parameters));
+            }
+
+            codecs.pushMap(codecMap);
+        });
+
+        result.putString("transactionId", params.transactionId);
+        result.putMap("rtcp", rtcp);
+        result.putArray("encodings", encodings);
+        result.putArray("codecs", codecs);
+        result.putArray("headerExtensions", headerExtensions);
+        if (params.degradationPreference != null) {
+            result.putString("degradationPreference", params.degradationPreference.toString());
+        }
+
+        return result;
+    }
+
+    public static ReadableMap serializeRtpCapabilities(RtpCapabilities capabilities) {
+        WritableMap result = Arguments.createMap();
+        WritableArray codecs = Arguments.createArray();
+
+        capabilities.codecs.forEach(codec -> codecs.pushMap(serializeRtpCapabilitiesCodec(codec)));
+
+        result.putArray("codecs", codecs);
+        return result;
+    }
+
+    public static ReadableMap serializeRtpCapabilitiesCodec(RtpCapabilities.CodecCapability codec) {
+        WritableMap codecMap = Arguments.createMap();
+        codecMap.putInt("payloadType", codec.preferredPayloadType);
+        codecMap.putString("mimeType", codec.mimeType);
+        codecMap.putInt("clockRate", codec.clockRate);
+        if (codec.numChannels != null) {
+            codecMap.putInt("channels", codec.numChannels);
+        }
+        if (!codec.parameters.isEmpty()) {
+            codecMap.putString("sdpFmtpLine", serializeSdpParameters(codec.parameters));
+        }
+
+        return codecMap;
+    }
+
+    // For serializing sdpFmptLine.
+    public static String serializeSdpParameters(Map<String, String> parameters) {
+        return parameters.keySet()
+                .stream()
+                .map(key -> key + "=" + parameters.get(key))
+                .collect(Collectors.joining(";"));
+    }
+
+    /**
+     * Parsing APIs
+     */
+
+    public static RtpParameters updateRtpParameters(ReadableMap updateParams, RtpParameters rtpParams) {
+        // Preparing encodings
+        ReadableArray encodingsArray = updateParams.getArray("encodings");
+        List<RtpParameters.Encoding> encodings = rtpParams.encodings;
+        if (encodingsArray.size() != encodings.size()) {
+            return null;
+        }
+
+        for (int i = 0; i < encodingsArray.size(); i++) {
+            ReadableMap encodingUpdate = encodingsArray.getMap(i);
+            RtpParameters.Encoding encoding = encodings.get(i);
+            // Dealing with nullable Integers
+            Integer maxBitrate = encodingUpdate.hasKey("maxBitrate") ? encodingUpdate.getInt("maxBitrate") : null;
+            Integer maxFramerate = encodingUpdate.hasKey("maxFramerate") ? encodingUpdate.getInt("maxFramerate") : null;
+            Double scaleResolutionDownBy = encodingUpdate.hasKey("scaleResolutionDownBy")
+                    ? encodingUpdate.getDouble("scaleResolutionDownBy")
+                    : null;
+
+            encoding.active = encodingUpdate.getBoolean("active");
+            encoding.rid = encodingUpdate.getString("rid");
+            encoding.maxBitrateBps = maxBitrate;
+            encoding.maxFramerate = maxFramerate;
+            encoding.scaleResolutionDownBy = scaleResolutionDownBy;
+        }
+
+        if (updateParams.hasKey("degradationPreference")) {
+            rtpParams.degradationPreference =
+                    RtpParameters.DegradationPreference.valueOf(updateParams.getString("degradationPreference"));
+        }
+
+        return rtpParams;
+    }
+
+    public static MediaStreamTrack.MediaType parseMediaType(String type) {
+        switch (type) {
+            case "audio":
+                return MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO;
+            case "video":
+                return MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO;
+            default:
+                throw new Error("Unknown media type");
+        }
+    }
+
+    public static RtpTransceiver.RtpTransceiverDirection parseDirection(String src) {
+        switch (src) {
+            case "sendrecv":
+                return RtpTransceiver.RtpTransceiverDirection.SEND_RECV;
+            case "sendonly":
+                return RtpTransceiver.RtpTransceiverDirection.SEND_ONLY;
+            case "recvonly":
+                return RtpTransceiver.RtpTransceiverDirection.RECV_ONLY;
+            case "inactive":
+                return RtpTransceiver.RtpTransceiverDirection.INACTIVE;
+                // Here we ignore the "stopped" direction because user code should
+                // never set it.
+        }
+        throw new Error("Invalid direction");
+    }
+
+    private static RtpParameters.Encoding parseEncoding(ReadableMap params) {
+        RtpParameters.Encoding encoding = new RtpParameters.Encoding(params.getString("rid"), true, 1.0);
+
+        if (params.hasKey("active")) {
+            encoding.active = params.getBoolean("active");
+        }
+        if (params.hasKey("maxBitrate")) {
+            encoding.maxBitrateBps = params.getInt("maxBitrate");
+        }
+        if (params.hasKey("maxFramerate")) {
+            encoding.maxFramerate = params.getInt("maxFramerate");
+        }
+        if (params.hasKey("scaleResolutionDownBy")) {
+            encoding.scaleResolutionDownBy = params.getDouble("scaleResolutionDownBy");
+        }
+
+        return encoding;
+    }
+
+    public static RtpTransceiver.RtpTransceiverInit parseTransceiverOptions(ReadableMap map) {
+        if (map == null) {
+            return null;
+        }
+
+        RtpTransceiver.RtpTransceiverDirection direction = RtpTransceiver.RtpTransceiverDirection.SEND_RECV;
+        List<String> streamIds = new ArrayList<>();
+        List<RtpParameters.Encoding> sendEncodings = new ArrayList<>();
+
+        if (map.hasKey("direction")) {
+            String directionRaw = map.getString("direction");
+            if (directionRaw != null) {
+                direction = SerializeUtils.parseDirection(directionRaw);
+            }
+        }
+        if (map.hasKey("streamIds")) {
+            ReadableArray rawStreamIds = map.getArray("streamIds");
+            if (rawStreamIds != null) {
+                for (int i = 0; i < rawStreamIds.size(); i++) {
+                    streamIds.add(rawStreamIds.getString(i));
+                }
+            }
+        }
+        if (map.hasKey("sendEncodings")) {
+            ReadableArray encodingsArray = map.getArray("sendEncodings");
+            if (encodingsArray != null) {
+                for (int i = 0; i < encodingsArray.size(); i++) {
+                    ReadableMap encoding = encodingsArray.getMap(i);
+                    sendEncodings.add(SerializeUtils.parseEncoding(encoding));
+                }
+            }
+        }
+
+        return new RtpTransceiver.RtpTransceiverInit(direction, streamIds, sendEncodings);
+    }
+}

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

@@ -0,0 +1,101 @@
+package com.oney.WebRTCModule;
+
+import android.util.Log;
+
+import org.webrtc.PeerConnection;
+import org.webrtc.RTCStats;
+import org.webrtc.RTCStatsReport;
+
+import java.util.Map;
+
+public class StringUtils {
+    private static final String TAG = StringUtils.class.getSimpleName();
+
+    /**
+     * Constructs a JSON <tt>String</tt> representation of a specific array of
+     * <tt>RTCStatsReport</tt>s (produced by {@link PeerConnection#getStats}).
+     * <p>
+     * @param report the <tt>RTCStatsReport</tt>s to represent in JSON
+     *               format
+     * @return a <tt>String</tt> which represents the specified <tt>report</tt>
+     * in JSON format
+     */
+    public static String statsToJSON(RTCStatsReport report) {
+        StringBuilder builder = new StringBuilder("[");
+
+        boolean firstKey = true;
+
+        Map<String, RTCStats> statsMap = report.getStatsMap();
+
+        for (String key : report.getStatsMap().keySet()) {
+            if (firstKey) {
+                firstKey = false;
+            } else {
+                builder.append(",");
+            }
+
+            builder.append("[\"").append(key).append("\",{");
+
+            RTCStats stats = statsMap.get(key);
+            builder.append("\"timestamp\":")
+                    .append(stats.getTimestampUs() / 1000.0)
+                    .append(",\"type\":\"")
+                    .append(stats.getType())
+                    .append("\",\"id\":\"")
+                    .append(stats.getId())
+                    .append("\"");
+
+            for (Map.Entry<String, Object> entry : stats.getMembers().entrySet()) {
+                builder.append(",").append("\"").append(entry.getKey()).append("\":");
+                appendValue(builder, entry.getValue());
+            }
+
+            builder.append("}]");
+        }
+
+        builder.append("]");
+
+        return builder.toString();
+    }
+
+    private static void appendValue(StringBuilder builder, Object value) {
+        if (value instanceof Object[]) {
+            Object[] arrayValue = (Object[]) value;
+            builder.append("[");
+
+            for (int i = 0; i < arrayValue.length; ++i) {
+                if (i != 0) {
+                    builder.append(",");
+                }
+
+                appendValue(builder, arrayValue[i]);
+            }
+
+            builder.append("]");
+        } else if (value instanceof Map) {
+            try {
+                Map<String, Object> mapValue = (Map) value;
+
+                boolean firstKey = true;
+                builder.append("{");
+
+                for (Map.Entry<String, Object> entry : mapValue.entrySet()) {
+                    if (firstKey) {
+                        firstKey = false;
+                    } else {
+                        builder.append(",");
+                    }
+                    builder.append("\"").append(entry.getKey()).append("\":");
+                    appendValue(builder, entry.getValue());
+                }
+                builder.append("}");
+            } catch (ClassCastException e) {
+                Log.e(TAG, "Error parsing stats value " + value);
+            }
+        } else if (value instanceof String) {
+            builder.append("\"").append(value).append("\"");
+        } else {
+            builder.append(value);
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.oney.WebRTCModule;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+final class ThreadUtils {
+    /**
+     * Thread which will be used to call all WebRTC PeerConnection APIs. They
+     * they don't run on the calling thread anyway, we are deferring the calls
+     * to this thread to avoid (potentially) blocking the calling thread.
+     */
+    private static final ExecutorService executor = Executors.newSingleThreadExecutor();
+
+    /**
+     * Runs the given {@link Runnable} on the executor.
+     * @param runnable
+     */
+    public static void runOnExecutor(Runnable runnable) {
+        executor.execute(runnable);
+    }
+
+    /**
+     * Submits the given {@link Callable} to be run on the executor.
+     * @param callable
+     * @return Future.
+     */
+    public static <T> Future<T> submitToExecutor(Callable<T> callable) {
+        return executor.submit(callable);
+    }
+
+    /**
+     * Submits the given {@link Runnable} to be run on the executor.
+     * @param runnable
+     * @return Future.
+     */
+    public static Future<?> submitToExecutor(Runnable runnable) {
+        return executor.submit(runnable);
+    }
+}

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

@@ -0,0 +1,34 @@
+package com.oney.WebRTCModule;
+
+import android.util.*;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import org.webrtc.CapturerObserver;
+import org.webrtc.VideoFrame;
+
+/**
+ * A capturer observer that emits track ended events when the capturer is stopped.
+ */
+public class TrackCapturerEventsEmitter implements AbstractVideoCaptureController.CapturerEventsListener {
+    private static final String TAG = TrackCapturerEventsEmitter.class.getCanonicalName();
+
+    private final WebRTCModule webRTCModule;
+    private final String trackId;
+
+    public TrackCapturerEventsEmitter(WebRTCModule webRTCModule, String trackId) {
+        this.webRTCModule = webRTCModule;
+        this.trackId = trackId;
+    }
+
+    /** Notify that the capturer has been stopped. */
+    public void onCapturerEnded() {
+        WritableMap params = Arguments.createMap();
+        params.putString("trackId", trackId);
+
+        Log.d(TAG, "ended event trackId: " + trackId);
+
+        webRTCModule.sendEvent("mediaStreamTrackEnded", params);
+    }
+}