@sbhjt-gr/react-native-webrtc 124.0.0

package/ios/RCTWebRTC/SampleBufferVideoCallView.m

@@ -0,0 +1,178 @@
+#import "SampleBufferVideoCallView.h"
+#import <Accelerate/Accelerate.h>
+#import <WebRTC/WebRTC.h>
+#import "I420Converter.h"
+
+@protocol SampleBufferRendering<AVQueuedSampleBufferRendering>
+
+- (BOOL)requiresFlushToResumeDecoding;
+
+@end
+
+/** These classes already implement the required methods. */
+@interface AVSampleBufferDisplayLayer ()<SampleBufferRendering>
+@end
+@interface AVSampleBufferVideoRenderer ()<SampleBufferRendering>
+@end
+
+@interface SampleBufferVideoCallView ()
+
+@property(nonatomic, retain) I420Converter *i420Converter;
+@property(nonatomic, strong) id<SampleBufferRendering> renderer;
+@property(nonatomic, assign) NSInteger currentRotation;
+
+@end
+
+@implementation SampleBufferVideoCallView
+
++ (Class)layerClass {
+    return [AVSampleBufferDisplayLayer class];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(layerFailedToDecode:)
+                                                     name:AVSampleBufferDisplayLayerFailedToDecodeNotification
+                                                   object:self.sampleBufferLayer];
+        if (@available(iOS 17.0, *)) {
+            _renderer = self.sampleBufferLayer.sampleBufferRenderer;
+        } else {
+            _renderer = self.sampleBufferLayer;
+        }
+    }
+    return self;
+}
+
+- (void)layerFailedToDecode:(NSNotification *)note {
+    NSError *error = [[note userInfo] valueForKey:AVSampleBufferDisplayLayerFailedToDecodeNotificationErrorKey];
+    NSLog(@"layerFailedToDecode, error: %@", [error localizedDescription]);
+}
+
+- (AVSampleBufferDisplayLayer *)sampleBufferLayer {
+    return (AVSampleBufferDisplayLayer *)self.layer;
+}
+
+- (void)requestScaleRecalculation {
+    _currentRotation = -1;
+}
+
+- (void)recalculateScale:(RTCVideoRotation)rotation {
+    if (self.currentRotation != rotation) {
+        self.currentRotation = rotation;
+
+        CGFloat scale = 1;
+        if (rotation == 90 || rotation == 270) {
+            CGSize size = self.bounds.size;
+            scale = size.height / size.width;
+        }
+
+        self.sampleBufferLayer.transform = CATransform3DConcat(
+            CATransform3DMakeRotation(rotation / 180.0 * M_PI, 0.0, 0.0, 1.0), CATransform3DMakeScale(scale, scale, 1));
+    }
+}
+
+/** The size of the video frame. */
+- (void)setSize:(CGSize)size {
+}
+
+/** The frame to be displayed. */
+- (void)renderFrame:(nullable RTC_OBJC_TYPE(RTCVideoFrame) *)frame {
+    if (!_shouldRender) {
+        return;
+    }
+
+    // Convert RTCVideoFrame to CMSampleBuffer
+    CMSampleBufferRef sampleBuffer = [self sampleBufferFrom:frame];
+    if (sampleBuffer == nil) {
+        return;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (self.renderer.requiresFlushToResumeDecoding) {
+            [self.renderer flush];
+        }
+
+        if (!self.renderer.readyForMoreMediaData) {
+            return;
+        }
+
+        [self recalculateScale:frame.rotation];
+
+        // Display the CMSampleBuffer using AVSampleBufferDisplayLayer
+        [self.renderer enqueueSampleBuffer:sampleBuffer];
+        CFRelease(sampleBuffer);
+    });
+}
+
+- (CMSampleBufferRef)sampleBufferFrom:(RTCVideoFrame *)rtcVideoFrame {
+    // Convert RTCVideoFrame to CMSampleBuffer
+
+    // Assuming your RTCVideoFrame contains pixelBuffer
+    CVPixelBufferRef pixelBuffer = [self pixelBufferFrom:rtcVideoFrame];
+    if (!pixelBuffer) {
+        return nil;
+    }
+
+    // Create a CMVideoFormatDescription
+    CMVideoFormatDescriptionRef formatDescription;
+    CMVideoFormatDescriptionCreateForImageBuffer(kCFAllocatorDefault, pixelBuffer, &formatDescription);
+
+    // Create CMSampleTimingInfo
+    // Timescale is 90khz according to RTCVideoFrame.h
+    CMSampleTimingInfo timingInfo;
+    timingInfo.presentationTimeStamp = CMTimeMake(rtcVideoFrame.timeStamp, 90000);
+    timingInfo.decodeTimeStamp = CMTimeMake(rtcVideoFrame.timeStamp, 90000);
+
+    // Create CMSampleBuffer
+    CMSampleBufferRef sampleBuffer;
+    CMSampleBufferCreateForImageBuffer(
+        kCFAllocatorDefault, pixelBuffer, true, nil, nil, formatDescription, &timingInfo, &sampleBuffer);
+
+    CFArrayRef attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, YES);
+    CFMutableDictionaryRef dict = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(attachments, 0);
+
+    CFDictionarySetValue(dict, kCMSampleAttachmentKey_DisplayImmediately, kCFBooleanTrue);
+    CVPixelBufferRelease(pixelBuffer);
+    return sampleBuffer;
+}
+
+/**
+ * The CVPixelBufferRef returned from this function must be released when finished using it.
+ */
+- (CVPixelBufferRef)pixelBufferFrom:(RTCVideoFrame *)videoFrame {
+    if ([videoFrame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
+        CVPixelBufferRef pixelBuffer = [((RTCCVPixelBuffer *)videoFrame.buffer) pixelBuffer];
+        CVPixelBufferRetain(pixelBuffer);
+        return [((RTCCVPixelBuffer *)videoFrame.buffer) pixelBuffer];
+    } else {
+        return [self pixelBufferFromI420:[videoFrame.buffer toI420]];
+    }
+}
+
+/**
+ * The CVPixelBufferRef returned from this function must be released when finished using it.
+ */
+- (CVPixelBufferRef)pixelBufferFromI420:(RTCI420Buffer *)i420Buffer {
+    if (_i420Converter == nil) {
+        I420Converter *converter = [[I420Converter alloc] init];
+        vImage_Error err = [converter prepareForAccelerateConversion];
+
+        if (err != kvImageNoError) {
+            NSLog(@"Error when preparing i420Converter: %ld", err);
+            return NULL;
+        }
+
+        _i420Converter = converter;
+    }
+
+    CVPixelBufferRef convertedPixelBuffer = [_i420Converter convertI420ToPixelBuffer:i420Buffer];
+
+    return convertedPixelBuffer;
+}
+
+- (void)dealloc {
+    [_i420Converter unprepareForAccelerateConversion];
+}
+
+@end

package/ios/RCTWebRTC/ScreenCaptureController.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+#import "CaptureController.h"
+#import "CapturerEventsDelegate.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const kRTCScreensharingSocketFD;
+extern NSString *const kRTCAppGroupIdentifier;
+
+@class ScreenCapturer;
+
+@interface ScreenCaptureController : CaptureController
+
+- (instancetype)initWithCapturer:(nonnull ScreenCapturer *)capturer;
+- (void)startCapture;
+- (void)stopCapture;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/ScreenCaptureController.m

@@ -0,0 +1,83 @@
+#if TARGET_OS_IOS
+
+#import "ScreenCaptureController.h"
+#import "ScreenCapturer.h"
+#import "SocketConnection.h"
+
+NSString *const kRTCScreensharingSocketFD = @"rtc_SSFD";
+NSString *const kRTCAppGroupIdentifier = @"RTCAppGroupIdentifier";
+
+@interface ScreenCaptureController ()
+
+@property(nonatomic, retain) ScreenCapturer *capturer;
+
+@end
+
+@interface ScreenCaptureController (CapturerEventsDelegate)<CapturerEventsDelegate>
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer;
+@end
+
+@interface ScreenCaptureController (Private)
+
+@property(nonatomic, readonly) NSString *appGroupIdentifier;
+
+@end
+
+@implementation ScreenCaptureController
+
+- (instancetype)initWithCapturer:(nonnull ScreenCapturer *)capturer {
+    self = [super init];
+    if (self) {
+        self.capturer = capturer;
+        self.deviceId = @"screen-capture";
+    }
+
+    return self;
+}
+
+- (void)dealloc {
+    [self.capturer stopCapture];
+}
+
+- (void)startCapture {
+    if (!self.appGroupIdentifier) {
+        return;
+    }
+
+    self.capturer.eventsDelegate = self;
+    NSString *socketFilePath = [self filePathForApplicationGroupIdentifier:self.appGroupIdentifier];
+    SocketConnection *connection = [[SocketConnection alloc] initWithFilePath:socketFilePath];
+    [self.capturer startCaptureWithConnection:connection];
+}
+
+- (void)stopCapture {
+    [self.capturer stopCapture];
+}
+
+- (NSDictionary *)getSettings {
+    return @{@"deviceId" : self.deviceId, @"groupId" : @"", @"frameRate" : @(30)};
+}
+// MARK: CapturerEventsDelegate Methods
+
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer {
+    [self.eventsDelegate capturerDidEnd:capturer];
+}
+
+// MARK: Private Methods
+
+- (NSString *)appGroupIdentifier {
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    return infoDictionary[kRTCAppGroupIdentifier];
+}
+
+- (NSString *)filePathForApplicationGroupIdentifier:(nonnull NSString *)identifier {
+    NSURL *sharedContainer =
+        [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:identifier];
+    NSString *socketFilePath = [[sharedContainer URLByAppendingPathComponent:kRTCScreensharingSocketFD] path];
+
+    return socketFilePath;
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/ScreenCapturePickerViewManager.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+API_AVAILABLE(ios(12))
+@interface ScreenCapturePickerViewManager : RCTViewManager
+
+@end

package/ios/RCTWebRTC/ScreenCapturePickerViewManager.m

@@ -0,0 +1,60 @@
+#if TARGET_OS_IOS
+
+#import <React/RCTUIManager.h>
+#import <ReplayKit/ReplayKit.h>
+
+#import "ScreenCapturePickerViewManager.h"
+
+NSString *const kRTCScreenSharingExtension = @"RTCScreenSharingExtension";
+
+@implementation ScreenCapturePickerViewManager {
+    RPSystemBroadcastPickerView *_broadcastPickerView;
+}
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view {
+    _broadcastPickerView = [[RPSystemBroadcastPickerView alloc] init];
+    _broadcastPickerView.preferredExtension = self.preferredExtension;
+    _broadcastPickerView.showsMicrophoneButton = false;
+    _broadcastPickerView.userInteractionEnabled = false;
+
+    return _broadcastPickerView;
+}
+
+// MARK: Private Methods
+
+- (NSString *)preferredExtension {
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    return infoDictionary[kRTCScreenSharingExtension];
+}
+
+RCT_EXPORT_METHOD(show : (nonnull NSNumber *)reactTag) {
+    [self.bridge.uiManager
+        addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            id view = viewRegistry[reactTag];
+            if (![view isKindOfClass:[RPSystemBroadcastPickerView class]]) {
+                RCTLogError(@"Invalid view returned from registry, expecting "
+                            @"RPSystemBroadcastPickerView, got: %@",
+                            view);
+            } else {
+                // Simulate a click
+                UIButton *btn = nil;
+
+                for (UIView *subview in ((RPSystemBroadcastPickerView *)view).subviews) {
+                    if ([subview isKindOfClass:[UIButton class]]) {
+                        btn = (UIButton *)subview;
+                    }
+                }
+                if (btn != nil) {
+                    [btn sendActionsForControlEvents:UIControlEventTouchUpInside];
+                } else {
+                    RCTLogError(@"RPSystemBroadcastPickerView button not found");
+                }
+            }
+        }];
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/ScreenCapturer.h

@@ -0,0 +1,19 @@
+#import <AVFoundation/AVFoundation.h>
+#import <WebRTC/RTCVideoCapturer.h>
+#import "CapturerEventsDelegate.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SocketConnection;
+
+@interface ScreenCapturer : RTCVideoCapturer
+
+@property(nonatomic, weak) id<CapturerEventsDelegate> eventsDelegate;
+
+- (instancetype)initWithDelegate:(__weak id<RTCVideoCapturerDelegate>)delegate;
+- (void)startCaptureWithConnection:(nonnull SocketConnection *)connection;
+- (void)stopCapture;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/ScreenCapturer.m

@@ -0,0 +1,264 @@
+#if TARGET_OS_IOS
+
+#include <mach/mach_time.h>
+
+#import <ReplayKit/ReplayKit.h>
+#import <WebRTC/RTCCVPixelBuffer.h>
+#import <WebRTC/RTCVideoFrameBuffer.h>
+
+#import "ScreenCapturer.h"
+#import "SocketConnection.h"
+
+const NSUInteger kMaxReadLength = 10 * 1024;
+
+@interface Message : NSObject
+
+@property(nonatomic, assign, readonly) CVImageBufferRef imageBuffer;
+@property(nonatomic, copy, nullable) void (^didComplete)(BOOL succes, Message *message);
+
+- (NSInteger)appendBytes:(UInt8 *)buffer length:(NSUInteger)length;
+
+@end
+
+@interface Message ()
+
+@property(nonatomic, assign) CVImageBufferRef imageBuffer;
+@property(nonatomic, assign) int imageOrientation;
+@property(nonatomic, assign) CFHTTPMessageRef framedMessage;
+
+@end
+
+@implementation Message
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        self.imageBuffer = NULL;
+    }
+
+    return self;
+}
+
+- (void)dealloc {
+    CVPixelBufferRelease(_imageBuffer);
+}
+
+/** Returns the amount of missing bytes to complete the message, or -1 when not enough bytes were provided to compute
+ * the message length */
+- (NSInteger)appendBytes:(UInt8 *)buffer length:(NSUInteger)length {
+    if (!_framedMessage) {
+        _framedMessage = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false);
+    }
+
+    CFHTTPMessageAppendBytes(_framedMessage, buffer, length);
+    if (!CFHTTPMessageIsHeaderComplete(_framedMessage)) {
+        return -1;
+    }
+
+    NSInteger contentLength =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Content-Length"))
+            integerValue];
+    NSInteger bodyLength = (NSInteger)[CFBridgingRelease(CFHTTPMessageCopyBody(_framedMessage)) length];
+
+    NSInteger missingBytesCount = contentLength - bodyLength;
+    if (missingBytesCount == 0) {
+        BOOL success = [self unwrapMessage:self.framedMessage];
+        self.didComplete(success, self);
+
+        CFRelease(self.framedMessage);
+        self.framedMessage = NULL;
+    }
+
+    return missingBytesCount;
+}
+
+// MARK: Private Methods
+
+- (CIContext *)imageContext {
+    // Initializing a CIContext object is costly, so we use a singleton instead
+    static CIContext *imageContext = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        imageContext = [[CIContext alloc] initWithOptions:nil];
+    });
+
+    return imageContext;
+}
+
+- (BOOL)unwrapMessage:(CFHTTPMessageRef)framedMessage {
+    size_t width =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Width"))
+            integerValue];
+    size_t height =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Height"))
+            integerValue];
+    _imageOrientation = [CFBridgingRelease(
+        CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Orientation")) intValue];
+
+    NSData *messageData = CFBridgingRelease(CFHTTPMessageCopyBody(_framedMessage));
+
+    // Copy the pixel buffer
+    CVReturn status =
+        CVPixelBufferCreate(kCFAllocatorDefault, width, height, kCVPixelFormatType_32BGRA, NULL, &_imageBuffer);
+    if (status != kCVReturnSuccess) {
+        NSLog(@"CVPixelBufferCreate failed");
+        return false;
+    }
+
+    [self copyImageData:messageData toPixelBuffer:&_imageBuffer];
+
+    return true;
+}
+
+- (void)copyImageData:(NSData *)data toPixelBuffer:(CVPixelBufferRef *)pixelBuffer {
+    CVPixelBufferLockBaseAddress(*pixelBuffer, 0);
+
+    CIImage *image = [CIImage imageWithData:data];
+    [self.imageContext render:image toCVPixelBuffer:*pixelBuffer];
+
+    CVPixelBufferUnlockBaseAddress(*pixelBuffer, 0);
+}
+
+@end
+
+// MARK: -
+
+@interface ScreenCapturer ()<NSStreamDelegate>
+
+@property(nonatomic, strong) SocketConnection *connection;
+@property(nonatomic, strong) Message *message;
+
+@end
+
+@implementation ScreenCapturer {
+    mach_timebase_info_data_t _timebaseInfo;
+    NSInteger _readLength;
+    int64_t _startTimeStampNs;
+}
+
+- (instancetype)initWithDelegate:(__weak id<RTCVideoCapturerDelegate>)delegate {
+    self = [super initWithDelegate:delegate];
+    if (self) {
+        mach_timebase_info(&_timebaseInfo);
+    }
+
+    return self;
+}
+
+- (void)setConnection:(SocketConnection *)connection {
+    if (_connection != connection) {
+        [_connection close];
+        _connection = connection;
+    }
+}
+
+- (void)startCaptureWithConnection:(SocketConnection *)connection {
+    _startTimeStampNs = -1;
+
+    self.connection = connection;
+    self.message = nil;
+
+    [self.connection openWithStreamDelegate:self];
+}
+
+- (void)stopCapture {
+    self.connection = nil;
+}
+
+// MARK: Private Methods
+
+- (void)readBytesFromStream:(NSInputStream *)stream {
+    if (!stream.hasBytesAvailable) {
+        return;
+    }
+
+    if (!self.message) {
+        self.message = [[Message alloc] init];
+        _readLength = kMaxReadLength;
+
+        __weak __typeof__(self) weakSelf = self;
+        self.message.didComplete = ^(BOOL success, Message *message) {
+            if (success) {
+                [weakSelf didCaptureVideoFrame:message.imageBuffer withOrientation:message.imageOrientation];
+            }
+
+            weakSelf.message = nil;
+        };
+    }
+
+    uint8_t buffer[_readLength];
+    NSInteger numberOfBytesRead = [stream read:buffer maxLength:_readLength];
+    if (numberOfBytesRead < 0) {
+        NSLog(@"error reading bytes from stream");
+        return;
+    }
+
+    _readLength = [self.message appendBytes:buffer length:numberOfBytesRead];
+    if (_readLength == -1 || _readLength > kMaxReadLength) {
+        _readLength = kMaxReadLength;
+    }
+}
+
+- (void)didCaptureVideoFrame:(CVPixelBufferRef)pixelBuffer withOrientation:(CGImagePropertyOrientation)orientation {
+    int64_t currentTime = mach_absolute_time();
+    int64_t currentTimeStampNs = currentTime * _timebaseInfo.numer / _timebaseInfo.denom;
+
+    if (_startTimeStampNs < 0) {
+        _startTimeStampNs = currentTimeStampNs;
+    }
+
+    RTCCVPixelBuffer *rtcPixelBuffer = [[RTCCVPixelBuffer alloc] initWithPixelBuffer:pixelBuffer];
+    int64_t frameTimeStampNs = currentTimeStampNs - _startTimeStampNs;
+
+    RTCVideoRotation rotation;
+    switch (orientation) {
+        case kCGImagePropertyOrientationLeft:
+            rotation = RTCVideoRotation_90;
+            break;
+        case kCGImagePropertyOrientationDown:
+            rotation = RTCVideoRotation_180;
+            break;
+        case kCGImagePropertyOrientationRight:
+            rotation = RTCVideoRotation_270;
+            break;
+        default:
+            rotation = RTCVideoRotation_0;
+            break;
+    }
+
+    RTCVideoFrame *videoFrame = [[RTCVideoFrame alloc] initWithBuffer:rtcPixelBuffer
+                                                             rotation:rotation
+                                                          timeStampNs:frameTimeStampNs];
+
+    [self.delegate capturer:self didCaptureVideoFrame:videoFrame];
+}
+
+@end
+
+@implementation ScreenCapturer (NSStreamDelegate)
+
+- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode {
+    switch (eventCode) {
+        case NSStreamEventOpenCompleted:
+            NSLog(@"server stream open completed");
+            break;
+        case NSStreamEventHasBytesAvailable:
+            [self readBytesFromStream:(NSInputStream *)aStream];
+            break;
+        case NSStreamEventEndEncountered:
+            NSLog(@"server stream end encountered");
+            [self stopCapture];
+            [self.eventsDelegate capturerDidEnd:self];
+            break;
+        case NSStreamEventErrorOccurred:
+            NSLog(@"server stream error encountered: %@", aStream.streamError.localizedDescription);
+            break;
+
+        default:
+            break;
+    }
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/SerializeUtils.h

@@ -0,0 +1,28 @@
+#import <WebRTC/RTCMediaStreamTrack.h>
+#import <WebRTC/RTCPeerConnectionFactory.h>
+#import <WebRTC/RTCRtpReceiver.h>
+#import <WebRTC/RTCRtpTransceiver.h>
+#import <WebRTC/RTCVideoCodecInfo.h>
+#import "WebRTCModule+RTCPeerConnection.h"
+
+@interface SerializeUtils : NSObject
+
++ (NSString *_Nonnull)transceiverToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                transceiver:(RTCRtpTransceiver *_Nonnull)transceiver;
++ (NSDictionary *_Nonnull)senderToJSONWithPeerConnectionId:(nonnull NSNumber *)id sender:(RTCRtpSender *_Nonnull)sender;
++ (NSDictionary *_Nonnull)receiverToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                    receiver:(RTCRtpReceiver *_Nonnull)receiver;
++ (NSDictionary *_Nonnull)trackToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                    track:(RTCMediaStreamTrack *_Nonnull)track;
++ (NSDictionary *_Nonnull)capabilitiesToJSON:(RTCRtpCapabilities *_Nonnull)capabilities;
++ (NSDictionary *_Nonnull)codecCapabilityToJSON:(RTCRtpCodecCapability *_Nonnull)codec;
++ (NSString *_Nonnull)serializeDirection:(RTCRtpTransceiverDirection)direction;
++ (RTCRtpTransceiverDirection)parseDirection:(NSString *_Nonnull)direction;
++ (RTCRtpTransceiverInit *_Nonnull)parseTransceiverOptions:(NSDictionary *_Nonnull)parameters;
++ (NSDictionary *_Nonnull)parametersToJSON:(RTCRtpParameters *_Nonnull)parameters;
++ (NSMutableArray *_Nonnull)constructTransceiversInfoArrayWithPeerConnection:
+    (RTCPeerConnection *_Nonnull)peerConnection;
++ (NSDictionary *_Nonnull)streamToJSONWithPeerConnectionId:(NSNumber *_Nonnull)id
+                                                    stream:(RTCMediaStream *_Nonnull)stream
+                                            streamReactTag:(NSString *_Nonnull)streamReactTag;
+@end