@sbhjt-gr/react-native-webrtc 137.0.2

package/ios/RCTWebRTC/I420Converter.m

@@ -0,0 +1,164 @@
+//
+//  I420Converter.m
+//  VideoSampleCaptureRender
+//
+//  Adapted from:
+//  https://github.com/twilio/video-ios-affectiva/blob/ed2e864324c40ad25e5a06cc2b05298b03caed09/EmoCall/I420Converter.m
+//  Created by Boisy Pitre on 5/21/16.
+//  Copyright © 2016 Twilio. All rights reserved.
+//
+
+#import "I420Converter.h"
+
+@interface I420Converter ()
+
+@property(nonatomic, assign) vImage_YpCbCrToARGB *conversionInfo;
+@property(nonatomic, assign) CVPixelBufferPoolRef pixelBufferPool;
+@property(nonatomic, assign) size_t poolWidth;
+@property(nonatomic, assign) size_t poolHeight;
+@end
+
+@implementation I420Converter
+
+- (vImage_Error)prepareForAccelerateConversion {
+    // Setup the YpCbCr to ARGB conversion.
+    if (_conversionInfo != NULL) {
+        return kvImageNoError;
+    }
+
+    // I420 uses limited range.
+    vImage_YpCbCrPixelRange pixelRange = {16, 128, 235, 240, 255, 0, 255, 0};
+    vImage_YpCbCrToARGB *outInfo = malloc(sizeof(vImage_YpCbCrToARGB));
+    vImageYpCbCrType inType = kvImage420Yp8_Cb8_Cr8;
+    vImageARGBType outType = kvImageARGB8888;
+
+    vImage_Error error = vImageConvert_YpCbCrToARGB_GenerateConversion(kvImage_YpCbCrToARGBMatrix_ITU_R_601_4,
+                                                                       &pixelRange,
+                                                                       outInfo,
+                                                                       inType,
+                                                                       outType,
+                                                                       kvImagePrintDiagnosticsToConsole);
+
+    _conversionInfo = outInfo;
+
+    return error;
+}
+
+- (void)unprepareForAccelerateConversion {
+    if (_conversionInfo != NULL) {
+        free(_conversionInfo);
+        _conversionInfo = NULL;
+    }
+    if (_pixelBufferPool != NULL) {
+        CVPixelBufferPoolRelease(_pixelBufferPool);
+        _pixelBufferPool = NULL;
+    }
+}
+
+- (void)createPixelBufferPoolWithWidth:(size_t)width height:(size_t)height {
+    if (_pixelBufferPool != NULL) {
+        CVPixelBufferPoolRelease(_pixelBufferPool);
+    }
+
+    _poolWidth = width;
+    _poolHeight = height;
+    NSDictionary *pixelBufferAttributes = @{
+        (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+        (id)kCVPixelBufferWidthKey : @(width),
+        (id)kCVPixelBufferHeightKey : @(height),
+        (id)kCVPixelBufferIOSurfacePropertiesKey : @{}
+    };
+
+    CVReturn ret = CVPixelBufferPoolCreate(
+        kCFAllocatorDefault, NULL, (__bridge CFDictionaryRef)pixelBufferAttributes, &_pixelBufferPool);
+
+    if (ret != kCVReturnSuccess) {
+        NSLog(@"Error creating pixel buffer pool: %d", ret);
+        _pixelBufferPool = NULL;
+    }
+}
+
+- (CVPixelBufferRef)convertI420ToPixelBuffer:(RTCI420Buffer *)buffer {
+    if (_conversionInfo == nil) {
+        NSLog(@"%@: not prepared", NSStringFromSelector(_cmd));
+        return NULL;
+    }
+
+    if (_pixelBufferPool == NULL || _poolWidth != buffer.width || _poolHeight != buffer.height) {
+        [self createPixelBufferPoolWithWidth:buffer.width height:buffer.height];
+    }
+
+    CVPixelBufferRef pixelBuffer = NULL;
+    CVReturn status = CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, _pixelBufferPool, &pixelBuffer);
+
+    if (status != kCVReturnSuccess) {
+        return NULL;
+    }
+
+    vImage_Error err = [self convertFrameVImageYUV:buffer toBuffer:pixelBuffer];
+
+    if (err != kvImageNoError) {
+        NSLog(@"%@: error during conversion: %ld", NSStringFromSelector(_cmd), err);
+        CVPixelBufferRelease(pixelBuffer);
+        return NULL;
+    }
+
+    return pixelBuffer;
+}
+
+- (vImage_Error)convertFrameVImageYUV:(RTCI420Buffer *)buffer toBuffer:(CVPixelBufferRef)pixelBufferRef {
+    if (pixelBufferRef == NULL) {
+        return kvImageInvalidParameter;
+    }
+
+    // Compute info for I420 source.
+    vImagePixelCount width = buffer.width;
+    vImagePixelCount height = buffer.height;
+    vImagePixelCount subsampledWidth = buffer.chromaWidth;
+    vImagePixelCount subsampledHeight = buffer.chromaHeight;
+
+    const uint8_t *yPlane = buffer.dataY;
+    const uint8_t *uPlane = buffer.dataU;
+    const uint8_t *vPlane = buffer.dataV;
+    size_t yStride = (size_t)buffer.strideY;
+    size_t uStride = (size_t)buffer.strideU;
+    size_t vStride = (size_t)buffer.strideV;
+
+    // Create vImage buffers to represent each of the Y, U, and V planes
+    vImage_Buffer yPlaneBuffer = {.data = (void *)yPlane, .height = height, .width = width, .rowBytes = yStride};
+    vImage_Buffer uPlaneBuffer = {
+        .data = (void *)uPlane, .height = subsampledHeight, .width = subsampledWidth, .rowBytes = uStride};
+    vImage_Buffer vPlaneBuffer = {
+        .data = (void *)vPlane, .height = subsampledHeight, .width = subsampledWidth, .rowBytes = vStride};
+
+    // Create a vImage buffer for the destination pixel buffer.
+    CVPixelBufferLockBaseAddress(pixelBufferRef, 0);
+
+    void *pixelBufferData = CVPixelBufferGetBaseAddress(pixelBufferRef);
+    size_t rowBytes = CVPixelBufferGetBytesPerRow(pixelBufferRef);
+    vImage_Buffer destinationImageBuffer = {
+        .data = pixelBufferData, .height = height, .width = width, .rowBytes = rowBytes};
+
+    // Do the conversion.
+
+    uint8_t permuteMap[4] = {3, 2, 1, 0};  // BGRA
+    vImage_Error convertError = vImageConvert_420Yp8_Cb8_Cr8ToARGB8888(&yPlaneBuffer,
+                                                                       &uPlaneBuffer,
+                                                                       &vPlaneBuffer,
+                                                                       &destinationImageBuffer,
+                                                                       self.conversionInfo,
+                                                                       permuteMap,
+                                                                       255,
+                                                                       kvImageNoFlags);
+
+    CVPixelBufferUnlockBaseAddress(pixelBufferRef, 0);
+
+    return convertError;
+}
+
+- (void)dealloc {
+    [self unprepareForAccelerateConversion];
+    CVPixelBufferPoolRelease(_pixelBufferPool);
+}
+
+@end

package/ios/RCTWebRTC/PIPController.h

@@ -0,0 +1,24 @@
+#import <AVKit/AVKit.h>
+#import <UIKit/UIKit.h>
+#import <WebRTC/RTCVideoTrack.h>
+
+#import "RTCVideoViewManager.h"
+
+API_AVAILABLE(ios(15.0))
+@interface PIPController : NSObject<AVPictureInPictureControllerDelegate>
+
+@property(nonatomic, weak) UIView *sourceView;
+@property(nonatomic, strong) RTCVideoTrack *videoTrack;
+
+@property(nonatomic, assign) BOOL startAutomatically;
+@property(nonatomic, assign) BOOL stopAutomatically;
+@property(nonatomic, assign) CGSize preferredSize;
+
+- (instancetype)initWithSourceView:(UIView *)sourceView;
+- (void)togglePIP;
+- (void)startPIP;
+- (void)stopPIP;
+- (void)insertFallbackView:(UIView *)subview;
+- (void)setObjectFit:(RTCVideoViewObjectFit)fit;
+
+@end

package/ios/RCTWebRTC/PIPController.m

@@ -0,0 +1,234 @@
+#import "PIPController.h"
+#import <AVKit/AVKit.h>
+#import "SampleBufferVideoCallView.h"
+
+@interface PIPController ()
+
+@property(nonatomic, strong) AVPictureInPictureVideoCallViewController *pipCallViewController;
+@property(nonatomic, strong) AVPictureInPictureControllerContentSource *contentSource;
+@property(nonatomic, strong) AVPictureInPictureController *pipController;
+@property(nonnull, nonatomic, strong) SampleBufferVideoCallView *sampleView;
+
+@property(nonnull, nonatomic, strong) UIView *fallbackView;
+
+@end
+
+@implementation PIPController
+
+- (instancetype)initWithSourceView:(UIView *)sourceView {
+    if (self = [super init]) {
+        self.sourceView = sourceView;
+
+        _fallbackView = [[UIView alloc] initWithFrame:CGRectZero];
+        _fallbackView.translatesAutoresizingMaskIntoConstraints = false;
+
+        SampleBufferVideoCallView *subview = [[SampleBufferVideoCallView alloc] initWithFrame:CGRectZero];
+        _sampleView = subview;
+        _sampleView.translatesAutoresizingMaskIntoConstraints = false;
+        _pipCallViewController = [[AVPictureInPictureVideoCallViewController alloc] init];
+
+        [self addToCallViewController:_fallbackView];
+
+        _contentSource = [[AVPictureInPictureControllerContentSource alloc]
+            initWithActiveVideoCallSourceView:sourceView
+                        contentViewController:_pipCallViewController];
+
+        _pipController = [[AVPictureInPictureController alloc] initWithContentSource:_contentSource];
+        _pipController.canStartPictureInPictureAutomaticallyFromInline = YES;
+        _pipController.delegate = self;
+
+        [_pipController addObserver:self
+                         forKeyPath:@"pictureInPictureActive"
+                            options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                            context:nil];
+
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(applicationWillEnterForeground:)
+                                                     name:UIApplicationWillEnterForegroundNotification
+                                                   object:nil];
+    }
+
+    return self;
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary *)change
+                       context:(void *)context {
+    if ([keyPath isEqualToString:@"pictureInPictureActive"]) {
+        _sampleView.shouldRender = [change[NSKeyValueChangeNewKey] boolValue];
+    }
+}
+
+- (void)applicationWillEnterForeground:(NSNotification *)notification {
+    if (_stopAutomatically) {
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.5 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+            [self.pipController stopPictureInPicture];
+        });
+    }
+}
+
+- (void)addToCallViewController:(UIView *)view {
+    [_pipCallViewController.view addSubview:view];
+    NSArray *constraints = @[
+        [view.leadingAnchor constraintEqualToAnchor:_pipCallViewController.view.leadingAnchor],
+        [view.trailingAnchor constraintEqualToAnchor:_pipCallViewController.view.trailingAnchor],
+        [view.topAnchor constraintEqualToAnchor:_pipCallViewController.view.topAnchor],
+        [view.bottomAnchor constraintEqualToAnchor:_pipCallViewController.view.bottomAnchor]
+    ];
+    [NSLayoutConstraint activateConstraints:constraints];
+}
+
+- (void)setVideoTrack:(RTCVideoTrack *)videoTrack {
+    if (_videoTrack != videoTrack) {
+        [_videoTrack removeRenderer:_sampleView];
+    }
+
+    _videoTrack = videoTrack;
+    [videoTrack addRenderer:_sampleView];
+
+    if (_videoTrack) {
+        if (!_sampleView.superview) {
+            [self addToCallViewController:_sampleView];
+        }
+        if (_fallbackView.superview) {
+            [_fallbackView removeFromSuperview];
+        }
+    } else {
+        if (!_fallbackView.superview) {
+            [self addToCallViewController:_fallbackView];
+        }
+        if (_sampleView.superview) {
+            [_sampleView removeFromSuperview];
+        }
+    }
+}
+
+- (void)insertFallbackView:(UIView *)view {
+    [self.fallbackView addSubview:view];
+}
+
+- (void)setObjectFit:(RTCVideoViewObjectFit)fit {
+    if (fit == RTCVideoViewObjectFitCover) {
+        self.sampleView.sampleBufferLayer.videoGravity = AVLayerVideoGravityResizeAspectFill;
+    } else {
+        self.sampleView.sampleBufferLayer.videoGravity = AVLayerVideoGravityResizeAspect;
+    }
+}
+
+- (CGSize)preferredSize {
+    return _pipCallViewController.preferredContentSize;
+}
+
+- (void)setPreferredSize:(CGSize)size {
+    if (!CGSizeEqualToSize(size, _pipCallViewController.preferredContentSize)) {
+        _pipCallViewController.preferredContentSize = size;
+        [_sampleView requestScaleRecalculation];
+    }
+}
+
+- (BOOL)startAutomatically {
+    return _pipController.canStartPictureInPictureAutomaticallyFromInline;
+}
+
+- (void)setStartAutomatically:(BOOL)value {
+    _pipController.canStartPictureInPictureAutomaticallyFromInline = value;
+}
+
+- (void)togglePIP {
+    if (_pipController.isPictureInPictureActive) {
+        [_pipController stopPictureInPicture];
+    } else if (_pipController.isPictureInPicturePossible) {
+        [_pipController startPictureInPicture];
+    }
+}
+
+- (void)startPIP {
+    if (_pipController.isPictureInPicturePossible) {
+        [_pipController startPictureInPicture];
+    }
+}
+
+- (void)stopPIP {
+    if (_pipController.isPictureInPictureActive) {
+        [_pipController stopPictureInPicture];
+    }
+}
+
+- (void)dealloc {
+    [_videoTrack removeRenderer:_sampleView];
+    [_pipController removeObserver:self forKeyPath:@"pictureInPictureActive"];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidBecomeActiveNotification object:nil];
+}
+
+@end
+
+@implementation PIPController (AVPictureInPictureControllerDelegate)
+
+/*!
+    @method        pictureInPictureControllerWillStartPictureInPicture:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @abstract    Delegate can implement this method to be notified when Picture in Picture will start.
+ */
+- (void)pictureInPictureControllerWillStartPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
+    NSLog(@"%@", NSStringFromSelector(_cmd));  // Objective-C
+}
+
+/*!
+    @method        pictureInPictureControllerDidStartPictureInPicture:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @abstract    Delegate can implement this method to be notified when Picture in Picture did start.
+ */
+- (void)pictureInPictureControllerDidStartPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
+    NSLog(@"%@", NSStringFromSelector(_cmd));  // Objective-C
+}
+
+/*!
+    @method        pictureInPictureController:failedToStartPictureInPictureWithError:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @param        error
+                An error describing why it failed.
+    @abstract    Delegate can implement this method to be notified when Picture in Picture failed to start.
+ */
+- (void)pictureInPictureController:(AVPictureInPictureController *)pictureInPictureController
+    failedToStartPictureInPictureWithError:(NSError *)error {
+    NSLog(@"%@: %@", NSStringFromSelector(_cmd), [error localizedDescription]);  // Objective-C
+}
+
+/*!
+    @method        pictureInPictureControllerWillStopPictureInPicture:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @abstract    Delegate can implement this method to be notified when Picture in Picture will stop.
+ */
+- (void)pictureInPictureControllerWillStopPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
+    NSLog(@"%@", NSStringFromSelector(_cmd));  // Objective-C
+}
+
+/*!
+    @method        pictureInPictureControllerDidStopPictureInPicture:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @abstract    Delegate can implement this method to be notified when Picture in Picture did stop.
+ */
+- (void)pictureInPictureControllerDidStopPictureInPicture:(AVPictureInPictureController *)pictureInPictureController {
+    NSLog(@"%@", NSStringFromSelector(_cmd));  // Objective-C
+}
+
+/*!
+    @method        pictureInPictureController:restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:
+    @param        pictureInPictureController
+                The Picture in Picture controller.
+    @param        completionHandler
+                The completion handler the delegate needs to call after restore.
+    @abstract    Delegate can implement this method to restore the user interface before Picture in Picture stops.
+ */
+- (void)pictureInPictureController:(AVPictureInPictureController *)pictureInPictureController
+    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:(void (^)(BOOL restored))completionHandler {
+    NSLog(@"%@", NSStringFromSelector(_cmd));  // Objective-C
+}
+
+@end

package/ios/RCTWebRTC/RCTConvert+WebRTC.h

@@ -0,0 +1,16 @@
+#import <React/RCTConvert.h>
+#import <WebRTC/RTCConfiguration.h>
+#import <WebRTC/RTCDataChannelConfiguration.h>
+#import <WebRTC/RTCIceCandidate.h>
+#import <WebRTC/RTCIceServer.h>
+#import <WebRTC/RTCSessionDescription.h>
+
+@interface RCTConvert (WebRTC)
+
++ (RTCIceCandidate *)RTCIceCandidate:(id)json;
++ (RTCSessionDescription *)RTCSessionDescription:(id)json;
++ (RTCIceServer *)RTCIceServer:(id)json;
++ (RTCDataChannelConfiguration *)RTCDataChannelConfiguration:(id)json;
++ (RTCConfiguration *)RTCConfiguration:(id)json;
+
+@end

package/ios/RCTWebRTC/RCTConvert+WebRTC.m

@@ -0,0 +1,206 @@
+#import <React/RCTLog.h>
+#import <WebRTC/RTCDataChannelConfiguration.h>
+#import <WebRTC/RTCIceServer.h>
+#import <WebRTC/RTCSessionDescription.h>
+#import "RCTConvert+WebRTC.h"
+
+@implementation RCTConvert (WebRTC)
+
++ (RTCSessionDescription *)RTCSessionDescription:(id)json {
+    if (!json) {
+        return nil;
+    }
+
+    if (![json isKindOfClass:[NSDictionary class]]) {
+        RCTLogConvertError(json, @"must be an object");
+        return nil;
+    }
+
+    if (json[@"sdp"] == nil) {
+        RCTLogConvertError(json, @".sdp must not be null");
+        return nil;
+    }
+
+    NSString *sdp = json[@"sdp"];
+    RTCSdpType sdpType = [RTCSessionDescription typeForString:json[@"type"]];
+
+    return [[RTCSessionDescription alloc] initWithType:sdpType sdp:sdp];
+}
+
++ (RTCIceCandidate *)RTCIceCandidate:(id)json {
+    if (!json) {
+        RCTLogConvertError(json, @"must not be null");
+        return nil;
+    }
+
+    if (![json isKindOfClass:[NSDictionary class]]) {
+        RCTLogConvertError(json, @"must be an object");
+        return nil;
+    }
+
+    if (json[@"candidate"] == nil) {
+        RCTLogConvertError(json, @".candidate must not be null");
+        return nil;
+    }
+
+    if (json[@"sdpMid"] == nil && json[@"sdpMLineIndex"] == nil) {
+        RCTLogConvertError(json, @".sdpMid and .sdpMLineIndex must not be both null");
+        return nil;
+    }
+
+    NSString *sdp = json[@"candidate"];
+    RCTLogTrace(@"%@ <- candidate", sdp);
+    int sdpMLineIndex = [RCTConvert int:json[@"sdpMLineIndex"]];
+    NSString *sdpMid = json[@"sdpMid"];
+
+    return [[RTCIceCandidate alloc] initWithSdp:sdp sdpMLineIndex:sdpMLineIndex sdpMid:sdpMid];
+}
+
++ (RTCIceServer *)RTCIceServer:(id)json {
+    if (!json) {
+        RCTLogConvertError(json, @"a valid iceServer value");
+        return nil;
+    }
+
+    if (![json isKindOfClass:[NSDictionary class]]) {
+        RCTLogConvertError(json, @"must be an object");
+        return nil;
+    }
+
+    NSArray<NSString *> *urls;
+    if ([json[@"urls"] isKindOfClass:[NSString class]]) {
+        urls = @[ json[@"urls"] ];
+    } else {
+        urls = [RCTConvert NSArray:json[@"urls"]];
+    }
+
+    if (json[@"username"] != nil || json[@"credential"] != nil) {
+        return [[RTCIceServer alloc] initWithURLStrings:urls username:json[@"username"] credential:json[@"credential"]];
+    }
+
+    return [[RTCIceServer alloc] initWithURLStrings:urls];
+}
+
++ (nonnull RTCConfiguration *)RTCConfiguration:(id)json {
+    RTCConfiguration *config = [[RTCConfiguration alloc] init];
+    config.sdpSemantics = RTCSdpSemanticsUnifiedPlan;
+
+    // Required for perfect negotiation.
+    config.enableImplicitRollback = YES;
+
+    // Enable GCM ciphers.
+    RTCCryptoOptions *cryptoOptions = [[RTCCryptoOptions alloc] initWithSrtpEnableGcmCryptoSuites:YES
+                                                              srtpEnableAes128Sha1_32CryptoCipher:NO
+                                                           srtpEnableEncryptedRtpHeaderExtensions:NO
+                                                                     sframeRequireFrameEncryption:NO];
+    config.cryptoOptions = cryptoOptions;
+
+    if (!json) {
+        return config;
+    }
+
+    if (![json isKindOfClass:[NSDictionary class]]) {
+        RCTLogConvertError(json, @"must be an object");
+        return config;
+    }
+
+    if (json[@"audioJitterBufferMaxPackets"] != nil &&
+        [json[@"audioJitterBufferMaxPackets"] isKindOfClass:[NSNumber class]]) {
+        config.audioJitterBufferMaxPackets = [RCTConvert int:json[@"audioJitterBufferMaxPackets"]];
+    }
+
+    if (json[@"bundlePolicy"] != nil && [json[@"bundlePolicy"] isKindOfClass:[NSString class]]) {
+        NSString *bundlePolicy = json[@"bundlePolicy"];
+        if ([bundlePolicy isEqualToString:@"balanced"]) {
+            config.bundlePolicy = RTCBundlePolicyBalanced;
+        } else if ([bundlePolicy isEqualToString:@"max-compat"]) {
+            config.bundlePolicy = RTCBundlePolicyMaxCompat;
+        } else if ([bundlePolicy isEqualToString:@"max-bundle"]) {
+            config.bundlePolicy = RTCBundlePolicyMaxBundle;
+        }
+    }
+
+    if (json[@"iceBackupCandidatePairPingInterval"] != nil &&
+        [json[@"iceBackupCandidatePairPingInterval"] isKindOfClass:[NSNumber class]]) {
+        config.iceBackupCandidatePairPingInterval = [RCTConvert int:json[@"iceBackupCandidatePairPingInterval"]];
+    }
+
+    if (json[@"iceConnectionReceivingTimeout"] != nil &&
+        [json[@"iceConnectionReceivingTimeout"] isKindOfClass:[NSNumber class]]) {
+        config.iceConnectionReceivingTimeout = [RCTConvert int:json[@"iceConnectionReceivingTimeout"]];
+    }
+
+    if (json[@"iceServers"] != nil && [json[@"iceServers"] isKindOfClass:[NSArray class]]) {
+        NSMutableArray<RTCIceServer *> *iceServers = [NSMutableArray new];
+        for (id server in json[@"iceServers"]) {
+            RTCIceServer *convert = [RCTConvert RTCIceServer:server];
+            if (convert != nil) {
+                [iceServers addObject:convert];
+            }
+        }
+        config.iceServers = iceServers;
+    }
+
+    if (json[@"iceTransportPolicy"] != nil && [json[@"iceTransportPolicy"] isKindOfClass:[NSString class]]) {
+        NSString *iceTransportPolicy = json[@"iceTransportPolicy"];
+        if ([iceTransportPolicy isEqualToString:@"all"]) {
+            config.iceTransportPolicy = RTCIceTransportPolicyAll;
+        } else if ([iceTransportPolicy isEqualToString:@"none"]) {
+            config.iceTransportPolicy = RTCIceTransportPolicyNone;
+        } else if ([iceTransportPolicy isEqualToString:@"nohost"]) {
+            config.iceTransportPolicy = RTCIceTransportPolicyNoHost;
+        } else if ([iceTransportPolicy isEqualToString:@"relay"]) {
+            config.iceTransportPolicy = RTCIceTransportPolicyRelay;
+        }
+    }
+
+    if (json[@"rtcpMuxPolicy"] != nil && [json[@"rtcpMuxPolicy"] isKindOfClass:[NSString class]]) {
+        NSString *rtcpMuxPolicy = json[@"rtcpMuxPolicy"];
+        if ([rtcpMuxPolicy isEqualToString:@"negotiate"]) {
+            config.rtcpMuxPolicy = RTCRtcpMuxPolicyNegotiate;
+        } else if ([rtcpMuxPolicy isEqualToString:@"require"]) {
+            config.rtcpMuxPolicy = RTCRtcpMuxPolicyRequire;
+        }
+    }
+
+    if (json[@"tcpCandidatePolicy"] != nil && [json[@"tcpCandidatePolicy"] isKindOfClass:[NSString class]]) {
+        NSString *tcpCandidatePolicy = json[@"tcpCandidatePolicy"];
+        if ([tcpCandidatePolicy isEqualToString:@"enabled"]) {
+            config.tcpCandidatePolicy = RTCTcpCandidatePolicyEnabled;
+        } else if ([tcpCandidatePolicy isEqualToString:@"disabled"]) {
+            config.tcpCandidatePolicy = RTCTcpCandidatePolicyDisabled;
+        }
+    }
+
+    return config;
+}
+
++ (RTCDataChannelConfiguration *)RTCDataChannelConfiguration:(id)json {
+    if (!json) {
+        return nil;
+    }
+    if ([json isKindOfClass:[NSDictionary class]]) {
+        RTCDataChannelConfiguration *init = [RTCDataChannelConfiguration new];
+
+        if (json[@"id"]) {
+            [init setChannelId:[RCTConvert int:json[@"id"]]];
+        }
+
+        if (json[@"ordered"]) {
+            init.isOrdered = [RCTConvert BOOL:json[@"ordered"]];
+        }
+        if (json[@"maxRetransmits"]) {
+            init.maxRetransmits = [RCTConvert int:json[@"maxRetransmits"]];
+        }
+        if (json[@"negotiated"]) {
+            init.isNegotiated = [RCTConvert NSInteger:json[@"negotiated"]];
+        }
+        if (json[@"protocol"]) {
+            init.protocol = [RCTConvert NSString:json[@"protocol"]];
+        }
+        return init;
+    }
+    return nil;
+}
+
+@end

package/ios/RCTWebRTC/RTCMediaStreamTrack+React.h

@@ -0,0 +1,10 @@
+
+#import <WebRTC/RTCMediaStreamTrack.h>
+
+@class CaptureController;
+
+@interface RTCMediaStreamTrack (React)
+
+@property(strong, nonatomic) CaptureController *captureController;
+
+@end

package/ios/RCTWebRTC/RTCMediaStreamTrack+React.m

@@ -0,0 +1,16 @@
+#import <objc/runtime.h>
+
+#import "CaptureController.h"
+#import "RTCMediaStreamTrack+React.h"
+
+@implementation RTCMediaStreamTrack (React)
+
+- (CaptureController *)captureController {
+    return objc_getAssociatedObject(self, @selector(captureController));
+}
+
+- (void)setCaptureController:(CaptureController *)captureController {
+    objc_setAssociatedObject(self, @selector(captureController), captureController, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+@end