@sbhjt-gr/react-native-webrtc 124.0.0

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

package/ios/RCTWebRTC/RTCVideoViewManager.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+/**
+ * In the fashion of
+ * https://www.w3.org/TR/html5/embedded-content-0.html#dom-video-videowidth
+ * and https://www.w3.org/TR/html5/rendering.html#video-object-fit, resembles
+ * the CSS style {@code object-fit}.
+ */
+typedef NS_ENUM(NSInteger, RTCVideoViewObjectFit) {
+    /**
+     * The contain value defined by https://www.w3.org/TR/css3-images/#object-fit:
+     *
+     * The replaced content is sized to maintain its aspect ratio while fitting
+     * within the element's content box.
+     */
+    RTCVideoViewObjectFitContain = 1,
+    /**
+     * The cover value defined by https://www.w3.org/TR/css3-images/#object-fit:
+     *
+     * The replaced content is sized to maintain its aspect ratio while filling
+     * the element's entire content box.
+     */
+    RTCVideoViewObjectFitCover
+};
+
+@interface RTCVideoViewManager : RCTViewManager
+
+@end

package/ios/RCTWebRTC/RTCVideoViewManager.m

@@ -0,0 +1,411 @@
+#import <AVFoundation/AVFoundation.h>
+#import <objc/runtime.h>
+
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTView.h>
+
+#import <WebRTC/RTCMediaStream.h>
+#if TARGET_OS_OSX
+#import <WebRTC/RTCMTLNSVideoView.h>
+#else
+#import <WebRTC/RTCMTLVideoView.h>
+#endif
+#import <WebRTC/RTCCVPixelBuffer.h>
+#import <WebRTC/RTCVideoFrame.h>
+#import <WebRTC/RTCVideoTrack.h>
+
+#import "PIPController.h"
+#import "RTCVideoViewManager.h"
+#import "WebRTCModule.h"
+
+/**
+ * Implements an equivalent of {@code HTMLVideoElement} i.e. Web's video
+ * element.
+ */
+@interface RTCVideoView : RCTView<RTCVideoViewDelegate>
+
+/**
+ * The indicator which determines whether this {@code RTCVideoView} is to mirror
+ * the video specified by {@link #videoTrack} during its rendering. Typically,
+ * applications choose to mirror the front/user-facing camera.
+ */
+@property(nonatomic) BOOL mirror;
+
+/**
+ * In the fashion of
+ * https://www.w3.org/TR/html5/embedded-content-0.html#dom-video-videowidth
+ * and https://www.w3.org/TR/html5/rendering.html#video-object-fit, resembles
+ * the CSS style {@code object-fit}.
+ */
+@property(nonatomic) RTCVideoViewObjectFit objectFit;
+
+@property(nonatomic) BOOL enablePIP;
+
+@property(nonatomic, strong) API_AVAILABLE(ios(15.0)) PIPController *pipController;
+
+/**
+ * The {@link RRTCVideoRenderer} which implements the actual rendering.
+ */
+#if TARGET_OS_OSX
+@property(nonatomic, readonly) RTCMTLNSVideoView *videoView;
+#else
+@property(nonatomic, readonly) RTCMTLVideoView *videoView;
+#endif
+
+// Add a reference to the view manager
+@property(nonatomic, weak) RTCVideoViewManager *viewManager;
+
+/**
+ * The {@link RTCVideoTrack}, if any, which this instance renders.
+ */
+@property(nonatomic, strong) RTCVideoTrack *videoTrack;
+
+/**
+ * Reference to the main WebRTC RN module.
+ */
+@property(nonatomic, weak) WebRTCModule *module;
+
+@property(nonatomic, copy) RCTDirectEventBlock onDimensionsChange;
+
+@end
+
+@implementation RTCVideoView
+
+@synthesize videoView = _videoView;
+@synthesize pipController = _pipController;
+
+/**
+ * Tells this view that its window object changed.
+ */
+- (void)didMoveToWindow {
+    // This RTCVideoView strongly retains its videoTrack. The latter strongly
+    // retains the former as well though because RTCVideoTrack strongly retains
+    // the RTCVideoRenderers added to it. In other words, there is a cycle of
+    // strong retainments. In order to break the cycle, and avoid a leak,
+    // have this RTCVideoView as the RTCVideoRenderer of its
+    // videoTrack only while this view resides in a window.
+    RTCVideoTrack *videoTrack = self.videoTrack;
+
+    if (videoTrack) {
+        if (self.window) {
+            dispatch_async(_module.workerQueue, ^{
+                [videoTrack addRenderer:self.videoView];
+            });
+        } else {
+            dispatch_async(_module.workerQueue, ^{
+                [videoTrack removeRenderer:self.videoView];
+            });
+        }
+    }
+}
+
+/**
+ * Initializes and returns a newly allocated view object with the specified
+ * frame rectangle.
+ *
+ * @param frame The frame rectangle for the view, measured in points.
+ */
+- (instancetype)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+#if TARGET_OS_OSX
+        RTCMTLNSVideoView *subview = [[RTCMTLNSVideoView alloc] initWithFrame:CGRectZero];
+        subview.wantsLayer = true;
+        _videoView = subview;
+#else
+        RTCMTLVideoView *subview = [[RTCMTLVideoView alloc] initWithFrame:CGRectZero];
+        _videoView = subview;
+#endif
+        _objectFit = RTCVideoViewObjectFitCover;
+        [self addSubview:self.videoView];
+        self.videoView.delegate = self;
+    }
+
+    return self;
+}
+
+#if TARGET_OS_OSX
+- (void)layout {
+    [super layout];
+#else
+- (void)layoutSubviews {
+    [super layoutSubviews];
+#endif
+
+    CGRect bounds = self.bounds;
+    self.videoView.frame = bounds;
+}
+
+/**
+ * Implements the setter of the {@link #mirror} property of this
+ * {@code RTCVideoView}.
+ *
+ * @param mirror The value to set on the {@code mirror} property of this
+ * {@code RTCVideoView}.
+ */
+- (void)setMirror:(BOOL)mirror {
+    if (_mirror != mirror) {
+        _mirror = mirror;
+
+        self.videoView.transform = mirror ? CGAffineTransformMakeScale(-1.0, 1.0) : CGAffineTransformIdentity;
+    }
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex {
+    // All subviews are treated as fallback views
+    [_pipController insertFallbackView:subview];
+}
+
+- (void)API_AVAILABLE(ios(15.0))setPIPOptions:(NSDictionary *)pipOptions {
+    if (!pipOptions) {
+        _pipController = nil;
+        return;
+    }
+
+    BOOL enabled = YES;
+    BOOL startAutomatically = YES;
+    BOOL stopAutomatically = YES;
+
+    CGSize preferredSize = CGSizeZero;
+
+    if ([pipOptions objectForKey:@"enabled"]) {
+        enabled = [pipOptions[@"enabled"] boolValue];
+    }
+    if ([pipOptions objectForKey:@"startAutomatically"]) {
+        startAutomatically = [pipOptions[@"startAutomatically"] boolValue];
+    }
+    if ([pipOptions objectForKey:@"stopAutomatically"]) {
+        stopAutomatically = [pipOptions[@"stopAutomatically"] boolValue];
+    }
+    if ([pipOptions objectForKey:@"preferredSize"]) {
+        NSDictionary *sizeDict = pipOptions[@"preferredSize"];
+        id width = sizeDict[@"width"];
+        id height = sizeDict[@"height"];
+
+        if ([width isKindOfClass:[NSNumber class]] && [height isKindOfClass:[NSNumber class]]) {
+            preferredSize = CGSizeMake([width doubleValue], [height doubleValue]);
+        }
+    }
+
+    if (!enabled) {
+        _pipController = nil;
+        return;
+    }
+
+    if (!_pipController) {
+        _pipController = [[PIPController alloc] initWithSourceView:self];
+        _pipController.videoTrack = _videoTrack;
+    }
+
+    _pipController.startAutomatically = startAutomatically;
+    _pipController.stopAutomatically = stopAutomatically;
+    _pipController.objectFit = _objectFit;
+    _pipController.preferredSize = preferredSize;
+}
+
+- (void)API_AVAILABLE(ios(15.0))startPIP {
+    [_pipController startPIP];
+}
+
+- (void)API_AVAILABLE(ios(15.0))stopPIP {
+    [_pipController stopPIP];
+}
+
+/**
+ * Implements the setter of the {@link #objectFit} property of this
+ * {@code RTCVideoView}.
+ *
+ * @param objectFit The value to set on the {@code objectFit} property of this
+ * {@code RTCVideoView}.
+ */
+- (void)setObjectFit:(RTCVideoViewObjectFit)fit {
+    if (_objectFit != fit) {
+        _objectFit = fit;
+
+#if !TARGET_OS_OSX
+        if (fit == RTCVideoViewObjectFitCover) {
+            self.videoView.videoContentMode = UIViewContentModeScaleAspectFill;
+        } else {
+            self.videoView.videoContentMode = UIViewContentModeScaleAspectFit;
+        }
+#endif
+        if (@available(iOS 15.0, *)) {
+            _pipController.objectFit = fit;
+        }
+    }
+}
+
+/**
+ * Implements the setter of the {@link #videoTrack} property of this
+ * {@code RTCVideoView}.
+ *
+ * @param videoTrack The value to set on the {@code videoTrack} property of this
+ * {@code RTCVideoView}.
+ */
+- (void)setVideoTrack:(RTCVideoTrack *)videoTrack {
+    RTCVideoTrack *oldValue = self.videoTrack;
+
+    if (oldValue != videoTrack) {
+        if (oldValue) {
+            dispatch_async(_module.workerQueue, ^{
+                [oldValue removeRenderer:self.videoView];
+            });
+        }
+
+        [_pipController setVideoTrack:videoTrack];
+        _videoTrack = videoTrack;
+
+        // Clear the videoView by rendering a 2x2 blank frame.
+        CVPixelBufferRef pixelBuffer;
+        CVReturn err = CVPixelBufferCreate(NULL, 2, 2, kCVPixelFormatType_32BGRA, NULL, &pixelBuffer);
+        if (err == kCVReturnSuccess) {
+            const int kBytesPerPixel = 4;
+            CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+            int bufferWidth = (int)CVPixelBufferGetWidth(pixelBuffer);
+            int bufferHeight = (int)CVPixelBufferGetHeight(pixelBuffer);
+            size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+            uint8_t *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
+
+            for (int row = 0; row < bufferHeight; row++) {
+                uint8_t *pixel = baseAddress + row * bytesPerRow;
+                for (int column = 0; column < bufferWidth; column++) {
+                    pixel[0] = 0;  // BGRA, Blue value
+                    pixel[1] = 0;  // Green value
+                    pixel[2] = 0;  // Red value
+                    pixel[3] = 0;  // Alpha value
+                    pixel += kBytesPerPixel;
+                }
+            }
+
+            CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+            int64_t time = (int64_t)(CFAbsoluteTimeGetCurrent() * 1000000000);
+            RTCCVPixelBuffer *buffer = [[RTCCVPixelBuffer alloc] initWithPixelBuffer:pixelBuffer];
+            RTCVideoFrame *frame = [[[RTCVideoFrame alloc] initWithBuffer:buffer
+                                                                 rotation:RTCVideoRotation_0
+                                                              timeStampNs:time] newI420VideoFrame];
+
+            [self.videoView renderFrame:frame];
+
+            CVPixelBufferRelease(pixelBuffer);
+        }
+
+        // See "didMoveToWindow" above.
+        if (videoTrack && self.window) {
+            dispatch_async(_module.workerQueue, ^{
+                [videoTrack addRenderer:self.videoView];
+            });
+        }
+    }
+}
+
+- (void)videoView:(id)videoView didChangeVideoSize:(CGSize)size {
+    // Capture the callback block to avoid accessing it across threads
+    RCTDirectEventBlock callback = self.onDimensionsChange;
+    if (callback) {
+        NSDictionary *eventData = @{@"width" : @(size.width), @"height" : @(size.height)};
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            callback(eventData);
+        });
+    }
+}
+
+@end
+
+@implementation RTCVideoViewManager
+
+RCT_EXPORT_MODULE()
+
+- (RCTView *)view {
+    RTCVideoView *v = [[RTCVideoView alloc] init];
+    v.module = [self.bridge moduleForName:@"WebRTCModule"];
+    v.viewManager = self;
+    v.clipsToBounds = YES;
+    return v;
+}
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
+#pragma mark - View properties
+
+RCT_EXPORT_VIEW_PROPERTY(mirror, BOOL)
+
+/**
+ * In the fashion of
+ * https://www.w3.org/TR/html5/embedded-content-0.html#dom-video-videowidth
+ * and https://www.w3.org/TR/html5/rendering.html#video-object-fit, resembles
+ * the CSS style {@code object-fit}.
+ */
+RCT_CUSTOM_VIEW_PROPERTY(objectFit, NSString *, RTCVideoView) {
+    NSString *fitStr = json;
+    RTCVideoViewObjectFit fit =
+        (fitStr && [fitStr isEqualToString:@"cover"]) ? RTCVideoViewObjectFitCover : RTCVideoViewObjectFitContain;
+
+    view.objectFit = fit;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(onDimensionsChange, RCTDirectEventBlock)
+
+RCT_CUSTOM_VIEW_PROPERTY(streamURL, NSString *, RTCVideoView) {
+    if (!json) {
+        view.videoTrack = nil;
+        return;
+    }
+
+    NSString *streamReactTag = json;
+    WebRTCModule *module = view.module;
+
+    dispatch_async(module.workerQueue, ^{
+        RTCMediaStream *stream = [module streamForReactTag:streamReactTag];
+        NSArray *videoTracks = stream ? stream.videoTracks : @[];
+        RTCVideoTrack *videoTrack = [videoTracks firstObject];
+        if (!videoTrack) {
+            RCTLogWarn(@"No video stream for react tag: %@", streamReactTag);
+        } else {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                view.videoTrack = videoTrack;
+            });
+        }
+    });
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(iosPIP, NSDictionary *, RTCVideoView) {
+    if (@available(iOS 15.0, *)) {
+        [view setPIPOptions:json];
+    }
+}
+
+RCT_EXPORT_METHOD(startIOSPIP : (nonnull NSNumber *)reactTag) {
+    if (@available(iOS 15.0, *)) {
+        RCTUIManager *uiManager = [self.bridge moduleForClass:[RCTUIManager class]];
+        [uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            UIView *view = viewRegistry[reactTag];
+            if (!view || ![view isKindOfClass:[RTCVideoView class]]) {
+                RCTLogError(@"Cannot find RTCVideoView with tag #%@", reactTag);
+                return;
+            }
+            [(RTCVideoView *)view startPIP];
+        }];
+    }
+}
+
+RCT_EXPORT_METHOD(stopIOSPIP : (nonnull NSNumber *)reactTag) {
+    if (@available(iOS 15.0, *)) {
+        RCTUIManager *uiManager = [self.bridge moduleForClass:[RCTUIManager class]];
+        [uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            UIView *view = viewRegistry[reactTag];
+            if (!view || ![view isKindOfClass:[RTCVideoView class]]) {
+                RCTLogError(@"Cannot find RTCVideoView with tag #%@", reactTag);
+                return;
+            }
+            [(RTCVideoView *)view stopPIP];
+        }];
+    }
+}
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+@end

package/ios/RCTWebRTC/SampleBufferVideoCallView.h

@@ -0,0 +1,12 @@
+#import <AVKit/AVKit.h>
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+#import <WebRTC/RTCVideoRenderer.h>
+
+@interface SampleBufferVideoCallView : UIView<RTCVideoRenderer>
+
+@property(nonnull, nonatomic, readonly) AVSampleBufferDisplayLayer *sampleBufferLayer;
+@property(nonatomic, assign) BOOL shouldRender;
+
+- (void)requestScaleRecalculation;
+@end