@stream-io/video-react-native-sdk 1.0.0-rc2.0 → 1.0.1

package/ios/PictureInPicture/StreamRTCYUVBuffer.swift

@@ -0,0 +1,249 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Accelerate
+import CoreVideo
+import Foundation
+
+/// A class that encapsulates the conversion of RTC video frame buffers from YUV to ARGB format.
+final class StreamRTCYUVBuffer: NSObject, RTCVideoFrameBuffer {
+    
+    private let pixelBufferRepository = StreamPixelBufferRepository.init()
+    
+    /// The original source of the video frame, conforming to `RTCVideoFrameBuffer`.
+    private let source: RTCVideoFrameBuffer
+    
+    /// The conversion mechanism from YUV to ARGB.
+    private let conversion: StreamYUVToARGBConversion
+    
+    /// The width of the video frame.
+    var width: Int32 { source.width }
+    
+    /// The height of the video frame.
+    var height: Int32 { source.height }
+    
+    /// Lazily initialized pixel buffer that stores the converted YUV to ARGB data.
+    private lazy var i420ToYUVPixelBuffer = buildI420ToYUVPixelBuffer()
+    
+    /// Initializes a new buffer with the given source and conversion setup.
+    ///
+    /// - Parameters:
+    ///   - source: The video frame source.
+    ///   - conversion: The conversion configuration, default initialized if not provided.
+    init(
+        source: RTCVideoFrameBuffer,
+        conversion: StreamYUVToARGBConversion = .init()
+    ) {
+        self.source = source
+        self.conversion = conversion
+    }
+    
+    /// Converts the frame to the I420 format.
+    ///
+    /// - Returns: An object conforming to `RTCI420BufferProtocol`.
+    func toI420() -> any RTCI420BufferProtocol {
+        if let i420 = source as? RTCI420Buffer {
+            return i420
+        } else {
+            return source.toI420()
+        }
+    }
+    
+    /// Resizes the current buffer resized to the target size.
+    ///
+    /// - Parameter targetSize: The target size for the buffer.
+    /// - Returns: A new `StreamRTCYUVBuffer` with the resized content or nil if resizing fails.
+    func resize(to targetSize: CGSize) -> StreamRTCYUVBuffer? {
+        if let i420 = source as? RTCI420Buffer {
+            let resizedSource = i420.cropAndScale(
+                with: 0,
+                offsetY: 0,
+                cropWidth: Int32(source.width),
+                cropHeight: Int32(source.height),
+                scaleWidth: Int32(targetSize.width),
+                scaleHeight: Int32(targetSize.height)
+            )
+            return .init(source: resizedSource, conversion: conversion)
+        } else if
+            let pixelBuffer = source as? RTCCVPixelBuffer,
+            let dequeuedPixelBuffer = try? pixelBufferRepository.dequeuePixelBuffer(
+                of: targetSize,
+                pixelFormat: CVPixelBufferGetPixelFormatType(pixelBuffer.pixelBuffer)
+            ) {
+            let count = pixelBuffer.bufferSizeForCroppingAndScaling(toWidth: Int32(targetSize.width), height: Int32(targetSize.height))
+            let tempBuffer: UnsafeMutableRawPointer? = malloc(Int(count))
+            pixelBuffer.cropAndScale(to: dequeuedPixelBuffer, withTempBuffer: tempBuffer)
+            tempBuffer?.deallocate()
+            return .init(source: RTCCVPixelBuffer(pixelBuffer: dequeuedPixelBuffer))
+        } else {
+            return nil
+        }
+    }
+    
+    /// Retrieves the underlying pixel buffer if available.
+    var pixelBuffer: CVPixelBuffer? {
+        if source is RTCI420Buffer {
+            return i420ToYUVPixelBuffer
+        } else if let pixelBuffer = source as? RTCCVPixelBuffer {
+            return pixelBuffer.pixelBuffer
+        } else {
+            return nil
+        }
+    }
+    
+    /// Creates a CMSampleBuffer from the current pixel buffer, if available.
+    var sampleBuffer: CMSampleBuffer? {
+        guard let pixelBuffer else {
+            return nil
+        }
+        
+        var sampleBuffer: CMSampleBuffer?
+        
+        var timingInfo = CMSampleTimingInfo()
+        var formatDescription: CMFormatDescription?
+        CMVideoFormatDescriptionCreateForImageBuffer(
+            allocator: kCFAllocatorDefault,
+            imageBuffer: pixelBuffer,
+            formatDescriptionOut: &formatDescription
+        )
+        
+        guard let formatDescription = formatDescription else {
+//            log.error("Cannot create sample buffer formatDescription.")
+            return nil
+        }
+        
+        _ = CMSampleBufferCreateReadyWithImageBuffer(
+            allocator: kCFAllocatorDefault,
+            imageBuffer: pixelBuffer,
+            formatDescription: formatDescription,
+            sampleTiming: &timingInfo,
+            sampleBufferOut: &sampleBuffer
+        )
+        
+        guard let buffer = sampleBuffer else {
+//            log.error("Cannot create sample buffer")
+            return nil
+        }
+        
+        let attachments: CFArray! = CMSampleBufferGetSampleAttachmentsArray(
+            buffer,
+            createIfNecessary: true
+        )
+        let dictionary = unsafeBitCast(
+            CFArrayGetValueAtIndex(attachments, 0),
+            to: CFMutableDictionary.self
+        )
+        let key = Unmanaged.passUnretained(kCMSampleAttachmentKey_DisplayImmediately).toOpaque()
+        let value = Unmanaged.passUnretained(kCFBooleanTrue).toOpaque()
+        CFDictionarySetValue(dictionary, key, value)
+        
+        return buffer
+    }
+    
+    // MARK: - Private Helpers
+    
+    /// Creates a pixel buffer converted from I420 to YUV format.
+    ///
+    /// - Returns: A `CVPixelBuffer` containing the converted data or nil if the conversion fails.
+    private func buildI420ToYUVPixelBuffer() -> CVPixelBuffer? {
+        guard let source = source as? RTCI420Buffer else {
+            return nil
+        }
+        
+        do {
+            let pixelBuffer = try pixelBufferRepository.dequeuePixelBuffer(
+                of: .init(width: Int(width), height: Int(height))
+            )
+            
+            var YpImageBuffer = buildYpImageBuffer(source)
+            var CbImageBuffer = buildCbImageBuffer(source)
+            var CrImageBuffer = buildCrImageBuffer(source)
+            
+            CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+            var output = buildImageBuffer(from: pixelBuffer)
+            /// The `vImageConvert_420Yp8_Cb8_Cr8ToARGB8888` will convert our buffer
+            /// to ARGB pixel format. However, for rendering we require BGRA pixel format. The
+            /// permuteMaps adds an instruction to move around the generated ARGB buffers to the
+            /// positions described by the array:
+            /// Example:
+            /// The resulted array will be: [0: Alpha, 1: Red, 2: Green, 3: Blue]. The array that we want
+            /// to get though will have the format [0: Blue, 1: Green, 2: Red, 3: Alpha].
+            let error = vImageConvert_420Yp8_Cb8_Cr8ToARGB8888(
+                &YpImageBuffer,
+                &CbImageBuffer,
+                &CrImageBuffer,
+                &output,
+                &conversion.output,
+                [3, 2, 1, 0],
+                255,
+                vImage_Flags(kvImageNoFlags)
+            )
+            
+            CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
+            
+            if error == kvImageNoError {
+                return pixelBuffer
+            } else {
+//                log.error(error)
+                return nil
+            }
+        } catch {
+//            log.error(error)
+            return nil
+        }
+    }
+    
+    /// Constructs a `vImage_Buffer` for the Y plane from the source I420 buffer.
+    ///
+    /// - Parameter source: The source I420 buffer.
+    /// - Returns: A `vImage_Buffer` representing the Y plane.
+    private func buildYpImageBuffer(_ source: RTCI420Buffer) -> vImage_Buffer {
+        vImage_Buffer(
+            data: UnsafeMutablePointer(mutating: source.dataY),
+            height: vImagePixelCount(height),
+            width: vImagePixelCount(width),
+            rowBytes: Int(source.strideY)
+        )
+    }
+    
+    /// Constructs a `vImage_Buffer` for the Cb plane from the source I420 buffer.
+    ///
+    /// - Parameter source: The source I420 buffer.
+    /// - Returns: A `vImage_Buffer` representing the Cb plane.
+    private func buildCbImageBuffer(_ source: RTCI420Buffer) -> vImage_Buffer {
+        vImage_Buffer(
+            data: UnsafeMutablePointer(mutating: source.dataU),
+            height: vImagePixelCount(source.chromaHeight),
+            width: vImagePixelCount(source.chromaWidth),
+            rowBytes: Int(source.strideU)
+        )
+    }
+    
+    /// Constructs a `vImage_Buffer` for the Cr plane from the source I420 buffer.
+    ///
+    /// - Parameter source: The source I420 buffer.
+    /// - Returns: A `vImage_Buffer` representing the Cr plane.
+    private func buildCrImageBuffer(_ source: RTCI420Buffer) -> vImage_Buffer {
+        vImage_Buffer(
+            data: UnsafeMutablePointer(mutating: source.dataV),
+            height: vImagePixelCount(source.chromaHeight),
+            width: vImagePixelCount(source.chromaWidth),
+            rowBytes: Int(source.strideV)
+        )
+    }
+    
+    /// Creates a `vImage_Buffer` from a CVPixelBuffer.
+    ///
+    /// - Parameter pixelBuffer: The pixel buffer to convert.
+    /// - Returns: A `vImage_Buffer` representing the given pixel buffer.
+    private func buildImageBuffer(from pixelBuffer: CVPixelBuffer) -> vImage_Buffer {
+        let baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer)!
+        return vImage_Buffer(
+            data: baseAddress,
+            height: vImagePixelCount(height),
+            width: vImagePixelCount(width),
+            rowBytes: CVPixelBufferGetBytesPerRow(pixelBuffer)
+        )
+    }
+}

package/ios/PictureInPicture/StreamYUVToARGBConversion.swift

@@ -0,0 +1,128 @@
+ //
+ // Copyright © 2024 Stream.io Inc. All rights reserved.
+ //
+
+ import Accelerate
+ import Foundation
+
+ /// A class dedicated to converting YUV (YpCbCr) image data to ARGB format.
+ final class StreamYUVToARGBConversion {
+
+     /// Enum defining the color conversion coefficients for YUV to ARGB conversion.
+     ///
+     /// The coefficient in the context of `vImageConvert_YpCbCrToARGB_GenerateConversion`
+     /// refers to a set of values used to define the color conversion matrix when transforming YpCbCr pixel
+     /// format images to ARGB format. This conversion is crucial in image and video processing where color
+     /// space compatibility is necessary for various rendering, compositing, or display purposes.
+     ///
+     /// Understanding YpCbCr to ARGB Conversion YpCbCr is a color space used in video compression
+     /// and broadcasting, where Yp represents the luma component (the brightness), and Cb and Cr
+     /// represent the chroma components (the color details). Converting YpCbCr to ARGB (Alpha, Red, Green, Blue)
+     /// involves transforming these components into a format commonly used in digital images, which
+     /// includes separate channels for red, green, blue, and an alpha transparency channel.
+     ///
+     /// Role of the Coefficient
+     /// - Color Space Transformation: The coefficients are used to create a matrix that mathematically
+     /// transforms the YpCbCr values into RGB values. This matrix accounts for the differences in color
+     /// representation between the two formats, ensuring accurate color rendition.
+     ///
+     /// - Handling Various Standards: Different video standards (like ITU-R BT.601, ITU-R BT.709, etc.)
+     /// define different coefficients because they assume different color primaries (red, green, and blue points)
+     /// and different luma/chroma formulations. The coefficient matrix you choose should match the standard
+     /// used when the YpCbCr data was originally created to ensure color accuracy.
+     ///
+     /// - Performance Optimization: Using a precalculated conversion matrix (which the coefficients help define)
+     /// allows for highly optimized, performant image processing. This is critical in real-time applications,
+     /// like video playback or editing, where processing speed is crucial.
+     ///
+     /// - Adjusting Luminance and Chrominance: The coefficients can also adjust the scale and bias of the
+     /// luminance (Yp) and chrominance (Cb and Cr) to match the expected range of the ARGB format.
+     /// This is essential for maintaining the correct brightness, contrast, and color saturation in the
+     /// converted image.
+     ///
+     /// Usage in `vImageConvert_YpCbCrToARGB_GenerateConversion`
+     /// When you use `vImageConvert_YpCbCrToARGB_GenerateConversion`, you typically provide a
+     /// `vImage_YpCbCrToARGB` structure that includes the coefficients. The function then uses these
+     /// coefficients to populate the structure with the necessary data to perform the conversion efficiently.
+     /// The populated structure can subsequently be used with other vImage functions to convert image
+     /// buffers from YpCbCr to ARGB.
+     ///
+     /// The correct selection and use of the coefficient matrix are vital for achieving accurate color conversion,
+     /// maintaining image quality, and ensuring consistency across various processing stages or devices.
+     /// The ability to specify different coefficients makes the vImage framework flexible and capable of
+     /// handling various video standards and custom conversion needs.
+     ///
+     /// - Parameters:
+     ///     - YpCbCrToARGBMatrix_ITU_R_601_4: ITU-R Recommendation BT.601, often used for
+     ///     standard-definition television.
+     ///     - YpCbCrToARGBMatrix_ITU_R_709_2: ITU-R Recommendation BT.709, often used for
+     ///     high-definition television.
+     enum Coefficient {
+         /// ITU-R Recommendation BT.601, often used for standard-definition video.
+         case YpCbCrToARGBMatrix_ITU_R_601_4
+
+         /// ITU-R Recommendation BT.709, often used for high-definition video.
+         case YpCbCrToARGBMatrix_ITU_R_709_2
+
+         /// Computed property to provide a pointer to the relevant conversion matrix.
+         ///
+         /// - Returns: A pointer to the selected color conversion matrix.
+         var value: UnsafePointer<vImage_YpCbCrToARGBMatrix> {
+             switch self {
+             case .YpCbCrToARGBMatrix_ITU_R_601_4: return kvImage_YpCbCrToARGBMatrix_ITU_R_601_4
+             case .YpCbCrToARGBMatrix_ITU_R_709_2: return kvImage_YpCbCrToARGBMatrix_ITU_R_709_2
+             }
+         }
+     }
+
+     /// The pixel range configuration for YUV to ARGB conversion, defaulting to standard range.
+     private var pixelRange: vImage_YpCbCrPixelRange
+
+     /// The coefficient matrix to use, defaulting to ITU-R BT.601.
+     private var coefficient: Coefficient
+
+     /// The type of YpCbCr pixel data, default set to a common format.
+     private var inYpCbCrType: vImageYpCbCrType
+
+     /// The output ARGB pixel format, default set to 8 bits per channel.
+     private var outARGBType: vImageARGBType
+
+     /// Flags for the conversion process, with no flags set by default.
+     private var flags: UInt32
+
+     /// The resulting conversion object to be used for converting YUV to ARGB.
+     var output: vImage_YpCbCrToARGB
+
+     /// Initializes the conversion setup with optional custom parameters.
+     ///
+     /// - Parameters:
+     ///   - pixelRange: The pixel range configuration, defaulting to `.default`.
+     ///   - coefficient: The coefficient matrix to use, defaulting to `.YpCbCrToARGBMatrix_ITU_R_601_4`.
+     ///   - inYpCbCrType: The type of YpCbCr pixel data, default set to `kvImage420Yp8_Cb8_Cr8`.
+     ///   - outARGBType: The output ARGB pixel format, default set to `kvImageARGB8888`.
+     ///   - flags: Flags for the conversion process, with no flags set by default.
+     init(
+         pixelRange: vImage_YpCbCrPixelRange = .default,
+         coefficient: Coefficient = .YpCbCrToARGBMatrix_ITU_R_601_4,
+         inYpCbCrType: vImageYpCbCrType = kvImage420Yp8_Cb8_Cr8,
+         outARGBType: vImageARGBType = kvImageARGB8888,
+         flags: UInt32 = UInt32(kvImageNoFlags)
+     ) {
+         self.pixelRange = pixelRange
+         self.coefficient = coefficient
+         self.inYpCbCrType = inYpCbCrType
+         self.outARGBType = outARGBType
+         self.flags = flags
+         output = vImage_YpCbCrToARGB()
+
+         /// Generates a conversion setup for converting YpCbCr to ARGB using specified parameters.
+         vImageConvert_YpCbCrToARGB_GenerateConversion(
+             self.coefficient.value,
+             &self.pixelRange,
+             &output,
+             inYpCbCrType,
+             outARGBType,
+             flags
+         )
+     }
+ }

package/ios/PictureInPicture/WindowSizePolicy/StreamPictureInPictureAdaptiveWindowSizePolicy.swift

@@ -0,0 +1,25 @@
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+/// An adaptive window size policy for Picture-in-Picture (PiP) views.
+final class StreamPictureInPictureAdaptiveWindowSizePolicy: PictureInPictureWindowSizePolicy {
+
+    /// The current size of the track to be displayed in the PiP window.
+    var trackSize: CGSize = .zero {
+        didSet {
+            // Only update the controller's preferred content size if the track size has changed and is not zero.
+            guard trackSize != oldValue, trackSize != .zero else {
+                return
+            }
+            controller?.preferredContentSize = trackSize
+        }
+    }
+
+    /// The controller that manages the PiP view.
+    weak var controller: StreamAVPictureInPictureViewControlling?
+
+    /// Initializes a new instance of the adaptive window size policy.
+    init() {}
+}

package/ios/PictureInPicture/WindowSizePolicy/StreamPictureInPictureFixedWindowSizePolicy.swift

@@ -0,0 +1,29 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+/// A fixed window size policy for Picture-in-Picture (PiP) views.
+final class StreamPictureInPictureFixedWindowSizePolicy: PictureInPictureWindowSizePolicy {
+
+    /// The current size of the track to be displayed in the PiP window. This is not used in this policy.
+    var trackSize: CGSize = .zero
+
+    /// The controller that manages the PiP view.
+    weak var controller: (any StreamAVPictureInPictureViewControlling)? {
+        didSet {
+            // Set the preferred content size of the controller to the fixed size.
+            controller?.preferredContentSize = fixedSize
+        }
+    }
+
+    /// The fixed size for the PiP window.
+    private let fixedSize: CGSize
+
+    /// Initializes a new instance of the fixed window size policy with a specified fixed size.
+    /// - Parameter fixedSize: The fixed size for the PiP window. Default is 640x480.
+    init(_ fixedSize: CGSize = .init(width: 640, height: 480)) {
+        self.fixedSize = fixedSize
+    }
+}

package/ios/PictureInPicture/WindowSizePolicy/StreamPictureInPictureWindowSizePolicy.swift

@@ -0,0 +1,14 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+/// Protocol defining the policy for determining the window size of a Picture-in-Picture (PiP) view.
+protocol PictureInPictureWindowSizePolicy {
+    /// The current size of the track to be displayed in the PiP window.
+    var trackSize: CGSize { get set }
+
+    /// The controller that manages the PiP view.
+    var controller: StreamAVPictureInPictureViewControlling? { get set }
+}

package/ios/PictureInPicture/YpCbCrPixelRange+Default.swift

@@ -0,0 +1,32 @@
+ //
+ // Copyright © 2024 Stream.io Inc. All rights reserved.
+ //
+
+ import Accelerate
+ import Foundation
+
+ /// Extension of vImage_YpCbCrPixelRange to include a default configuration.
+ extension vImage_YpCbCrPixelRange {
+
+     /// Initializes a default pixel range for YpCbCr pixel format.
+     /// This default configuration is often used when converting YpCbCr to RGB.
+     /// - Yp_bias: The bias for the Y' (luma) component, typically 0.
+     /// - CbCr_bias: The bias for the Cb and Cr (chroma) components, usually set to 128 to center the chroma values.
+     /// - YpRangeMax: The maximum value for the Y' range, typically 255.
+     /// - CbCrRangeMax: The maximum value for the Cb and Cr range, also usually 255.
+     /// - YpMax: The maximum possible value for Y', generally 255.
+     /// - YpMin: The minimum possible value for Y', usually set to 1 for video ranges.
+     /// - CbCrMax: The maximum possible value for Cb and Cr, typically 255.
+     /// - CbCrMin: The minimum possible value for Cb and Cr, often 0.
+     /// Reference: [Apple's documentation on vImageConvert_YpCbCrToARGB](https://developer.apple.com/documentation/accelerate/1533189-vimageconvert_ypcbcrtoargb_gener)
+     static let `default` = vImage_YpCbCrPixelRange(
+         Yp_bias: 0, /// The bias applied to the Y' component.
+         CbCr_bias: 128, /// The bias applied to the Cb and Cr components.
+         YpRangeMax: 255, /// The maximum value of the Y' range.
+         CbCrRangeMax: 255, /// The maximum value of the Cb and Cr range.
+         YpMax: 255, /// The maximum value of Y'.
+         YpMin: 1, /// The minimum value of Y' (often used for setting video range).
+         CbCrMax: 255, /// The maximum value of Cb and Cr.
+         CbCrMin: 0 /// The minimum value of Cb and Cr.
+     )
+ }

package/ios/RTCViewPip.swift

@@ -0,0 +1,69 @@
+//
+//  RTCViewPip.swift
+//  stream-video-react-native
+//
+//  Created by santhosh vaiyapuri on 22/08/2024.
+//
+
+import Foundation
+
+@objc(RTCViewPip)
+class RTCViewPip: UIView {
+    
+    private lazy var pictureInPictureController = StreamPictureInPictureController()
+    private var webRtcModule: WebRTCModule?
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupView()
+    }
+    
+    required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        setupView()
+    }
+    
+    private func setupView() {
+        let videoView = UIView()
+        self.addSubview(videoView)
+        pictureInPictureController?.sourceView = videoView
+        videoView.backgroundColor = UIColor.clear // make it transparent
+    }
+    
+    func setWebRtcModule(_ module: WebRTCModule) {
+        webRtcModule = module
+    }
+    
+    @objc func setStreamURL(_ streamReactTag: NSString) {
+        webRtcModule?.workerQueue.async {
+            let stream = self.webRtcModule?.stream(forReactTag: String(streamReactTag))
+            let videoTracks = stream?.videoTracks ?? []
+            let videoTrack = videoTracks.first
+            if videoTrack == nil {
+                NSLog("PiP - No video stream for react tag: -\(streamReactTag)")
+            } else {
+                DispatchQueue.main.async {
+                    self.pictureInPictureController?.track = videoTrack
+                }
+            }
+        }
+    }
+    
+    @objc
+    func onCallClosed() {
+        DispatchQueue.main.async {
+            self.pictureInPictureController?.cleanup()
+            self.pictureInPictureController = nil
+        }
+    }
+    
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        let isVisible = self.superview != nil && self.window != nil;
+        if (!isVisible) {
+            // view is detached so we cleanup the pip controller
+            // taken from:  https://github.com/software-mansion/react-native-screens/blob/main/Example/ios/ScreensExample/RNSSampleLifecycleAwareView.m
+            onCallClosed()
+        }
+    }
+}

package/ios/RTCViewPipManager.mm

@@ -0,0 +1,16 @@
+//
+//  RTCViewPipManager.m
+//  stream-video-react-native
+//
+//  Created by santhosh vaiyapuri on 22/08/2024.
+//
+// tutorial used: https://teabreak.e-spres-oh.com/swift-in-react-native-the-ultimate-guide-part-2-ui-components-907767123d9e
+
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RTCViewPipManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(streamURL, NSString)
+RCT_EXTERN_METHOD(onCallClosed:(nonnull NSNumber*) reactTag)
+
+@end

package/ios/RTCViewPipManager.swift

@@ -0,0 +1,34 @@
+//
+//  RTCViewPipManager.swift
+//  stream-video-react-native
+//
+//  Created by santhosh vaiyapuri on 22/08/2024.
+//
+
+import Foundation
+
+@objc (RTCViewPipManager)
+class RTCViewPipManager: RCTViewManager {
+    
+    override func view() -> UIView! {
+        let view = RTCViewPip()
+        view.setWebRtcModule(self.bridge.module(forName: "WebRTCModule") as! WebRTCModule)
+        return view
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    @objc func onCallClosed(_ reactTag: NSNumber) {
+        self.bridge!.uiManager.addUIBlock { (_: RCTUIManager?, viewRegistry: [NSNumber: UIView]?) in
+            guard let view = viewRegistry?[reactTag] as? RTCViewPip else {
+                if RCT_DEBUG == 1 {
+                    print("Invalid view returned from registry, expecting RTCViewPip")
+                }
+                return
+            }
+            view.onCallClosed()
+        }
+    }
+}

package/ios/StreamVideoReactNative-Bridging-Header.h

@@ -1,3 +1,14 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
 #import <React/RCTEventEmitter.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTView.h>
+#import <React/RCTBridge.h>
+
+#import <WebRTC/RTCCVPixelBuffer.h>
+#import <WebRTC/RTCVideoFrame.h>
+#import <WebRTC/RTCVideoTrack.h>
+#import <WebRTC/RTCVideoRenderer.h>
+#import <WebRTC/RTCVideoFrameBuffer.h>
+#import "WebRTCModule.h"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.0.0-rc2.0",
+  "version": "1.0.1",
   "packageManager": "yarn@3.2.4",
   "main": "dist/commonjs/index.js",
   "module": "dist/module/index.js",
@@ -46,8 +46,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.6.0-rc2.0",
-    "@stream-io/video-react-bindings": "0.5.0-rc2.0",
+    "@stream-io/video-client": "1.6.0",
+    "@stream-io/video-react-bindings": "1.0.0",
     "intl-pluralrules": "2.0.1",
     "lodash.merge": "^4.6.2",
     "react-native-url-polyfill": "1.3.0",
@@ -125,7 +125,7 @@
     "@react-native-firebase/messaging": "17.5.0",
     "@react-native/eslint-config": "^0.74.84",
     "@stream-io/react-native-webrtc": "118.1.0",
-    "@stream-io/video-filters-react-native": "^0.2.1",
+    "@stream-io/video-filters-react-native": "^0.2.2",
     "@testing-library/jest-native": "^5.4.2",
     "@testing-library/react-native": "^12.1.2",
     "@tsconfig/node14": "14.1.0",