@sbhjt-gr/react-native-webrtc 124.0.0

package/ios/RCTWebRTC/WebRTCModule+Transceivers.m

@@ -0,0 +1,267 @@
+#import <objc/runtime.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+
+#import <WebRTC/RTCRtpCodecCapability.h>
+#import <WebRTC/RTCRtpReceiver.h>
+#import <WebRTC/RTCRtpSender.h>
+
+#import "SerializeUtils.h"
+#import "WebRTCModule.h"
+
+@implementation WebRTCModule (Transceivers)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(senderGetCapabilities : (NSString *)kind) {
+    __block id params;
+
+    dispatch_sync(self.workerQueue, ^{
+        RTCRtpCapabilities *capabilities = [self.peerConnectionFactory rtpSenderCapabilitiesForKind:kind];
+        params = [SerializeUtils capabilitiesToJSON:capabilities];
+    });
+
+    return params;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(receiverGetCapabilities : (NSString *)kind) {
+    __block id params;
+
+    dispatch_sync(self.workerQueue, ^{
+        RTCRtpCapabilities *capabilities = [self.peerConnectionFactory rtpReceiverCapabilitiesForKind:kind];
+        params = [SerializeUtils capabilitiesToJSON:capabilities];
+    });
+
+    return params;
+}
+
+RCT_EXPORT_METHOD(senderReplaceTrack
+                  : (nonnull NSNumber *)objectID senderId
+                  : (NSString *)senderId trackId
+                  : (NSString *)trackId resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCPeerConnection *peerConnection = self.peerConnections[objectID];
+
+    if (peerConnection == nil) {
+        RCTLogWarn(@"PeerConnection %@ not found in senderReplaceTrack()", objectID);
+        reject(@"E_INVALID", @"Peer Connection is not initialized", nil);
+    }
+
+    RTCRtpTransceiver *transceiver = nil;
+    for (RTCRtpTransceiver *t in peerConnection.transceivers) {
+        if ([senderId isEqual:t.sender.senderId]) {
+            transceiver = t;
+            break;
+        }
+    }
+
+    if (transceiver == nil) {
+        RCTLogWarn(@"senderReplaceTrack() transceiver is null");
+        reject(@"E_INVALID", @"Could not get transceive", nil);
+    }
+
+    RTCRtpSender *sender = transceiver.sender;
+    RTCMediaStreamTrack *track = self.localTracks[trackId];
+    [sender setTrack:track];
+    resolve(@true);
+}
+
+RCT_EXPORT_METHOD(senderSetParameters
+                  : (nonnull NSNumber *)objectID senderId
+                  : (NSString *)senderId options
+                  : (NSDictionary *)options resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCPeerConnection *peerConnection = self.peerConnections[objectID];
+
+    if (peerConnection == nil) {
+        RCTLogWarn(@"PeerConnection %@ not found in senderSetParameters()", objectID);
+        reject(@"E_INVALID", @"Peer Connection is not initialized", nil);
+        return;
+    }
+
+    RTCRtpTransceiver *transceiver = nil;
+    for (RTCRtpTransceiver *t in peerConnection.transceivers) {
+        if ([senderId isEqual:t.sender.senderId]) {
+            transceiver = t;
+            break;
+        }
+    }
+
+    if (transceiver == nil) {
+        RCTLogWarn(@"senderSetParameters() transceiver is null");
+        reject(@"E_INVALID", @"Could not get transceiver", nil);
+        return;
+    }
+
+    RTCRtpSender *sender = transceiver.sender;
+    RTCRtpParameters *parameters = sender.parameters;
+    [sender setParameters:[self updateParametersWithOptions:options params:parameters]];
+
+    resolve([SerializeUtils parametersToJSON:sender.parameters]);
+}
+
+RCT_EXPORT_METHOD(transceiverSetDirection
+                  : (nonnull NSNumber *)objectID senderId
+                  : (NSString *)senderId direction
+                  : (NSString *)direction resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCPeerConnection *peerConnection = self.peerConnections[objectID];
+
+    if (peerConnection == nil) {
+        RCTLogWarn(@"transceiverSetDirection() PeerConnection %@ not found in transceiverSetDirection()", objectID);
+        reject(@"E_INVALID", @"Peer Connection is not initialized", nil);
+        return;
+    }
+
+    RTCRtpTransceiver *transceiver = nil;
+    for (RTCRtpTransceiver *t in peerConnection.transceivers) {
+        if ([senderId isEqual:t.sender.senderId]) {
+            transceiver = t;
+            break;
+        }
+    }
+
+    if (transceiver == nil) {
+        RCTLogWarn(@"transceiverSetDirection() transceiver is null");
+        reject(@"E_INVALID", @"Could not get transceiver", nil);
+        return;
+    }
+
+    NSError *error;
+    [transceiver setDirection:[SerializeUtils parseDirection:direction] error:&error];
+
+    if (error) {
+        reject(@"E_SET_DIRECTION", @"Could not set direction", error);
+    } else {
+        resolve(@true);
+    }
+}
+
+RCT_EXPORT_METHOD(transceiverStop
+                  : (nonnull NSNumber *)objectID senderId
+                  : (NSString *)senderId resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    RTCPeerConnection *peerConnection = self.peerConnections[objectID];
+
+    if (peerConnection == nil) {
+        RCTLogWarn(@"PeerConnection %@ not found in transceiverStop()", objectID);
+        reject(@"E_INVALID", @"Peer Connection is not initialized", nil);
+        return;
+    }
+
+    RTCRtpTransceiver *transceiver = nil;
+    for (RTCRtpTransceiver *t in peerConnection.transceivers) {
+        if ([senderId isEqual:t.sender.senderId]) {
+            transceiver = t;
+            break;
+        }
+    }
+
+    if (transceiver == nil) {
+        RCTLogWarn(@"senderSetParameters() transceiver is null");
+        reject(@"E_INVALID", @"Could not get transceiver", nil);
+        return;
+    }
+
+    [transceiver stopInternal];
+
+    resolve(@true);
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(transceiverSetCodecPreferences
+                                       : (nonnull NSNumber *)objectID senderId
+                                       : (NSString *)senderId codecPreferences
+                                       : (NSArray *)codecPreferences) {
+    RTCPeerConnection *peerConnection = self.peerConnections[objectID];
+
+    if (peerConnection == nil) {
+        RCTLogWarn(@"PeerConnection %@ not found in transceiverSetCodecPreferences()", objectID);
+        return nil;
+    }
+
+    RTCRtpTransceiver *transceiver = nil;
+    for (RTCRtpTransceiver *t in peerConnection.transceivers) {
+        if ([senderId isEqual:t.sender.senderId]) {
+            transceiver = t;
+            break;
+        }
+    }
+
+    if (transceiver == nil) {
+        RCTLogWarn(@"transceiverSetCodecPreferences() transceiver is null");
+        return nil;
+    }
+
+    // Get the available codecs
+    RTCRtpTransceiverDirection direction = transceiver.direction;
+    NSMutableArray *availableCodecs = [NSMutableArray new];
+    NSString *kind = transceiver.mediaType == RTCRtpMediaTypeAudio ? @"audio" : @"video";
+    if (direction == RTCRtpTransceiverDirectionSendRecv || direction == RTCRtpTransceiverDirectionSendOnly) {
+        RTCRtpCapabilities *capabilities = [self.peerConnectionFactory rtpSenderCapabilitiesForKind:kind];
+        for (RTCRtpCodecCapability *codec in capabilities.codecs) {
+            NSDictionary *codecDict = [SerializeUtils codecCapabilityToJSON:codec];
+            [availableCodecs addObject:@{
+                @"dict" : codecDict,
+                @"codec" : codec,
+            }];
+        }
+    }
+    if (direction == RTCRtpTransceiverDirectionSendRecv || direction == RTCRtpTransceiverDirectionRecvOnly) {
+        RTCRtpCapabilities *capabilities = [self.peerConnectionFactory rtpReceiverCapabilitiesForKind:kind];
+        for (RTCRtpCodecCapability *codec in capabilities.codecs) {
+            NSDictionary *codecDict = [SerializeUtils codecCapabilityToJSON:codec];
+            [availableCodecs addObject:@{
+                @"dict" : codecDict,
+                @"codec" : codec,
+            }];
+        }
+    }
+
+    // Convert JSON codec capabilities to the actual objects.
+    // Codec preferences is order sensitive.
+    NSMutableArray *codecsToSet = [NSMutableArray new];
+
+    for (NSDictionary *codecDict in codecPreferences) {
+        for (NSDictionary *entry in availableCodecs) {
+            NSDictionary *availableCodecDict = [entry objectForKey:@"dict"];
+            if ([codecDict isEqualToDictionary:availableCodecDict]) {
+                [codecsToSet addObject:[entry objectForKey:@"codec"]];
+                break;
+            }
+        }
+    }
+
+    transceiver.codecPreferences = codecsToSet;
+    return nil;
+}
+
+- (RTCRtpParameters *)updateParametersWithOptions:(NSDictionary *)options params:(RTCRtpParameters *)params {
+    NSArray *encodingsArray = options[@"encodings"];
+    NSArray *encodings = params.encodings;
+
+    if ([encodingsArray count] != [encodings count]) {
+        return nil;
+    }
+
+    for (int i = 0; i < [encodingsArray count]; i++) {
+        NSDictionary *encodingUpdate = encodingsArray[i];
+        RTCRtpEncodingParameters *encoding = encodings[i];
+
+        encoding.isActive = [encodingUpdate[@"active"] boolValue];
+        encoding.rid = encodingUpdate[@"rid"];
+        encoding.maxBitrateBps = encodingUpdate[@"maxBitrate"];
+        encoding.maxFramerate = encodingUpdate[@"maxFramerate"];
+        encoding.scaleResolutionDownBy = encodingUpdate[@"scaleResolutionDownBy"];
+    }
+
+    if ([options objectForKey:@"degradationPreference"]) {
+        params.degradationPreference = [options objectForKey:@"degradationPreference"];
+    }
+
+    return params;
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule+VideoTrackAdapter.h

@@ -0,0 +1,12 @@
+
+#import <WebRTC/RTCPeerConnection.h>
+#import "WebRTCModule.h"
+
+@interface RTCPeerConnection (VideoTrackAdapter)
+
+@property(nonatomic, strong) NSMutableDictionary<NSString *, id> *videoTrackAdapters;
+
+- (void)addVideoTrackAdapter:(RTCVideoTrack *)track;
+- (void)removeVideoTrackAdapter:(RTCVideoTrack *)track;
+
+@end

package/ios/RCTWebRTC/WebRTCModule+VideoTrackAdapter.m

@@ -0,0 +1,166 @@
+
+#import <Foundation/Foundation.h>
+#include <libkern/OSAtomic.h>
+#import <objc/runtime.h>
+#import <stdatomic.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTLog.h>
+
+#import <WebRTC/RTCVideoRenderer.h>
+#import <WebRTC/RTCVideoTrack.h>
+
+#import "WebRTCModule+RTCPeerConnection.h"
+#import "WebRTCModule+VideoTrackAdapter.h"
+#import "WebRTCModule.h"
+
+/* Mute detection timer intervals. The initial timeout will be longer to
+ * accommodate for source startup.
+ */
+static const NSTimeInterval INITIAL_MUTE_DELAY = 3;
+static const NSTimeInterval MUTE_DELAY = 1.5;
+
+/* Entity responsible for detecting track mute / unmute events. It's implemented
+ * as a video renderer, which counts the number of frames, and if it sees them
+ * stalled for the default interval it will emit a mute event. If frames keep
+ * being received, the track unmute event will be emitted.
+ */
+@interface TrackMuteDetector : NSObject<RTCVideoRenderer>
+
+@property(copy, nonatomic) NSNumber *peerConnectionId;
+@property(copy, nonatomic) NSString *trackId;
+@property(weak, nonatomic) WebRTCModule *module;
+
+@end
+
+@implementation TrackMuteDetector {
+    BOOL _disposed;
+    atomic_ullong _frameCount;
+    BOOL _muted;
+    dispatch_source_t _timer;
+}
+
+- (instancetype)initWith:(NSNumber *)peerConnectionId trackId:(NSString *)trackId webRTCModule:(WebRTCModule *)module {
+    self = [super init];
+    if (self) {
+        self.peerConnectionId = peerConnectionId;
+        self.trackId = trackId;
+        self.module = module;
+
+        _disposed = NO;
+        _frameCount = 0;
+        _muted = NO;
+        _timer = nil;
+    }
+
+    return self;
+}
+
+- (void)dispose {
+    _disposed = YES;
+    if (_timer != nil) {
+        dispatch_source_cancel(_timer);
+        _timer = nil;
+    }
+}
+
+- (void)emitMuteEvent:(BOOL)muted {
+    [self.module sendEventWithName:kEventMediaStreamTrackMuteChanged
+                              body:@{@"pcId" : self.peerConnectionId, @"trackId" : self.trackId, @"muted" : @(muted)}];
+    RCTLog(@"[VideoTrackAdapter] %@ event for pc %@ track %@",
+           muted ? @"Mute" : @"Unmute",
+           self.peerConnectionId,
+           self.trackId);
+}
+
+- (void)start {
+    if (_disposed) {
+        return;
+    }
+
+    if (_timer != nil) {
+        dispatch_source_cancel(_timer);
+    }
+
+    // Create a timer using GCD, since NSTimer requires a runloop to be present
+    // on the calling thread.
+    _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
+
+    // Schedule the timer with a larger initial delay than the interval.
+    dispatch_source_set_timer(_timer,
+                              dispatch_time(DISPATCH_TIME_NOW, INITIAL_MUTE_DELAY * NSEC_PER_SEC),
+                              MUTE_DELAY * NSEC_PER_SEC,
+                              (1ull * NSEC_PER_SEC) / 10);
+
+    __block unsigned long long lastFrameCount = _frameCount;
+    dispatch_source_set_event_handler(_timer, ^() {
+        if (self->_disposed) {
+            return;
+        }
+
+        BOOL isMuted = lastFrameCount == self->_frameCount;
+        if (isMuted != self->_muted) {
+            self->_muted = isMuted;
+            [self emitMuteEvent:isMuted];
+        }
+
+        lastFrameCount = self->_frameCount;
+    });
+
+    dispatch_resume(_timer);
+}
+
+- (void)renderFrame:(nullable RTCVideoFrame *)frame {
+    atomic_fetch_add(&_frameCount, 1);
+}
+
+- (void)setSize:(CGSize)size {
+    // XXX unneeded for our purposes, but part of RTCVideoRenderer.
+}
+
+@end
+
+@implementation RTCPeerConnection (VideoTrackAdapter)
+
+- (NSMutableDictionary<NSString *, id> *)videoTrackAdapters {
+    return objc_getAssociatedObject(self, _cmd);
+}
+
+- (void)setVideoTrackAdapters:(NSMutableDictionary<NSString *, id> *)videoTrackAdapters {
+    objc_setAssociatedObject(
+        self, @selector(videoTrackAdapters), videoTrackAdapters, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (void)addVideoTrackAdapter:(RTCVideoTrack *)track {
+    NSString *trackId = track.trackId;
+    if ([self.videoTrackAdapters objectForKey:trackId] != nil) {
+        RCTLogWarn(@"[VideoTrackAdapter] Adapter already exists for track %@", trackId);
+        return;
+    }
+
+    TrackMuteDetector *muteDetector = [[TrackMuteDetector alloc] initWith:self.reactTag
+                                                                  trackId:trackId
+                                                             webRTCModule:self.webRTCModule];
+    [self.videoTrackAdapters setObject:muteDetector forKey:trackId];
+    [track addRenderer:muteDetector];
+    [muteDetector start];
+
+    RCTLogTrace(@"[VideoTrackAdapter] Adapter created for track %@", trackId);
+}
+
+- (void)removeVideoTrackAdapter:(RTCVideoTrack *)track {
+    NSString *trackId = track.trackId;
+    TrackMuteDetector *muteDetector = [self.videoTrackAdapters objectForKey:trackId];
+    if (muteDetector == nil) {
+        RCTLogWarn(@"[VideoTrackAdapter] Adapter doesn't exist for track %@", trackId);
+        return;
+    }
+
+    [track removeRenderer:muteDetector];
+    [muteDetector dispose];
+    [self.videoTrackAdapters removeObjectForKey:trackId];
+    RCTLogTrace(@"[VideoTrackAdapter] Adapter removed for track %@", trackId);
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule.h

@@ -0,0 +1,51 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConvert.h>
+#import <React/RCTEventEmitter.h>
+
+#import <WebRTC/WebRTC.h>
+
+@class PalabraClient;
+
+static NSString *const kEventPeerConnectionSignalingStateChanged = @"peerConnectionSignalingStateChanged";
+static NSString *const kEventPeerConnectionStateChanged = @"peerConnectionStateChanged";
+static NSString *const kEventPeerConnectionOnRenegotiationNeeded = @"peerConnectionOnRenegotiationNeeded";
+static NSString *const kEventPeerConnectionIceConnectionChanged = @"peerConnectionIceConnectionChanged";
+static NSString *const kEventPeerConnectionIceGatheringChanged = @"peerConnectionIceGatheringChanged";
+static NSString *const kEventPeerConnectionGotICECandidate = @"peerConnectionGotICECandidate";
+static NSString *const kEventPeerConnectionDidOpenDataChannel = @"peerConnectionDidOpenDataChannel";
+static NSString *const kEventDataChannelDidChangeBufferedAmount = @"dataChannelDidChangeBufferedAmount";
+static NSString *const kEventDataChannelStateChanged = @"dataChannelStateChanged";
+static NSString *const kEventDataChannelReceiveMessage = @"dataChannelReceiveMessage";
+static NSString *const kEventMediaStreamTrackMuteChanged = @"mediaStreamTrackMuteChanged";
+static NSString *const kEventMediaStreamTrackEnded = @"mediaStreamTrackEnded";
+static NSString *const kEventPeerConnectionOnRemoveTrack = @"peerConnectionOnRemoveTrack";
+static NSString *const kEventPeerConnectionOnTrack = @"peerConnectionOnTrack";
+static NSString *const kEventFrameCryptionStateChanged = @"frameCryptionStateChanged";
+static NSString *const kEventPalabraTranscription = @"palabraTranscription";
+static NSString *const kEventPalabraConnectionState = @"palabraConnectionState";
+static NSString *const kEventPalabraError = @"palabraError";
+
+@interface WebRTCModule : RCTEventEmitter<RCTBridgeModule>
+
+@property(nonatomic, strong) dispatch_queue_t workerQueue;
+
+@property(nonatomic, strong) RTCPeerConnectionFactory *peerConnectionFactory;
+@property(nonatomic, strong) id<RTCVideoDecoderFactory> decoderFactory;
+@property(nonatomic, strong) id<RTCVideoEncoderFactory> encoderFactory;
+
+@property(nonatomic, strong) NSMutableDictionary<NSNumber *, RTCPeerConnection *> *peerConnections;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, RTCMediaStream *> *localStreams;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, RTCMediaStreamTrack *> *localTracks;
+
+@property(nonatomic, strong) NSMutableDictionary<NSString *, RTCFrameCryptor *> *frameCryptors;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, RTCFrameCryptorKeyProvider *> *keyProviders;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, RTCDataPacketCryptor *> *dataPacketCryptors;
+
+@property(nonatomic, strong) PalabraClient *palabraClient;
+
+- (RTCMediaStream *)streamForReactTag:(NSString *)reactTag;
+
+@end

package/ios/RCTWebRTC/WebRTCModule.m

@@ -0,0 +1,151 @@
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#endif
+
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "WebRTCModule+RTCPeerConnection.h"
+#import "WebRTCModule.h"
+#import "WebRTCModuleOptions.h"
+
+@interface WebRTCModule ()
+@end
+
+@implementation WebRTCModule
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+- (void)dealloc {
+    [_localTracks removeAllObjects];
+    _localTracks = nil;
+    [_localStreams removeAllObjects];
+    _localStreams = nil;
+
+    for (NSNumber *peerConnectionId in _peerConnections) {
+        RTCPeerConnection *peerConnection = _peerConnections[peerConnectionId];
+        peerConnection.delegate = nil;
+        [peerConnection close];
+    }
+    [_peerConnections removeAllObjects];
+
+    _peerConnectionFactory = nil;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
+        id<RTCAudioDevice> audioDevice = options.audioDevice;
+        id<RTCVideoDecoderFactory> decoderFactory = options.videoDecoderFactory;
+        id<RTCVideoEncoderFactory> encoderFactory = options.videoEncoderFactory;
+        id<RTCAudioProcessingModule> audioProcessingModule = options.audioProcessingModule;
+        NSDictionary *fieldTrials = options.fieldTrials;
+        RTCLoggingSeverity loggingSeverity = options.loggingSeverity;
+
+        // Initialize field trials.
+        if (fieldTrials == nil) {
+            // Fix for dual-sim connectivity:
+            // https://bugs.chromium.org/p/webrtc/issues/detail?id=10966
+            fieldTrials = @{kRTCFieldTrialUseNWPathMonitor : kRTCFieldTrialEnabledValue};
+        }
+        RTCInitFieldTrialDictionary(fieldTrials);
+
+        // Initialize logging.
+        RTCSetMinDebugLogLevel(loggingSeverity);
+
+        if (encoderFactory == nil) {
+            encoderFactory = [[RTCDefaultVideoEncoderFactory alloc] init];
+        }
+        if (decoderFactory == nil) {
+            decoderFactory = [[RTCDefaultVideoDecoderFactory alloc] init];
+        }
+        _encoderFactory = encoderFactory;
+        _decoderFactory = decoderFactory;
+
+        RCTLogInfo(@"Using video encoder factory: %@", NSStringFromClass([encoderFactory class]));
+        RCTLogInfo(@"Using video decoder factory: %@", NSStringFromClass([decoderFactory class]));
+
+        if (audioProcessingModule != nil) {
+            if (audioDevice != nil) {
+                NSLog(@"Both audioProcessingModule and audioDevice are provided, but only one can be used. Ignoring "
+                      @"audioDevice.");
+            }
+            RCTLogInfo(@"Using audio processing module: %@", NSStringFromClass([audioProcessingModule class]));
+            _peerConnectionFactory =
+                [[RTCPeerConnectionFactory alloc] initWithAudioDeviceModuleType:RTCAudioDeviceModuleTypeAudioEngine
+                                                          bypassVoiceProcessing:NO
+                                                                 encoderFactory:encoderFactory
+                                                                 decoderFactory:decoderFactory
+                                                          audioProcessingModule:audioProcessingModule];
+        } else {
+            RCTLogInfo(@"Using audio device: %@", NSStringFromClass([audioDevice class]));
+            _peerConnectionFactory = [[RTCPeerConnectionFactory alloc] initWithEncoderFactory:encoderFactory
+                                                                               decoderFactory:decoderFactory
+                                                                                  audioDevice:audioDevice];
+        }
+
+        _peerConnections = [NSMutableDictionary new];
+        _localStreams = [NSMutableDictionary new];
+        _localTracks = [NSMutableDictionary new];
+
+        _frameCryptors = [NSMutableDictionary new];
+        _keyProviders = [NSMutableDictionary new];
+        _dataPacketCryptors = [NSMutableDictionary new];
+
+        dispatch_queue_attr_t attributes =
+            dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INITIATED, -1);
+        _workerQueue = dispatch_queue_create("WebRTCModule.queue", attributes);
+    }
+
+    return self;
+}
+
+- (RTCMediaStream *)streamForReactTag:(NSString *)reactTag {
+    RTCMediaStream *stream = _localStreams[reactTag];
+    if (!stream) {
+        for (NSNumber *peerConnectionId in _peerConnections) {
+            RTCPeerConnection *peerConnection = _peerConnections[peerConnectionId];
+            stream = peerConnection.remoteStreams[reactTag];
+            if (stream) {
+                break;
+            }
+        }
+    }
+    return stream;
+}
+
+RCT_EXPORT_MODULE();
+
+- (dispatch_queue_t)methodQueue {
+    return _workerQueue;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        kEventPeerConnectionSignalingStateChanged,
+        kEventPeerConnectionStateChanged,
+        kEventPeerConnectionOnRenegotiationNeeded,
+        kEventPeerConnectionIceConnectionChanged,
+        kEventPeerConnectionIceGatheringChanged,
+        kEventPeerConnectionGotICECandidate,
+        kEventPeerConnectionDidOpenDataChannel,
+        kEventDataChannelDidChangeBufferedAmount,
+        kEventDataChannelStateChanged,
+        kEventDataChannelReceiveMessage,
+        kEventMediaStreamTrackMuteChanged,
+        kEventMediaStreamTrackEnded,
+        kEventPeerConnectionOnRemoveTrack,
+        kEventPeerConnectionOnTrack,
+        kEventFrameCryptionStateChanged,
+        kEventPalabraTranscription,
+        kEventPalabraConnectionState,
+        kEventPalabraError
+    ];
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModuleOptions.h

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/WebRTC.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WebRTCModuleOptions : NSObject
+
+@property(nonatomic, strong, nullable) id<RTCVideoDecoderFactory> videoDecoderFactory;
+@property(nonatomic, strong, nullable) id<RTCVideoEncoderFactory> videoEncoderFactory;
+@property(nonatomic, strong, nullable) id<RTCAudioDevice> audioDevice;
+@property(nonatomic, strong, nullable) id<RTCAudioProcessingModule> audioProcessingModule;
+@property(nonatomic, strong, nullable) NSDictionary *fieldTrials;
+@property(nonatomic, assign) RTCLoggingSeverity loggingSeverity;
+@property(nonatomic, assign) BOOL enableMultitaskingCameraAccess;
+
+@property(nonatomic, assign) double defaultTrackVolume;
+
+#pragma mark - This class is a singleton
+
++ (instancetype _Nonnull)sharedInstance;
+
+@end
+
+NS_ASSUME_NONNULL_END