@sbhjt-gr/react-native-webrtc 124.0.0

package/ios/RCTWebRTC/SerializeUtils.m

@@ -0,0 +1,314 @@
+#import "SerializeUtils.h"
+
+@implementation SerializeUtils
++ (NSDictionary *)transceiverToJSONWithPeerConnectionId:(NSNumber *)id
+                                            transceiver:(RTCRtpTransceiver *_Nonnull)transceiver {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+
+    result[@"id"] = transceiver.sender.senderId;
+    result[@"peerConnectionId"] = id;
+    result[@"mid"] = transceiver.mid;
+    result[@"direction"] = [SerializeUtils serializeDirection:transceiver.direction];
+
+    RTCRtpTransceiverDirection currentDirection;
+    if ([transceiver currentDirection:&currentDirection]) {
+        result[@"currentDirection"] = [SerializeUtils serializeDirection:currentDirection];
+    }
+
+    result[@"isStopped"] = [NSNumber numberWithBool:transceiver.isStopped];
+    result[@"receiver"] = [SerializeUtils receiverToJSONWithPeerConnectionId:id receiver:transceiver.receiver];
+    result[@"sender"] = [SerializeUtils senderToJSONWithPeerConnectionId:id sender:transceiver.sender];
+
+    return result;
+}
+
++ (NSMutableArray *)constructTransceiversInfoArrayWithPeerConnection:(RTCPeerConnection *)peerConnection {
+    NSMutableArray *transceiverUpdates = [NSMutableArray new];
+
+    for (RTCRtpTransceiver *transceiver in peerConnection.transceivers) {
+        NSMutableDictionary *transceiverUpdate = [NSMutableDictionary new];
+
+        RTCRtpTransceiverDirection currentDirection;
+        BOOL hasCurrentDirection = [transceiver currentDirection:&currentDirection];
+        if (hasCurrentDirection) {
+            NSString *currentDirectionSerialized = [SerializeUtils serializeDirection:currentDirection];
+            transceiverUpdate[@"currentDirection"] = currentDirectionSerialized;
+        }
+
+        transceiverUpdate[@"transceiverId"] = transceiver.sender.senderId;
+        transceiverUpdate[@"mid"] = transceiver.mid;
+        transceiverUpdate[@"isStopped"] = [NSNumber numberWithBool:transceiver.isStopped];
+        transceiverUpdate[@"senderRtpParameters"] = [SerializeUtils parametersToJSON:transceiver.sender.parameters];
+        transceiverUpdate[@"receiverRtpParameters"] = [SerializeUtils parametersToJSON:transceiver.receiver.parameters];
+
+        [transceiverUpdates addObject:transceiverUpdate];
+    }
+
+    return transceiverUpdates;
+}
+
++ (NSDictionary *)senderToJSONWithPeerConnectionId:(NSNumber *)id sender:(RTCRtpSender *)sender {
+    NSMutableDictionary *senderDictionary = [NSMutableDictionary new];
+    senderDictionary[@"id"] = sender.senderId;
+    senderDictionary[@"peerConnectionId"] = id;
+
+    if (sender.track) {
+        senderDictionary[@"track"] = [SerializeUtils trackToJSONWithPeerConnectionId:id track:sender.track];
+    }
+
+    senderDictionary[@"rtpParameters"] = [SerializeUtils parametersToJSON:sender.parameters];
+
+    return senderDictionary;
+}
+
++ (NSDictionary *)receiverToJSONWithPeerConnectionId:(NSNumber *)id receiver:(RTCRtpReceiver *)receiver {
+    NSMutableDictionary *receiverDictionary = [NSMutableDictionary new];
+    receiverDictionary[@"id"] = receiver.receiverId;
+    receiverDictionary[@"peerConnectionId"] = id;
+
+    if (receiver.track) {
+        receiverDictionary[@"track"] = [SerializeUtils trackToJSONWithPeerConnectionId:id track:receiver.track];
+    }
+
+    receiverDictionary[@"rtpParameters"] = [SerializeUtils parametersToJSON:receiver.parameters];
+
+    return receiverDictionary;
+}
+
++ (NSDictionary *)parametersToJSON:(RTCRtpParameters *)params {
+    NSMutableDictionary *paramsDictionary = [NSMutableDictionary new];
+
+    NSMutableDictionary *rtcpDictionary = [NSMutableDictionary new];
+    rtcpDictionary[@"cname"] = params.rtcp.cname;
+    rtcpDictionary[@"reducedSize"] = [NSNumber numberWithBool:params.rtcp.isReducedSize];
+
+    NSMutableArray *headerExtensions = [NSMutableArray new];
+
+    for (RTCRtpHeaderExtension *extension in params.headerExtensions) {
+        NSMutableDictionary *extensionDictionary = [NSMutableDictionary new];
+        extensionDictionary[@"id"] = [NSNumber numberWithInt:extension.id];
+        extensionDictionary[@"uri"] = extension.uri;
+        extensionDictionary[@"encrypted"] = [NSNumber numberWithBool:extension.isEncrypted];
+
+        [headerExtensions addObject:extensionDictionary];
+    }
+
+    NSMutableArray *encodings = [NSMutableArray new];
+
+    for (RTCRtpEncodingParameters *encoding in params.encodings) {
+        NSMutableDictionary *encodingDictionary = [NSMutableDictionary new];
+
+        encodingDictionary[@"active"] = [NSNumber numberWithBool:encoding.isActive];
+
+        if (encoding.rid) {
+            encodingDictionary[@"rid"] = encoding.rid;
+        }
+        if (encoding.maxBitrateBps) {
+            encodingDictionary[@"maxBitrate"] = encoding.maxBitrateBps;
+        }
+        if (encoding.maxFramerate) {
+            encodingDictionary[@"maxFramerate"] = encoding.maxFramerate;
+        }
+        if (encoding.scaleResolutionDownBy) {
+            encodingDictionary[@"scaleResolutionDownBy"] = encoding.scaleResolutionDownBy;
+        }
+
+        [encodings addObject:encodingDictionary];
+    }
+
+    NSMutableArray *codecs = [NSMutableArray new];
+
+    for (RTCRtpCodecParameters *codec in params.codecs) {
+        NSMutableDictionary *codecDictionary = [NSMutableDictionary new];
+
+        codecDictionary[@"payloadType"] = [NSNumber numberWithInt:codec.payloadType];
+        codecDictionary[@"mimeType"] = codec.name;
+        codecDictionary[@"clockRate"] = codec.clockRate;
+
+        if (codec.numChannels) {
+            codecDictionary[@"channels"] = codec.numChannels;
+        }
+
+        if (codec.parameters.count) {
+            codecDictionary[@"sdpFmtpLine"] = [self serializeSdpParameters:codec.parameters];
+        }
+
+        [codecs addObject:codecDictionary];
+    }
+
+    paramsDictionary[@"transactionId"] = params.transactionId;
+    paramsDictionary[@"rtcp"] = rtcpDictionary;
+    paramsDictionary[@"headerExtensions"] = headerExtensions;
+    paramsDictionary[@"encodings"] = encodings;
+    paramsDictionary[@"codecs"] = codecs;
+
+    if (params.degradationPreference) {
+        paramsDictionary[@"degradationPreference"] = params.degradationPreference;
+    }
+
+    return paramsDictionary;
+}
+
++ (NSDictionary *)trackToJSONWithPeerConnectionId:(NSNumber *)id track:(RTCMediaStreamTrack *)track {
+    NSString *readyState;
+    switch (track.readyState) {
+        case RTCMediaStreamTrackStateLive:
+            readyState = @"live";
+            break;
+        case RTCMediaStreamTrackStateEnded:
+            readyState = @"ended";
+            break;
+    }
+
+    return @{
+        @"id" : track.trackId,
+        @"peerConnectionId" : id,
+        @"kind" : track.kind,
+        @"enabled" : [NSNumber numberWithBool:track.isEnabled],
+        @"readyState" : readyState,
+        @"remote" : [NSNumber numberWithBool:YES],
+    };
+}
+
++ (NSDictionary *)capabilitiesToJSON:(RTCRtpCapabilities *)capabilities {
+    NSMutableArray *codecs = [NSMutableArray new];
+
+    for (RTCRtpCodecCapability *codec in capabilities.codecs) {
+        [codecs addObject:[self codecCapabilityToJSON:codec]];
+    }
+
+    return @{@"codecs" : codecs};
+}
+
++ (NSDictionary *)codecCapabilityToJSON:(RTCRtpCodecCapability *)codec {
+    NSMutableDictionary *codecDictionary = [NSMutableDictionary new];
+
+    codecDictionary[@"payloadType"] = codec.preferredPayloadType;
+    codecDictionary[@"mimeType"] = codec.mimeType;
+    codecDictionary[@"clockRate"] = codec.clockRate;
+
+    if (codec.numChannels) {
+        codecDictionary[@"channels"] = codec.numChannels;
+    }
+
+    if (codec.parameters.count) {
+        codecDictionary[@"sdpFmtpLine"] = [self serializeSdpParameters:codec.parameters];
+    }
+
+    return codecDictionary;
+}
+
++ (NSString *)serializeSdpParameters:(NSDictionary *)parameters {
+    if (parameters == nil || parameters.count == 0) {
+        return nil;
+    }
+
+    NSMutableArray *parts = [NSMutableArray arrayWithCapacity:parameters.count];
+    [parameters enumerateKeysAndObjectsUsingBlock:^(id _Nonnull key, id _Nonnull value, BOOL *_Nonnull stop) {
+        [parts addObject:[NSString stringWithFormat:@"%@=%@", key, value]];
+    }];
+
+    return [parts componentsJoinedByString:@";"];
+}
+
++ (NSString *)serializeDirection:(RTCRtpTransceiverDirection)direction {
+    if (direction == RTCRtpTransceiverDirectionInactive) {
+        return @"inactive";
+    } else if (direction == RTCRtpTransceiverDirectionRecvOnly) {
+        return @"recvonly";
+    } else if (direction == RTCRtpTransceiverDirectionSendOnly) {
+        return @"sendonly";
+    } else if (direction == RTCRtpTransceiverDirectionSendRecv) {
+        return @"sendrecv";
+    } else if (direction == RTCRtpTransceiverDirectionStopped) {
+        return @"stopped";
+    }
+    return nil;
+}
+
++ (RTCRtpTransceiverDirection)parseDirection:(NSString *)direction {
+    if ([direction isEqual:@"inactive"]) {
+        return RTCRtpTransceiverDirectionInactive;
+    } else if ([direction isEqual:@"recvonly"]) {
+        return RTCRtpTransceiverDirectionRecvOnly;
+    } else if ([direction isEqual:@"sendonly"]) {
+        return RTCRtpTransceiverDirectionSendOnly;
+    } else if ([direction isEqual:@"sendrecv"]) {
+        return RTCRtpTransceiverDirectionSendRecv;
+    } else if ([direction isEqual:@"stopped"]) {
+        return RTCRtpTransceiverDirectionStopped;
+    }
+
+    return RTCRtpTransceiverDirectionInactive;
+}
+
++ (RTCRtpEncodingParameters *)parseEncoding:(NSDictionary *)params {
+    RTCRtpEncodingParameters *encoding = [RTCRtpEncodingParameters new];
+
+    if (params[@"rid"] != nil) {
+        [encoding setRid:params[@"rid"]];
+    }
+    if (params[@"active"] != nil) {
+        [encoding setIsActive:((NSNumber *)params[@"active"]).boolValue];
+    }
+    if (params[@"maxBitrate"] != nil) {
+        [encoding setMaxBitrateBps:(NSNumber *)params[@"maxBitrate"]];
+    }
+    if (params[@"maxFramerate"] != nil) {
+        [encoding setMaxFramerate:(NSNumber *)params[@"maxFramerate"]];
+    }
+    if (params[@"scaleResolutionDownBy"] != nil) {
+        [encoding setScaleResolutionDownBy:(NSNumber *)params[@"scaleResolutionDownBy"]];
+    }
+
+    return encoding;
+}
+
++ (RTCRtpTransceiverInit *)parseTransceiverOptions:(NSDictionary *)params {
+    RTCRtpTransceiverInit *transceiverInit = [RTCRtpTransceiverInit new];
+
+    NSString *direction = [params objectForKey:@"direction"];
+    if (direction) {
+        [transceiverInit setDirection:[SerializeUtils parseDirection:direction]];
+    }
+
+    NSArray *streamIds = [params objectForKey:@"streamIds"];
+    if (streamIds) {
+        [transceiverInit setStreamIds:streamIds];
+    }
+
+    NSArray *encodingsArray = [params objectForKey:@"sendEncodings"];
+    if (encodingsArray) {
+        NSMutableArray<RTCRtpEncodingParameters *> *sendEncodings = [NSMutableArray new];
+        for (NSDictionary *encoding in encodingsArray) {
+            [sendEncodings addObject:[self parseEncoding:encoding]];
+        }
+        [transceiverInit setSendEncodings:sendEncodings];
+    }
+
+    return transceiverInit;
+}
+
++ (NSDictionary *)streamToJSONWithPeerConnectionId:(NSNumber *)id
+                                            stream:(RTCMediaStream *)stream
+                                    streamReactTag:(NSString *)streamReactTag {
+    NSMutableDictionary *streamDictionary = [NSMutableDictionary new];
+
+    streamDictionary[@"streamId"] = stream.streamId;
+    streamDictionary[@"streamReactTag"] = streamReactTag;
+
+    NSMutableArray *tracks = [NSMutableArray new];
+
+    for (RTCAudioTrack *audioTrack in stream.audioTracks) {
+        [tracks addObject:[SerializeUtils trackToJSONWithPeerConnectionId:id track:audioTrack]];
+    }
+
+    for (RTCVideoTrack *videoTrack in stream.videoTracks) {
+        [tracks addObject:[SerializeUtils trackToJSONWithPeerConnectionId:id track:videoTrack]];
+    }
+
+    streamDictionary[@"tracks"] = tracks;
+
+    return streamDictionary;
+}
+@end

package/ios/RCTWebRTC/SocketConnection.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SocketConnection : NSObject
+
+- (instancetype)initWithFilePath:(nonnull NSString *)filePath;
+- (void)openWithStreamDelegate:(id<NSStreamDelegate>)streamDelegate;
+- (void)close;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/SocketConnection.m

@@ -0,0 +1,137 @@
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#import "SocketConnection.h"
+
+@interface SocketConnection ()
+
+@property(nonatomic, assign) int serverSocket;
+@property(nonatomic, strong) dispatch_source_t listeningSource;
+
+@property(nonatomic, strong) NSThread *networkThread;
+
+@property(nonatomic, strong) NSInputStream *inputStream;
+@property(nonatomic, strong) NSOutputStream *outputStream;
+
+@end
+
+@implementation SocketConnection
+
+- (instancetype)initWithFilePath:(nonnull NSString *)filePath {
+    self = [super init];
+
+    [self setupNetworkThread];
+
+    self.serverSocket = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (self.serverSocket < 0) {
+        NSLog(@"failure creating socket");
+        return nil;
+    }
+
+    if (![self setupSocketWithFileAtPath:filePath]) {
+        close(self.serverSocket);
+        return nil;
+    }
+
+    return self;
+}
+
+- (void)openWithStreamDelegate:(id<NSStreamDelegate>)streamDelegate {
+    int status = listen(self.serverSocket, 10);
+    if (status < 0) {
+        NSLog(@"failure: socket listening");
+        return;
+    }
+
+    dispatch_source_t listeningSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, self.serverSocket, 0, NULL);
+    dispatch_source_set_event_handler(listeningSource, ^{
+        int clientSocket = accept(self.serverSocket, NULL, NULL);
+        if (clientSocket < 0) {
+            NSLog(@"failure accepting connection");
+            return;
+        }
+
+        CFReadStreamRef readStream;
+        CFWriteStreamRef writeStream;
+
+        CFStreamCreatePairWithSocket(kCFAllocatorDefault, clientSocket, &readStream, &writeStream);
+
+        self.inputStream = (__bridge_transfer NSInputStream *)readStream;
+        self.inputStream.delegate = streamDelegate;
+        [self.inputStream setProperty:@"kCFBooleanTrue" forKey:@"kCFStreamPropertyShouldCloseNativeSocket"];
+
+        self.outputStream = (__bridge_transfer NSOutputStream *)writeStream;
+        [self.outputStream setProperty:@"kCFBooleanTrue" forKey:@"kCFStreamPropertyShouldCloseNativeSocket"];
+
+        [self.networkThread start];
+        [self performSelector:@selector(scheduleStreams) onThread:self.networkThread withObject:nil waitUntilDone:true];
+
+        [self.inputStream open];
+        [self.outputStream open];
+    });
+
+    self.listeningSource = listeningSource;
+    dispatch_resume(listeningSource);
+}
+
+- (void)close {
+    [self performSelector:@selector(unscheduleStreams) onThread:self.networkThread withObject:nil waitUntilDone:true];
+
+    self.inputStream.delegate = nil;
+    self.outputStream.delegate = nil;
+
+    [self.inputStream close];
+    [self.outputStream close];
+
+    [self.networkThread cancel];
+
+    dispatch_source_cancel(self.listeningSource);
+    close(self.serverSocket);
+}
+
+// MARK: - Private Methods
+
+- (void)setupNetworkThread {
+    self.networkThread = [[NSThread alloc] initWithBlock:^{
+        do {
+            @autoreleasepool {
+                [[NSRunLoop currentRunLoop] run];
+            }
+        } while (![NSThread currentThread].isCancelled);
+    }];
+    self.networkThread.qualityOfService = NSQualityOfServiceUserInitiated;
+}
+
+- (BOOL)setupSocketWithFileAtPath:(NSString *)filePath {
+    struct sockaddr_un addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+
+    if (filePath.length > sizeof(addr.sun_path)) {
+        NSLog(@"failure: path too long");
+        return false;
+    }
+
+    unlink(filePath.UTF8String);
+    strncpy(addr.sun_path, filePath.UTF8String, sizeof(addr.sun_path) - 1);
+
+    int status = bind(self.serverSocket, (struct sockaddr *)&addr, sizeof(addr));
+    if (status < 0) {
+        NSLog(@"failure: socket binding");
+        return false;
+    }
+
+    return true;
+}
+
+- (void)scheduleStreams {
+    [self.inputStream scheduleInRunLoop:NSRunLoop.currentRunLoop forMode:NSRunLoopCommonModes];
+    [self.outputStream scheduleInRunLoop:NSRunLoop.currentRunLoop forMode:NSRunLoopCommonModes];
+}
+
+- (void)unscheduleStreams {
+    [self.inputStream removeFromRunLoop:NSRunLoop.currentRunLoop forMode:NSRunLoopCommonModes];
+    [self.outputStream removeFromRunLoop:NSRunLoop.currentRunLoop forMode:NSRunLoopCommonModes];
+}
+
+@end

package/ios/RCTWebRTC/TrackCapturerEventsEmitter.h

@@ -0,0 +1,14 @@
+#import "CaptureController.h"
+#import "CapturerEventsDelegate.h"
+#import "WebRTCModule.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TrackCapturerEventsEmitter : NSObject<CapturerEventsDelegate>
+
+- (instancetype)initWith:(NSString *)trackId webRTCModule:(WebRTCModule *)module;
+
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/TrackCapturerEventsEmitter.m

@@ -0,0 +1,37 @@
+#import "TrackCapturerEventsEmitter.h"
+#import "CapturerEventsDelegate.h"
+#import "WebRTCModule.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TrackCapturerEventsEmitter ()
+
+@property(copy, nonatomic) NSString *trackId;
+@property(weak, nonatomic) WebRTCModule *module;
+
+@end
+
+@implementation TrackCapturerEventsEmitter
+
+- (instancetype)initWith:(NSString *)trackId webRTCModule:(WebRTCModule *)module {
+    self = [super init];
+    if (self) {
+        self.trackId = trackId;
+        self.module = module;
+    }
+
+    return self;
+}
+
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer {
+    [self.module sendEventWithName:kEventMediaStreamTrackEnded
+                              body:@{
+                                  @"trackId" : self.trackId,
+                              }];
+
+    RCTLog(@"[TrackCapturerEventsEmitter] ended event for track %@", self.trackId);
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/VideoCaptureController.h

@@ -0,0 +1,21 @@
+#if !TARGET_OS_TV
+
+#import <Foundation/Foundation.h>
+#import <WebRTC/RTCCameraVideoCapturer.h>
+
+#import "CaptureController.h"
+
+@interface VideoCaptureController : CaptureController
+@property(nonatomic, readonly, strong) RTCCameraVideoCapturer *capturer;
+@property(nonatomic, readonly, strong) AVCaptureDeviceFormat *selectedFormat;
+@property(nonatomic, readonly, assign) int frameRate;
+@property(nonatomic, assign) BOOL enableMultitaskingCameraAccess;
+
+- (instancetype)initWithCapturer:(RTCCameraVideoCapturer *)capturer andConstraints:(NSDictionary *)constraints;
+- (void)startCapture;
+- (void)stopCapture;
+- (void)switchCamera;
+- (void)applyConstraints:(NSDictionary *)constraints error:(NSError **)outError;
+
+@end
+#endif