package com.oney.WebRTCModule; import android.os.Build; import android.util.Log; import android.util.Pair; import android.util.SparseArray; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import com.facebook.react.bridge.Arguments; import com.facebook.react.bridge.Callback; import com.facebook.react.bridge.Promise; import com.facebook.react.bridge.ReactApplicationContext; import com.facebook.react.bridge.ReactContextBaseJavaModule; import com.facebook.react.bridge.ReactMethod; 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 com.facebook.react.module.annotations.ReactModule; import com.facebook.react.modules.core.DeviceEventManagerModule; import com.oney.WebRTCModule.webrtcutils.SelectiveVideoDecoderFactory; import org.webrtc.*; import org.webrtc.audio.AudioDeviceModule; import org.webrtc.audio.JavaAudioDeviceModule; import java.io.ByteArrayInputStream; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; @ReactModule(name = "WebRTCModule") public class WebRTCModule extends ReactContextBaseJavaModule { static final String TAG = WebRTCModule.class.getCanonicalName(); PeerConnectionFactory mFactory; VideoEncoderFactory mVideoEncoderFactory; VideoDecoderFactory mVideoDecoderFactory; AudioDeviceModule mAudioDeviceModule; // Need to expose the peer connection codec factories here to get capabilities private final SparseArray mPeerConnectionObservers; final Map localStreams; // Store generated certificates by ID to avoid exposing private keys to JS private static final Map mCertificates = new HashMap<>(); private final GetUserMediaImpl getUserMediaImpl; private SpeechActivityDetector speechActivityDetector; public WebRTCModule(ReactApplicationContext reactContext) { super(reactContext); mPeerConnectionObservers = new SparseArray<>(); localStreams = new HashMap<>(); WebRTCModuleOptions options = WebRTCModuleOptions.getInstance(); AudioDeviceModule adm = options.audioDeviceModule; VideoEncoderFactory encoderFactory = options.videoEncoderFactory; VideoDecoderFactory decoderFactory = options.videoDecoderFactory; Loggable injectableLogger = options.injectableLogger; Logging.Severity loggingSeverity = options.loggingSeverity; String fieldTrials = options.fieldTrials; PeerConnectionFactory.initialize(PeerConnectionFactory.InitializationOptions .builder(reactContext) .setFieldTrials(fieldTrials) .setNativeLibraryLoader(new LibraryLoader()) .setInjectableLogger(injectableLogger, loggingSeverity) .createInitializationOptions()); if (injectableLogger == null && loggingSeverity != null) { Logging.enableLogToDebugOutput(loggingSeverity); } if (encoderFactory == null || decoderFactory == null) { // Initialize EGL context required for HW acceleration. EglBase.Context eglContext = EglUtils.getRootEglBaseContext(); encoderFactory = new SimulcastAlignedVideoEncoderFactory( eglContext, true, true, ResolutionAdjustment.MULTIPLE_OF_16); decoderFactory = new SelectiveVideoDecoderFactory(eglContext, false, Arrays.asList("VP9", "AV1")); } if (adm == null) { adm = createAudioDeviceModule(reactContext); } AudioProcessingFactory audioProcessingFactory = null; try { if (options.audioProcessingFactoryProvider != null) { audioProcessingFactory = options.audioProcessingFactoryProvider.getFactory(); } else if (options.audioProcessingFactoryFactory != null) { audioProcessingFactory = options.audioProcessingFactoryFactory.call(); } } catch (Exception e) { // do nothing. } Log.d(TAG, "Using video encoder factory: " + encoderFactory.getClass().getCanonicalName()); Log.d(TAG, "Using video decoder factory: " + decoderFactory.getClass().getCanonicalName()); PeerConnectionFactory.Builder pcFactoryBuilder = PeerConnectionFactory.builder() .setAudioDeviceModule(adm) .setVideoEncoderFactory(encoderFactory) .setVideoDecoderFactory(decoderFactory); if (audioProcessingFactory != null) { pcFactoryBuilder.setAudioProcessingFactory(audioProcessingFactory); } mFactory = pcFactoryBuilder.createPeerConnectionFactory(); // PeerConnectionFactory now owns the adm native pointer, and we don't need it anymore. adm.release(); // Saving the encoder and decoder factories to get codec info later when needed. mVideoEncoderFactory = encoderFactory; mVideoDecoderFactory = decoderFactory; mAudioDeviceModule = adm; getUserMediaImpl = new GetUserMediaImpl(this, reactContext); } @Override public void invalidate() { Log.d(TAG, "invalidate()"); try { ThreadUtils .submitToExecutor(() -> { // 1. Dispose PeerConnections (dispose() calls close() internally) for (int i = 0; i < mPeerConnectionObservers.size(); i++) { try { mPeerConnectionObservers.valueAt(i).dispose(); } catch (Exception e) { Log.w(TAG, "invalidate(): error disposing PC " + mPeerConnectionObservers.keyAt(i), e); } } mPeerConnectionObservers.clear(); // 2. Detach tracks, then dispose streams. Tracks themselves get disposed in step 3. for (Map.Entry entry : localStreams.entrySet()) { try { MediaStream stream = entry.getValue(); for (AudioTrack t : new ArrayList<>(stream.audioTracks)) stream.removeTrack(t); for (VideoTrack t : new ArrayList<>(stream.videoTracks)) stream.removeTrack(t); stream.dispose(); } catch (Exception e) { Log.w(TAG, "invalidate(): error disposing stream " + entry.getKey(), e); } } localStreams.clear(); // 3. Stop capturers + dispose tracks (prevents use-after-free on factory threads) getUserMediaImpl.disposeAllTracks(); // 4. Dispose factory (frees C++ factory + 3 threads) if (mFactory != null) { mFactory.dispose(); mFactory = null; } return null; }) .get(); } catch (InterruptedException | ExecutionException e) { Log.e(TAG, "invalidate() error", e); } super.invalidate(); } private JavaAudioDeviceModule createAudioDeviceModule(ReactApplicationContext reactContext) { speechActivityDetector = new SpeechActivityDetector(new SpeechActivityDetector.Listener() { @Override public void onSpeechStarted() { WritableMap params = Arguments.createMap(); params.putString("event", "started"); sendEvent("audioDeviceModuleSpeechActivity", params); } @Override public void onSpeechEnded() { WritableMap params = Arguments.createMap(); params.putString("event", "ended"); sendEvent("audioDeviceModuleSpeechActivity", params); } }); return JavaAudioDeviceModule.builder(reactContext) .setUseHardwareAcousticEchoCanceler(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) .setUseHardwareNoiseSuppressor(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) .setUseStereoOutput(true) .setAudioBufferCallback( (audioBuffer, audioFormat, channelCount, sampleRate, bytesRead, captureTimeNs) -> { // 1. Speech activity detection on raw mic data, BEFORE any mutation. speechActivityDetector.processBuffer(audioBuffer, bytesRead); // 2. Existing screen-audio mixing — mutates audioBuffer in place. if (bytesRead > 0) { WebRTCModuleOptions.ScreenAudioBytesProvider provider = WebRTCModuleOptions.getInstance().screenAudioBytesProvider; if (provider != null) { java.nio.ByteBuffer screenBuffer = provider.getScreenAudioBytes(bytesRead); if (screenBuffer != null && screenBuffer.remaining() > 0) { mixScreenAudioIntoBuffer(audioBuffer, screenBuffer, bytesRead); } } } return captureTimeNs; }) .setAudioRecordStateCallback(new JavaAudioDeviceModule.AudioRecordStateCallback() { @Override public void onWebRtcAudioRecordStart() { speechActivityDetector.reset(); } @Override public void onWebRtcAudioRecordStop() { speechActivityDetector.onRecordStop(); } }) .createAudioDeviceModule(); } /** * Mixes screen audio into the microphone buffer using PCM 16-bit additive mixing * with clamping. Handles different buffer sizes safely: each buffer is read only * within its own bounds. When one buffer is shorter, the other's samples pass * through unmodified (mic samples stay as-is, or screen-only samples are written). */ private static void mixScreenAudioIntoBuffer( java.nio.ByteBuffer micBuffer, java.nio.ByteBuffer screenBuffer, int bytesRead) { micBuffer.position(0); screenBuffer.position(0); micBuffer.order(java.nio.ByteOrder.LITTLE_ENDIAN); screenBuffer.order(java.nio.ByteOrder.LITTLE_ENDIAN); java.nio.ShortBuffer micShorts = micBuffer.asShortBuffer(); java.nio.ShortBuffer screenShorts = screenBuffer.asShortBuffer(); int micSamples = Math.min(bytesRead / 2, micShorts.remaining()); int screenSamples = screenShorts.remaining(); int totalSamples = Math.max(micSamples, screenSamples); for (int i = 0; i < totalSamples; i++) { int sum; if (i >= micSamples) { // Screen-only: mic buffer is shorter — write screen sample directly sum = screenShorts.get(i); } else if (i >= screenSamples) { // Mic-only: screen buffer is shorter — keep mic sample as-is break; } else { // Both buffers have data — add samples sum = micShorts.get(i) + screenShorts.get(i); } if (sum > Short.MAX_VALUE) sum = Short.MAX_VALUE; if (sum < Short.MIN_VALUE) sum = Short.MIN_VALUE; micShorts.put(i, (short) sum); } } @NonNull @Override public String getName() { return "WebRTCModule"; } public AudioDeviceModule getAudioDeviceModule() { return mAudioDeviceModule; } public GetUserMediaImpl getUserMediaImpl() { return getUserMediaImpl; } public PeerConnectionObserver getPeerConnectionObserver(int id) { return mPeerConnectionObservers.get(id); } private PeerConnection getPeerConnection(int id) { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); return (pco == null) ? null : pco.getPeerConnection(); } void sendEvent(String eventName, @Nullable ReadableMap params) { if (getReactApplicationContext().hasActiveReactInstance()) { getReactApplicationContext() .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class) .emit(eventName, params); } } private PeerConnection.IceServer createIceServer(String url) { return PeerConnection.IceServer.builder(url).createIceServer(); } private PeerConnection.IceServer createIceServer(String url, String username, String credential) { return PeerConnection.IceServer.builder(url).setUsername(username).setPassword(credential).createIceServer(); } private List createIceServers(ReadableArray iceServersArray) { final int size = (iceServersArray == null) ? 0 : iceServersArray.size(); List iceServers = new ArrayList<>(size); for (int i = 0; i < size; i++) { ReadableMap iceServerMap = iceServersArray.getMap(i); boolean hasUsernameAndCredential = iceServerMap.hasKey("username") && iceServerMap.hasKey("credential"); if (iceServerMap.hasKey("urls")) { switch (iceServerMap.getType("urls")) { case String: if (hasUsernameAndCredential) { iceServers.add(createIceServer(iceServerMap.getString("urls"), iceServerMap.getString("username"), iceServerMap.getString("credential"))); } else { iceServers.add(createIceServer(iceServerMap.getString("urls"))); } break; case Array: ReadableArray urls = iceServerMap.getArray("urls"); for (int j = 0; j < urls.size(); j++) { String url = urls.getString(j); if (hasUsernameAndCredential) { iceServers.add(createIceServer( url, iceServerMap.getString("username"), iceServerMap.getString("credential"))); } else { iceServers.add(createIceServer(url)); } } break; } } } return iceServers; } private PeerConnection.RTCConfiguration parseRTCConfiguration(ReadableMap map) { ReadableArray iceServersArray = null; if (map != null && map.hasKey("iceServers")) { iceServersArray = map.getArray("iceServers"); } List iceServers = createIceServers(iceServersArray); PeerConnection.RTCConfiguration conf = new PeerConnection.RTCConfiguration(iceServers); conf.sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN; // Required for perfect negotiation. conf.enableImplicitRollback = true; // Enable GCM ciphers. CryptoOptions cryptoOptions = CryptoOptions.builder() .setEnableGcmCryptoSuites(true) .setEnableAes128Sha1_32CryptoCipher(false) .setEnableEncryptedRtpHeaderExtensions(false) .setRequireFrameEncryption(false) .createCryptoOptions(); conf.cryptoOptions = cryptoOptions; if (map == null) { return conf; } // iceTransportPolicy (public api) if (map.hasKey("iceTransportPolicy") && map.getType("iceTransportPolicy") == ReadableType.String) { final String v = map.getString("iceTransportPolicy"); if (v != null) { switch (v) { case "all": // public conf.iceTransportsType = PeerConnection.IceTransportsType.ALL; break; case "relay": // public conf.iceTransportsType = PeerConnection.IceTransportsType.RELAY; break; case "nohost": conf.iceTransportsType = PeerConnection.IceTransportsType.NOHOST; break; case "none": conf.iceTransportsType = PeerConnection.IceTransportsType.NONE; break; } } } // bundlePolicy (public api) if (map.hasKey("bundlePolicy") && map.getType("bundlePolicy") == ReadableType.String) { final String v = map.getString("bundlePolicy"); if (v != null) { switch (v) { case "balanced": // public conf.bundlePolicy = PeerConnection.BundlePolicy.BALANCED; break; case "max-compat": // public conf.bundlePolicy = PeerConnection.BundlePolicy.MAXCOMPAT; break; case "max-bundle": // public conf.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE; break; } } } // rtcpMuxPolicy (public api) if (map.hasKey("rtcpMuxPolicy") && map.getType("rtcpMuxPolicy") == ReadableType.String) { final String v = map.getString("rtcpMuxPolicy"); if (v != null) { switch (v) { case "negotiate": // public conf.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.NEGOTIATE; break; case "require": // public conf.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE; break; } } } // FIXME: peerIdentity of type DOMString (public api) // certificates (public api) if (map.hasKey("certificates") && map.getType("certificates") == ReadableType.Array) { ReadableArray certificates = map.getArray("certificates"); if (certificates.size() > 0) { ReadableMap certMap = certificates.getMap(0); if (certMap.hasKey("certificateId")) { String certId = certMap.getString("certificateId"); RtcCertificatePem cert; synchronized (mCertificates) { cert = mCertificates.get(certId); } if (cert != null) { conf.certificate = cert; } } } } // iceCandidatePoolSize of type unsigned short, defaulting to 0 if (map.hasKey("iceCandidatePoolSize") && map.getType("iceCandidatePoolSize") == ReadableType.Number) { final int v = map.getInt("iceCandidatePoolSize"); if (v > 0) { conf.iceCandidatePoolSize = v; } } // === below is private api in webrtc === // tcpCandidatePolicy (private api) if (map.hasKey("tcpCandidatePolicy") && map.getType("tcpCandidatePolicy") == ReadableType.String) { final String v = map.getString("tcpCandidatePolicy"); if (v != null) { switch (v) { case "enabled": conf.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.ENABLED; break; case "disabled": conf.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED; break; } } } // candidateNetworkPolicy (private api) if (map.hasKey("candidateNetworkPolicy") && map.getType("candidateNetworkPolicy") == ReadableType.String) { final String v = map.getString("candidateNetworkPolicy"); if (v != null) { switch (v) { case "all": conf.candidateNetworkPolicy = PeerConnection.CandidateNetworkPolicy.ALL; break; case "low_cost": conf.candidateNetworkPolicy = PeerConnection.CandidateNetworkPolicy.LOW_COST; break; } } } // KeyType (private api) if (map.hasKey("keyType") && map.getType("keyType") == ReadableType.String) { final String v = map.getString("keyType"); if (v != null) { switch (v) { case "RSA": conf.keyType = PeerConnection.KeyType.RSA; break; case "ECDSA": conf.keyType = PeerConnection.KeyType.ECDSA; break; } } } // continualGatheringPolicy (private api) if (map.hasKey("continualGatheringPolicy") && map.getType("continualGatheringPolicy") == ReadableType.String) { final String v = map.getString("continualGatheringPolicy"); if (v != null) { switch (v) { case "gather_once": conf.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_ONCE; break; case "gather_continually": conf.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY; break; } } } // audioJitterBufferMaxPackets (private api) if (map.hasKey("audioJitterBufferMaxPackets") && map.getType("audioJitterBufferMaxPackets") == ReadableType.Number) { final int v = map.getInt("audioJitterBufferMaxPackets"); if (v > 0) { conf.audioJitterBufferMaxPackets = v; } } // iceConnectionReceivingTimeout (private api) if (map.hasKey("iceConnectionReceivingTimeout") && map.getType("iceConnectionReceivingTimeout") == ReadableType.Number) { final int v = map.getInt("iceConnectionReceivingTimeout"); conf.iceConnectionReceivingTimeout = v; } // iceBackupCandidatePairPingInterval (private api) if (map.hasKey("iceBackupCandidatePairPingInterval") && map.getType("iceBackupCandidatePairPingInterval") == ReadableType.Number) { final int v = map.getInt("iceBackupCandidatePairPingInterval"); conf.iceBackupCandidatePairPingInterval = v; } // audioJitterBufferFastAccelerate (private api) if (map.hasKey("audioJitterBufferFastAccelerate") && map.getType("audioJitterBufferFastAccelerate") == ReadableType.Boolean) { final boolean v = map.getBoolean("audioJitterBufferFastAccelerate"); conf.audioJitterBufferFastAccelerate = v; } // pruneTurnPorts (private api) if (map.hasKey("pruneTurnPorts") && map.getType("pruneTurnPorts") == ReadableType.Boolean) { final boolean v = map.getBoolean("pruneTurnPorts"); conf.pruneTurnPorts = v; } // presumeWritableWhenFullyRelayed (private api) if (map.hasKey("presumeWritableWhenFullyRelayed") && map.getType("presumeWritableWhenFullyRelayed") == ReadableType.Boolean) { final boolean v = map.getBoolean("presumeWritableWhenFullyRelayed"); conf.presumeWritableWhenFullyRelayed = v; } return conf; } @ReactMethod(isBlockingSynchronousMethod = true) public boolean peerConnectionInit(ReadableMap configuration, int id) { PeerConnection.RTCConfiguration rtcConfiguration = parseRTCConfiguration(configuration); try { return (boolean) ThreadUtils .submitToExecutor(() -> { PeerConnectionObserver observer = new PeerConnectionObserver(this, id); PeerConnection peerConnection = mFactory.createPeerConnection(rtcConfiguration, observer); if (peerConnection == null) { return false; } observer.setPeerConnection(peerConnection); mPeerConnectionObservers.put(id, observer); return true; }) .get(); } catch (ExecutionException | InterruptedException e) { e.printStackTrace(); throw new RuntimeException(e); } } // Must be called in the executor. public MediaStream getStreamForReactTag(String streamReactTag) { MediaStream stream = localStreams.get(streamReactTag); if (stream != null) { return stream; } for (int i = 0, size = mPeerConnectionObservers.size(); i < size; i++) { PeerConnectionObserver pco = mPeerConnectionObservers.valueAt(i); stream = pco.remoteStreams.get(streamReactTag); if (stream != null) { return stream; } } return null; } public MediaStreamTrack getTrack(int pcId, String trackId) { if (pcId == -1) { return getLocalTrack(trackId); } PeerConnectionObserver pco = mPeerConnectionObservers.get(pcId); if (pco == null) { Log.d(TAG, "getTrack(): could not find PeerConnection"); return null; } return pco.remoteTracks.get(trackId); } MediaStreamTrack getLocalTrack(String trackId) { return getUserMediaImpl.getTrack(trackId); } public VideoTrack createVideoTrack(AbstractVideoCaptureController videoCaptureController) { return getUserMediaImpl.createVideoTrack(videoCaptureController); } public void registerTrack(AudioTrack track, AudioSource source) { getUserMediaImpl.registerTrack(track, source); } public void registerTrack(VideoTrack track, VideoSource source, AbstractVideoCaptureController controller, SurfaceTextureHelper surfaceTextureHelper) { getUserMediaImpl.registerTrack(track, source, controller, surfaceTextureHelper); } public void createStream( MediaStreamTrack[] tracks, GetUserMediaImpl.BiConsumer> successCallback) { getUserMediaImpl.createStream(tracks, successCallback); } /** * Turns an "options" ReadableMap into a MediaConstraints object. * * @param options A ReadableMap which represents a JavaScript * object specifying the options to be parsed into a * MediaConstraints instance. * @return A new MediaConstraints instance initialized with the * mandatory keys and values specified by options. */ MediaConstraints constraintsForOptions(ReadableMap options) { MediaConstraints mediaConstraints = new MediaConstraints(); ReadableMapKeySetIterator keyIterator = options.keySetIterator(); while (keyIterator.hasNextKey()) { String key = keyIterator.nextKey(); String value = ReactBridgeUtil.getMapStrValue(options, key); mediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(key, value)); } return mediaConstraints; } @ReactMethod(isBlockingSynchronousMethod = true) public WritableMap peerConnectionAddTransceiver(int id, ReadableMap options) { try { return (WritableMap) ThreadUtils .submitToExecutor((Callable) () -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "peerConnectionAddTransceiver() peerConnection is null"); return null; } RtpTransceiver transceiver = null; if (options.hasKey("type")) { String kind = options.getString("type"); transceiver = pco.addTransceiver(SerializeUtils.parseMediaType(kind), SerializeUtils.parseTransceiverOptions(options.getMap("init"))); } else if (options.hasKey("trackId")) { String trackId = options.getString("trackId"); MediaStreamTrack track = getLocalTrack(trackId); transceiver = pco.addTransceiver( track, SerializeUtils.parseTransceiverOptions(options.getMap("init"))); // Add mute detection for local video tracks (dimension detection is handled at track // creation) if (track instanceof VideoTrack) { pco.videoTrackAdapters.addAdapter((VideoTrack) track); } } else { // This should technically never happen as the JS side checks for that. Log.d(TAG, "peerConnectionAddTransceiver() no type nor trackId provided in options"); return null; } if (transceiver == null) { Log.d(TAG, "peerConnectionAddTransceiver() Error adding transceiver"); return null; } WritableMap params = Arguments.createMap(); // We need to get a unique order at which the transceiver was created // to reorder the cached array of transceivers on the JS layer. params.putInt("transceiverOrder", pco.getNextTransceiverId()); params.putMap("transceiver", SerializeUtils.serializeTransceiver(id, transceiver)); return params; }) .get(); } catch (InterruptedException | ExecutionException e) { Log.d(TAG, "peerConnectionAddTransceiver() " + e.getMessage()); return null; } } @ReactMethod(isBlockingSynchronousMethod = true) public WritableMap peerConnectionAddTrack(int id, String trackId, ReadableMap options) { try { return (WritableMap) ThreadUtils .submitToExecutor((Callable) () -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "peerConnectionAddTrack() peerConnection is null"); return null; } MediaStreamTrack track = getLocalTrack(trackId); if (track == null) { Log.w(TAG, "peerConnectionAddTrack() couldn't find track " + trackId); return null; } List streamIds = new ArrayList<>(); if (options.hasKey("streamIds")) { ReadableArray rawStreamIds = options.getArray("streamIds"); if (rawStreamIds != null) { for (int i = 0; i < rawStreamIds.size(); i++) { streamIds.add(rawStreamIds.getString(i)); } } } RtpSender sender = pco.getPeerConnection().addTrack(track, streamIds); // Add mute detection for local video tracks (dimension detection is handled at track creation) if (track instanceof VideoTrack) { pco.videoTrackAdapters.addAdapter((VideoTrack) track); } // Need to get the corresponding transceiver as well RtpTransceiver transceiver = pco.getTransceiver(sender.id()); // We need the transceiver creation order to reorder the transceivers array // in the JS layer. WritableMap params = Arguments.createMap(); params.putInt("transceiverOrder", pco.getNextTransceiverId()); params.putMap("transceiver", SerializeUtils.serializeTransceiver(id, transceiver)); params.putMap("sender", SerializeUtils.serializeSender(id, sender)); return params; }) .get(); } catch (InterruptedException | ExecutionException e) { Log.d(TAG, "peerConnectionAddTrack() " + e.getMessage()); return null; } } @ReactMethod(isBlockingSynchronousMethod = true) public boolean peerConnectionRemoveTrack(int id, String senderId) { try { return (boolean) ThreadUtils .submitToExecutor((Callable) () -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "peerConnectionRemoveTrack() peerConnection is null"); return false; } RtpSender sender = pco.getSender(senderId); if (sender == null) { Log.w(TAG, "peerConnectionRemoveTrack() sender is null"); return false; } // Remove video track adapters for local tracks MediaStreamTrack track = sender.track(); if (track instanceof VideoTrack) { pco.videoTrackAdapters.removeAdapter((VideoTrack) track); // Note: dimension detection for local tracks is cleaned up when track is disposed } return pco.getPeerConnection().removeTrack(sender); }) .get(); } catch (InterruptedException | ExecutionException e) { Log.d(TAG, "peerConnectionRemoveTrack() " + e.getMessage()); return false; } } @ReactMethod public void senderSetParameters(int id, String senderId, ReadableMap options, Promise promise) { ThreadUtils.runOnExecutor(() -> { try { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "senderSetParameters() peerConnectionObserver is null"); promise.reject(new Exception("Peer Connection is not initialized")); return; } RtpSender sender = pco.getSender(senderId); if (sender == null) { Log.w(TAG, "senderSetParameters() sender is null"); promise.reject(new Exception("Could not get sender")); return; } RtpParameters params = sender.getParameters(); params = SerializeUtils.updateRtpParameters(options, params); sender.setParameters(params); promise.resolve(SerializeUtils.serializeRtpParameters(sender.getParameters())); } catch (Exception e) { Log.d(TAG, "senderSetParameters: " + e.getMessage()); promise.reject(e); } }); } @ReactMethod public void transceiverStop(int id, String senderId, Promise promise) { ThreadUtils.runOnExecutor(() -> { try { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "transceiverStop() peerConnectionObserver is null"); promise.reject(new Exception("Peer Connection is not initialized")); return; } RtpTransceiver transceiver = pco.getTransceiver(senderId); if (transceiver == null) { Log.w(TAG, "transceiverStop() transceiver is null"); promise.reject(new Exception("Could not get transceiver")); return; } transceiver.stopStandard(); promise.resolve(true); } catch (Exception e) { Log.d(TAG, "transceiverStop(): " + e.getMessage()); promise.reject(e); } }); } @ReactMethod public void senderReplaceTrack(int id, String senderId, String trackId, Promise promise) { ThreadUtils.runOnExecutor(() -> { try { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "senderReplaceTrack() peerConnectionObserver is null"); promise.reject(new Exception("Peer Connection is not initialized")); return; } RtpSender sender = pco.getSender(senderId); if (sender == null) { Log.w(TAG, "senderReplaceTrack() sender is null"); promise.reject(new Exception("Could not get sender")); return; } MediaStreamTrack track = getLocalTrack(trackId); sender.setTrack(track, false); promise.resolve(true); } catch (Exception e) { Log.d(TAG, "senderReplaceTrack(): " + e.getMessage()); promise.reject(e); } }); } @ReactMethod public void transceiverSetDirection(int id, String senderId, String direction, Promise promise) { ThreadUtils.runOnExecutor(() -> { WritableMap identifier = Arguments.createMap(); WritableMap params = Arguments.createMap(); identifier.putInt("peerConnectionId", id); identifier.putString("transceiverId", senderId); try { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "transceiverSetDirection() peerConnectionObserver is null"); promise.reject(new Exception("Peer Connection is not initialized")); return; } RtpTransceiver transceiver = pco.getTransceiver(senderId); if (transceiver == null) { Log.d(TAG, "transceiverSetDirection() transceiver is null"); promise.reject(new Exception("Could not get sender")); return; } transceiver.setDirection(SerializeUtils.parseDirection(direction)); promise.resolve(true); } catch (Exception e) { Log.d(TAG, "transceiverSetDirection(): " + e.getMessage()); promise.reject(e); } }); } @ReactMethod(isBlockingSynchronousMethod = true) public boolean transceiverSetCodecPreferences(int id, String senderId, ReadableArray codecPreferences) { ThreadUtils.runOnExecutor(() -> { WritableMap identifier = Arguments.createMap(); WritableMap params = Arguments.createMap(); identifier.putInt("peerConnectionId", id); identifier.putString("transceiverId", senderId); try { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null) { Log.d(TAG, "transceiverSetDirection() peerConnectionObserver is null"); return; } RtpTransceiver transceiver = pco.getTransceiver(senderId); if (transceiver == null) { Log.d(TAG, "transceiverSetDirection() transceiver is null"); return; } // Convert JSON codec capabilities to the actual objects. RtpTransceiver.RtpTransceiverDirection direction = transceiver.getDirection(); List, RtpCapabilities.CodecCapability>> availableCodecs = new ArrayList<>(); if (direction.equals(RtpTransceiver.RtpTransceiverDirection.SEND_RECV) || direction.equals(RtpTransceiver.RtpTransceiverDirection.SEND_ONLY)) { RtpCapabilities capabilities = mFactory.getRtpSenderCapabilities(transceiver.getMediaType()); for (RtpCapabilities.CodecCapability codec : capabilities.codecs) { Map codecDict = SerializeUtils.serializeRtpCapabilitiesCodec(codec).toHashMap(); availableCodecs.add(new Pair<>(codecDict, codec)); } } if (direction.equals(RtpTransceiver.RtpTransceiverDirection.SEND_RECV) || direction.equals(RtpTransceiver.RtpTransceiverDirection.RECV_ONLY)) { RtpCapabilities capabilities = mFactory.getRtpReceiverCapabilities(transceiver.getMediaType()); for (RtpCapabilities.CodecCapability codec : capabilities.codecs) { Map codecDict = SerializeUtils.serializeRtpCapabilitiesCodec(codec).toHashMap(); availableCodecs.add(new Pair<>(codecDict, codec)); } } // Codec preferences is order sensitive. List codecsToSet = new ArrayList<>(); for (int i = 0; i < codecPreferences.size(); i++) { Map codecPref = codecPreferences.getMap(i).toHashMap(); for (Pair, RtpCapabilities.CodecCapability> pair : availableCodecs) { Map availableCodecDict = pair.first; if (codecPref.equals(availableCodecDict)) { codecsToSet.add(pair.second); break; } } } transceiver.setCodecPreferences(codecsToSet); } catch (Exception e) { Log.d(TAG, "transceiverSetCodecPreferences(): " + e.getMessage()); } }); return true; } @ReactMethod public void getDisplayMedia(ReadableMap constraints, Promise promise) { ThreadUtils.runOnExecutor(() -> getUserMediaImpl.getDisplayMedia(constraints, promise)); } @ReactMethod public void getUserMedia(ReadableMap constraints, Callback successCallback, Callback errorCallback) { ThreadUtils.runOnExecutor(() -> getUserMediaImpl.getUserMedia(constraints, successCallback, errorCallback)); } @ReactMethod public void enumerateDevices(Callback callback) { ThreadUtils.runOnExecutor(() -> callback.invoke(getUserMediaImpl.enumerateDevices())); } @ReactMethod public void mediaStreamCreate(String id) { ThreadUtils.runOnExecutor(() -> { MediaStream mediaStream = mFactory.createLocalMediaStream(id); localStreams.put(id, mediaStream); }); } @ReactMethod public void mediaStreamAddTrack(String streamId, int pcId, String trackId) { ThreadUtils.runOnExecutor(() -> { MediaStream stream = localStreams.get(streamId); if (stream == null) { Log.d(TAG, "mediaStreamAddTrack() could not find stream " + streamId); return; } MediaStreamTrack track = getTrack(pcId, trackId); if (track == null) { Log.d(TAG, "mediaStreamAddTrack() could not find track " + trackId); return; } String kind = track.kind(); if ("audio".equals(kind)) { stream.addTrack((AudioTrack) track); } else if ("video".equals(kind)) { stream.addTrack((VideoTrack) track); } }); } @ReactMethod public void mediaStreamRemoveTrack(String streamId, int pcId, String trackId) { ThreadUtils.runOnExecutor(() -> { MediaStream stream = localStreams.get(streamId); if (stream == null) { Log.d(TAG, "mediaStreamRemoveTrack() could not find stream " + streamId); return; } MediaStreamTrack track = getTrack(pcId, trackId); if (track == null) { Log.d(TAG, "mediaStreamRemoveTrack() could not find track " + trackId); return; } String kind = track.kind(); if ("audio".equals(kind)) { stream.removeTrack((AudioTrack) track); } else if ("video".equals(kind)) { stream.removeTrack((VideoTrack) track); } }); } @ReactMethod public void mediaStreamRelease(String id) { ThreadUtils.runOnExecutor(() -> { MediaStream stream = localStreams.get(id); if (stream == null) { Log.d(TAG, "mediaStreamRelease() stream is null"); return; } localStreams.remove(id); stream.dispose(); }); } @ReactMethod public void mediaStreamTrackRelease(String id) { ThreadUtils.runOnExecutor(() -> { MediaStreamTrack track = getLocalTrack(id); if (track == null) { Log.d(TAG, "mediaStreamTrackRelease() track is null"); return; } track.setEnabled(false); getUserMediaImpl.disposeTrack(id); }); } @ReactMethod public void mediaStreamTrackSetEnabled(int pcId, String id, boolean enabled) { ThreadUtils.runOnExecutor(() -> { MediaStreamTrack track = getTrack(pcId, id); if (track == null) { Log.d(TAG, "mediaStreamTrackSetEnabled() could not find track " + id); return; } if (track.enabled() == enabled) { return; } track.setEnabled(enabled); getUserMediaImpl.mediaStreamTrackSetEnabled(id, enabled); }); } @ReactMethod public void mediaStreamTrackApplyConstraints(String id, ReadableMap constraints, Promise promise) { ThreadUtils.runOnExecutor(() -> { MediaStreamTrack track = getLocalTrack(id); if (track != null) { getUserMediaImpl.applyConstraints(id, constraints, promise); } else { promise.reject(new Exception("mediaStreamTrackApplyConstraints() could not find track " + id)); } }); } @ReactMethod public void mediaStreamTrackSetVolume(int pcId, String id, double volume) { ThreadUtils.runOnExecutor(() -> { MediaStreamTrack track = getTrack(pcId, id); if (track == null) { Log.d(TAG, "mediaStreamTrackSetVolume() could not find track " + id); return; } if (!(track instanceof AudioTrack)) { Log.d(TAG, "mediaStreamTrackSetVolume() track is not an AudioTrack!"); return; } ((AudioTrack) track).setVolume(volume); }); } @ReactMethod(isBlockingSynchronousMethod = true) public String mediaStreamTrackClone(String id) { try { return (String) ThreadUtils .submitToExecutor((Callable) () -> { MediaStreamTrack track = getLocalTrack(id); if (track == null) { Log.d(TAG, "mediaStreamTrackClone() could not find track " + id); return null; } MediaStreamTrack clonedTrack = getUserMediaImpl.cloneTrack(id); return clonedTrack.id(); }) .get(); } catch (ExecutionException | InterruptedException e) { Log.d(TAG, "mediaStreamTrackClone() " + e.getMessage()); return null; } } /** * This serializes the transceivers current direction and mid and returns them * for update when an sdp negotiation/renegotiation happens */ private ReadableArray getTransceiversInfo(PeerConnection peerConnection) { WritableArray transceiverUpdates = Arguments.createArray(); for (RtpTransceiver transceiver : peerConnection.getTransceivers()) { WritableMap transceiverUpdate = Arguments.createMap(); RtpTransceiver.RtpTransceiverDirection direction = transceiver.getCurrentDirection(); if (direction != null) { String directionSerialized = SerializeUtils.serializeDirection(direction); transceiverUpdate.putString("currentDirection", directionSerialized); } transceiverUpdate.putString("transceiverId", transceiver.getSender().id()); transceiverUpdate.putString("mid", transceiver.getMid()); transceiverUpdate.putBoolean("isStopped", transceiver.isStopped()); transceiverUpdate.putMap("senderRtpParameters", SerializeUtils.serializeRtpParameters(transceiver.getSender().getParameters())); transceiverUpdate.putMap("receiverRtpParameters", SerializeUtils.serializeRtpParameters(transceiver.getReceiver().getParameters())); transceiverUpdates.pushMap(transceiverUpdate); } return transceiverUpdates; } @ReactMethod public void mediaStreamTrackSetVideoEffects(String id, ReadableArray names) { ThreadUtils.runOnExecutor(() -> { getUserMediaImpl.setVideoEffects(id, names); }); } @ReactMethod public void peerConnectionSetConfiguration(ReadableMap configuration, int id) { ThreadUtils.runOnExecutor(() -> { PeerConnection peerConnection = getPeerConnection(id); if (peerConnection == null) { Log.d(TAG, "peerConnectionSetConfiguration() peerConnection is null"); return; } peerConnection.setConfiguration(parseRTCConfiguration(configuration)); }); } @ReactMethod public void peerConnectionCreateOffer(int id, ReadableMap options, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); PeerConnection peerConnection = pco == null ? null : pco.getPeerConnection(); if (peerConnection == null) { Log.d(TAG, "peerConnectionCreateOffer() peerConnection is null"); promise.reject(new Exception("PeerConnection not found")); return; } List receiversIds = new ArrayList<>(); for (RtpTransceiver transceiver : peerConnection.getTransceivers()) { receiversIds.add(transceiver.getReceiver().id()); } final SdpObserver observer = new SdpObserver() { @Override public void onCreateFailure(String s) { ThreadUtils.runOnExecutor(() -> { promise.reject("E_OPERATION_ERROR", s); }); } @Override public void onCreateSuccess(SessionDescription sdp) { ThreadUtils.runOnExecutor(() -> { WritableMap params = Arguments.createMap(); WritableMap sdpInfo = Arguments.createMap(); sdpInfo.putString("sdp", sdp.description); sdpInfo.putString("type", sdp.type.canonicalForm()); params.putArray("transceiversInfo", getTransceiversInfo(peerConnection)); params.putMap("sdpInfo", sdpInfo); WritableArray newTransceivers = Arguments.createArray(); for (RtpTransceiver transceiver : peerConnection.getTransceivers()) { if (!receiversIds.contains(transceiver.getReceiver().id())) { WritableMap newTransceiver = Arguments.createMap(); newTransceiver.putInt("transceiverOrder", pco.getNextTransceiverId()); newTransceiver.putMap( "transceiver", SerializeUtils.serializeTransceiver(id, transceiver)); newTransceivers.pushMap(newTransceiver); } } params.putArray("newTransceivers", newTransceivers); promise.resolve(params); }); } @Override public void onSetFailure(String s) {} @Override public void onSetSuccess() {} }; peerConnection.createOffer(observer, constraintsForOptions(options)); }); } @ReactMethod public void peerConnectionCreateAnswer(int id, ReadableMap options, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnection peerConnection = getPeerConnection(id); if (peerConnection == null) { Log.d(TAG, "peerConnectionCreateAnswer() peerConnection is null"); promise.reject(new Exception("PeerConnection not found")); return; } final SdpObserver observer = new SdpObserver() { @Override public void onCreateFailure(String s) { ThreadUtils.runOnExecutor(() -> { promise.reject("E_OPERATION_ERROR", s); }); } @Override public void onCreateSuccess(SessionDescription sdp) { ThreadUtils.runOnExecutor(() -> { WritableMap params = Arguments.createMap(); WritableMap sdpInfo = Arguments.createMap(); sdpInfo.putString("sdp", sdp.description); sdpInfo.putString("type", sdp.type.canonicalForm()); params.putArray("transceiversInfo", getTransceiversInfo(peerConnection)); params.putMap("sdpInfo", sdpInfo); promise.resolve(params); }); } @Override public void onSetFailure(String s) {} @Override public void onSetSuccess() {} }; peerConnection.createAnswer(observer, constraintsForOptions(options)); }); } @ReactMethod public void peerConnectionSetLocalDescription(int pcId, ReadableMap desc, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnection peerConnection = getPeerConnection(pcId); if (peerConnection == null) { Log.d(TAG, "peerConnectionSetLocalDescription() peerConnection is null"); promise.reject(new Exception("PeerConnection not found")); return; } final SdpObserver observer = new SdpObserver() { @Override public void onCreateSuccess(SessionDescription sdp) {} @Override public void onSetSuccess() { ThreadUtils.runOnExecutor(() -> { WritableMap newSdpMap = Arguments.createMap(); WritableMap params = Arguments.createMap(); SessionDescription newSdp = peerConnection.getLocalDescription(); // Can happen when doing a rollback. if (newSdp != null) { newSdpMap.putString("type", newSdp.type.canonicalForm()); newSdpMap.putString("sdp", newSdp.description); } params.putMap("sdpInfo", newSdpMap); params.putArray("transceiversInfo", getTransceiversInfo(peerConnection)); promise.resolve(params); }); } @Override public void onCreateFailure(String s) {} @Override public void onSetFailure(String s) { ThreadUtils.runOnExecutor(() -> { promise.reject("E_OPERATION_ERROR", s); }); } }; if (desc != null) { SessionDescription sdp = new SessionDescription( SessionDescription.Type.fromCanonicalForm(Objects.requireNonNull(desc.getString("type"))), desc.getString("sdp")); peerConnection.setLocalDescription(observer, sdp); } else { peerConnection.setLocalDescription(observer); } }); } @ReactMethod public void peerConnectionSetRemoteDescription(int id, ReadableMap desc, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); PeerConnection peerConnection = pco == null ? null : pco.getPeerConnection(); if (peerConnection == null) { Log.d(TAG, "peerConnectionSetRemoteDescription() peerConnection is null"); promise.reject(new Exception("PeerConnection not found")); return; } SessionDescription sdp = new SessionDescription( SessionDescription.Type.fromCanonicalForm(desc.getString("type")), desc.getString("sdp")); List receiversIds = new ArrayList<>(); for (RtpTransceiver transceiver : peerConnection.getTransceivers()) { receiversIds.add(transceiver.getReceiver().id()); } final SdpObserver observer = new SdpObserver() { @Override public void onCreateSuccess(final SessionDescription sdp) {} @Override public void onSetSuccess() { ThreadUtils.runOnExecutor(() -> { WritableMap newSdpMap = Arguments.createMap(); WritableMap params = Arguments.createMap(); SessionDescription newSdp = peerConnection.getRemoteDescription(); // Be defensive for the rollback cases. if (newSdp != null) { newSdpMap.putString("type", newSdp.type.canonicalForm()); newSdpMap.putString("sdp", newSdp.description); } params.putArray("transceiversInfo", getTransceiversInfo(peerConnection)); params.putMap("sdpInfo", newSdpMap); WritableArray newTransceivers = Arguments.createArray(); for (RtpTransceiver transceiver : peerConnection.getTransceivers()) { if (!receiversIds.contains(transceiver.getReceiver().id())) { WritableMap newTransceiver = Arguments.createMap(); newTransceiver.putInt("transceiverOrder", pco.getNextTransceiverId()); newTransceiver.putMap( "transceiver", SerializeUtils.serializeTransceiver(id, transceiver)); newTransceivers.pushMap(newTransceiver); } } params.putArray("newTransceivers", newTransceivers); promise.resolve(params); }); } @Override public void onCreateFailure(String s) {} @Override public void onSetFailure(String s) { ThreadUtils.runOnExecutor(() -> { promise.reject("E_OPERATION_ERROR", s); }); } }; peerConnection.setRemoteDescription(observer, sdp); }); } @ReactMethod(isBlockingSynchronousMethod = true) public WritableMap receiverGetCapabilities(String kind) { try { return (WritableMap) ThreadUtils .submitToExecutor((Callable) () -> { MediaStreamTrack.MediaType mediaType; if (kind.equals("audio")) { mediaType = MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO; } else if (kind.equals("video")) { mediaType = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO; } else { return Arguments.createMap(); } RtpCapabilities capabilities = mFactory.getRtpReceiverCapabilities(mediaType); return SerializeUtils.serializeRtpCapabilities(capabilities); }) .get(); } catch (ExecutionException | InterruptedException e) { Log.d(TAG, "receiverGetCapabilities() " + e.getMessage()); return null; } } @ReactMethod(isBlockingSynchronousMethod = true) public WritableMap senderGetCapabilities(String kind) { try { return (WritableMap) ThreadUtils .submitToExecutor((Callable) () -> { MediaStreamTrack.MediaType mediaType; if (kind.equals("audio")) { mediaType = MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO; } else if (kind.equals("video")) { mediaType = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO; } else { return Arguments.createMap(); } RtpCapabilities capabilities = mFactory.getRtpSenderCapabilities(mediaType); return SerializeUtils.serializeRtpCapabilities(capabilities); }) .get(); } catch (ExecutionException | InterruptedException e) { Log.d(TAG, "senderGetCapabilities() " + e.getMessage()); return null; } } @ReactMethod public void receiverGetStats(int pcId, String receiverId, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(pcId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "receiverGetStats() peerConnection is null"); promise.resolve(StringUtils.statsToJSON(new RTCStatsReport(0, new HashMap<>()))); } else { pco.receiverGetStats(receiverId, promise); } }); } @ReactMethod public void senderGetStats(int pcId, String senderId, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(pcId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "senderGetStats() peerConnection is null"); promise.resolve(StringUtils.statsToJSON(new RTCStatsReport(0, new HashMap<>()))); } else { pco.senderGetStats(senderId, promise); } }); } @ReactMethod public void peerConnectionAddICECandidate(int pcId, ReadableMap candidateMap, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnection peerConnection = getPeerConnection(pcId); if (peerConnection == null) { Log.d(TAG, "peerConnectionAddICECandidate() peerConnection is null"); promise.reject(new Exception("PeerConnection not found")); return; } if (!candidateMap.hasKey("sdpMid") && !candidateMap.hasKey("sdpMLineIndex")) { promise.reject("E_TYPE_ERROR", "Invalid argument"); return; } IceCandidate candidate = new IceCandidate(candidateMap.hasKey("sdpMid") && !candidateMap.isNull("sdpMid") ? candidateMap.getString("sdpMid") : "", candidateMap.hasKey("sdpMLineIndex") && !candidateMap.isNull("sdpMLineIndex") ? candidateMap.getInt("sdpMLineIndex") : 0, candidateMap.getString("candidate")); peerConnection.addIceCandidate(candidate, new AddIceObserver() { @Override public void onAddSuccess() { ThreadUtils.runOnExecutor(() -> { WritableMap newSdpMap = Arguments.createMap(); SessionDescription newSdp = peerConnection.getRemoteDescription(); newSdpMap.putString("type", newSdp.type.canonicalForm()); newSdpMap.putString("sdp", newSdp.description); promise.resolve(newSdpMap); }); } @Override public void onAddFailure(String s) { ThreadUtils.runOnExecutor(() -> { promise.reject("E_OPERATION_ERROR", s); }); } }); }); } @ReactMethod public void peerConnectionGetStats(int peerConnectionId, Promise promise) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "peerConnectionGetStats() peerConnection is null"); promise.resolve(StringUtils.statsToJSON(new RTCStatsReport(0, new HashMap<>()))); } else { pco.getStats(promise); } }); } @ReactMethod public void peerConnectionClose(int id) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "peerConnectionClose() peerConnection is null"); return; } pco.close(); }); } @ReactMethod public void peerConnectionDispose(int id) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(id); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "peerConnectionDispose() peerConnection is null"); } pco.dispose(); mPeerConnectionObservers.remove(id); }); } @ReactMethod public void peerConnectionRestartIce(int pcId) { ThreadUtils.runOnExecutor(() -> { PeerConnection peerConnection = getPeerConnection(pcId); if (peerConnection == null) { Log.w(TAG, "peerConnectionRestartIce() peerConnection is null"); return; } peerConnection.restartIce(); }); } @ReactMethod(isBlockingSynchronousMethod = true) public WritableMap createDataChannel(int peerConnectionId, String label, ReadableMap config) { try { return (WritableMap) ThreadUtils .submitToExecutor((Callable) () -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "createDataChannel() peerConnection is null"); return null; } else { return pco.createDataChannel(label, config); } }) .get(); } catch (ExecutionException | InterruptedException e) { return null; } } @ReactMethod public void dataChannelClose(int peerConnectionId, String reactTag) { ThreadUtils.runOnExecutor(() -> { // Forward to PeerConnectionObserver which deals with DataChannels // because DataChannel is owned by PeerConnection. PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "dataChannelClose() peerConnection is null"); return; } pco.dataChannelClose(reactTag); }); } @ReactMethod public void dataChannelDispose(int peerConnectionId, String reactTag) { ThreadUtils.runOnExecutor(() -> { PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "dataChannelDispose() peerConnection is null"); return; } pco.dataChannelDispose(reactTag); }); } @ReactMethod public void dataChannelSend(int peerConnectionId, String reactTag, String data, String type) { ThreadUtils.runOnExecutor(() -> { // Forward to PeerConnectionObserver which deals with DataChannels // because DataChannel is owned by PeerConnection. PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId); if (pco == null || pco.getPeerConnection() == null) { Log.d(TAG, "dataChannelSend() peerConnection is null"); return; } pco.dataChannelSend(reactTag, data, type); }); } // Frame Cryptor methods //////////////////////////////// RTCCryptoManager frameCryptor = new RTCCryptoManager(this); @ReactMethod(isBlockingSynchronousMethod = true) public String frameCryptorFactoryCreateFrameCryptor(ReadableMap config) { return frameCryptor.frameCryptorFactoryCreateFrameCryptor(config); } @ReactMethod public void frameCryptorSetKeyIndex(ReadableMap config, Promise promise) { frameCryptor.frameCryptorSetKeyIndex(config, promise); } @ReactMethod public void frameCryptorGetKeyIndex(ReadableMap config, Promise promise) { frameCryptor.frameCryptorGetKeyIndex(config, promise); } @ReactMethod public void frameCryptorSetEnabled(ReadableMap config, Promise promise) { frameCryptor.frameCryptorSetEnabled(config, promise); } @ReactMethod public void frameCryptorGetEnabled(ReadableMap config, Promise promise) { frameCryptor.frameCryptorGetEnabled(config, promise); } @ReactMethod public void frameCryptorDispose(ReadableMap config, Promise promise) { frameCryptor.frameCryptorDispose(config, promise); } @ReactMethod(isBlockingSynchronousMethod = true) public String frameCryptorFactoryCreateKeyProvider(ReadableMap config) { return frameCryptor.frameCryptorFactoryCreateKeyProvider(config); } @ReactMethod public void keyProviderSetSharedKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderSetSharedKey(config, promise); } @ReactMethod public void keyProviderRatchetSharedKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderRatchetSharedKey(config, promise); } @ReactMethod public void keyProviderExportSharedKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderExportSharedKey(config, promise); } @ReactMethod public void keyProviderSetKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderSetKey(config, promise); } @ReactMethod public void keyProviderRatchetKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderRatchetKey(config, promise); } @ReactMethod public void keyProviderExportKey(ReadableMap config, Promise promise) { frameCryptor.keyProviderExportKey(config, promise); } @ReactMethod public void keyProviderSetSifTrailer(ReadableMap config, Promise promise) { frameCryptor.keyProviderSetSifTrailer(config, promise); } @ReactMethod public void keyProviderDispose(ReadableMap config, Promise promise) { frameCryptor.keyProviderDispose(config, promise); } @ReactMethod public void generateCertificate(ReadableMap options, Promise promise) { ThreadUtils.runOnExecutor(() -> { try { PeerConnection.KeyType keyType = PeerConnection.KeyType.ECDSA; long expires = 2592000L; // Default 30 days if (options.hasKey("keyType")) { String keyTypeStr = options.getString("keyType"); if ("RSA".equals(keyTypeStr)) { keyType = PeerConnection.KeyType.RSA; } else if ("ECDSA".equals(keyTypeStr)) { keyType = PeerConnection.KeyType.ECDSA; } } if (options.hasKey("expires")) { expires = (long) options.getDouble("expires"); } RtcCertificatePem cert = RtcCertificatePem.generateCertificate(keyType, expires); String certId = java.util.UUID.randomUUID().toString(); synchronized (mCertificates) { mCertificates.put(certId, cert); } WritableMap params = Arguments.createMap(); params.putString("certificateId", certId); // Return expires as millis since epoch params.putDouble("expires", System.currentTimeMillis() + expires * 1000); // Calculate fingerprints WritableArray fingerprints = Arguments.createArray(); try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); ByteArrayInputStream is = new ByteArrayInputStream(cert.certificate.getBytes(StandardCharsets.UTF_8)); X509Certificate x509Cert = (X509Certificate) cf.generateCertificate(is); MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] hash = digest.digest(x509Cert.getEncoded()); WritableMap fingerprint = Arguments.createMap(); fingerprint.putString("algorithm", "sha-256"); fingerprint.putString("value", bytesToHex(hash)); fingerprints.pushMap(fingerprint); } catch (Exception e) { Log.e(TAG, "Failed to calculate fingerprint: " + e.getMessage()); } params.putArray("fingerprints", fingerprints); promise.resolve(params); } catch (Exception e) { promise.reject(e); } }); } private String bytesToHex(byte[] bytes) { StringBuilder sb = new StringBuilder(); for (byte b : bytes) { sb.append(String.format("%02x", b)); sb.append(":"); } if (sb.length() > 0) { sb.setLength(sb.length() - 1); } return sb.toString(); } @ReactMethod public void dataPacketCryptorFactoryCreateDataPacketCryptor(ReadableMap params, @NonNull Promise result) { frameCryptor.dataPacketCryptorFactoryCreateDataPacketCryptor(params, result); } @ReactMethod public void dataPacketCryptorEncrypt(ReadableMap params, @NonNull Promise result) { frameCryptor.dataPacketCryptorEncrypt(params, result); } @ReactMethod public void dataPacketCryptorDecrypt(ReadableMap params, @NonNull Promise result) { frameCryptor.dataPacketCryptorDecrypt(params, result); } @ReactMethod public void dataPacketCryptorDispose(ReadableMap params, @NonNull Promise result) { frameCryptor.dataPacketCryptorDispose(params, result); } @ReactMethod public void addListener(String eventName) { // Keep: Required for RN built in Event Emitter Calls. } @ReactMethod public void removeListeners(Integer count) { // Keep: Required for RN built in Event Emitter Calls. } }