@stream-io/video-react-native-sdk 0.10.3 → 0.10.5

package/ios/PictureInPicture/StreamAVPictureInPictureVideoCallViewController.swift

@@ -0,0 +1,83 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import Foundation
+
+/// Describes an object that can be used to present picture-in-picture content.
+protocol StreamAVPictureInPictureViewControlling: AnyObject {
+    
+    /// The closure to call whenever the picture-in-picture window size changes.
+    var onSizeUpdate: ((CGSize) -> Void)? { get set }
+    
+    /// The track that will be rendered on picture-in-picture window.
+    var track: RTCVideoTrack? { get set }
+    
+    /// The preferred size for the picture-in-picture window.
+    /// - Important: This should **always** be greater to ``CGSize.zero``. If not, iOS throws
+    /// a cryptic error with content `PGPegasus code:-1003`
+    var preferredContentSize: CGSize { get set }
+    
+    /// The layer that renders the incoming frames from WebRTC.
+    var displayLayer: CALayer { get }
+}
+
+@available(iOS 15.0, *)
+final class StreamAVPictureInPictureVideoCallViewController: AVPictureInPictureVideoCallViewController,
+                                                             StreamAVPictureInPictureViewControlling {
+    
+    private let contentView: StreamPictureInPictureVideoRenderer =
+        .init(windowSizePolicy: StreamPictureInPictureAdaptiveWindowSizePolicy())
+    
+    var onSizeUpdate: ((CGSize) -> Void)?
+    
+    var track: RTCVideoTrack? {
+        get { contentView.track }
+        set { contentView.track = newValue }
+    }
+    
+    var displayLayer: CALayer { contentView.displayLayer }
+    
+    // MARK: - Lifecycle
+
+     @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+    /// Initializes a new instance and sets the `preferredContentSize` to `Self.defaultPreferredContentSize`
+    /// value.
+    required init() {
+        super.init(nibName: nil, bundle: nil)
+        contentView.pictureInPictureWindowSizePolicy.controller = self
+    }
+
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setUp()
+    }
+    
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        contentView.bounds = view.bounds
+        onSizeUpdate?(contentView.bounds.size)
+    }
+    
+    // MARK: - Private helpers
+    
+    private func setUp() {
+        view.subviews.forEach { $0.removeFromSuperview() }
+        
+        contentView.translatesAutoresizingMaskIntoConstraints = false
+        
+        view.addSubview(contentView)
+        NSLayoutConstraint.activate([
+            contentView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            contentView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            contentView.topAnchor.constraint(equalTo: view.topAnchor),
+            contentView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+        
+        contentView.bounds = view.bounds
+    }
+}

package/ios/PictureInPicture/StreamBufferTransformer.swift

@@ -0,0 +1,96 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+/// `StreamBufferTransformer` is a struct that provides methods for transforming RTCI420Buffer to
+/// CVPixelBuffer, while performing downsampling when necessary.
+struct StreamBufferTransformer {
+    
+    var requiresResize = false
+
+    /// Transforms an RTCVideoFrame's buffer  to a CMSampleBuffer with optional resizing.
+    /// - Note: The current implementation always handles an i420 buffer as RTCCVPixelBuffer have been
+    /// proven problematic.
+    /// - Parameters:
+    ///   - source: The source RTCVideoFrameBuffer to be transformed.
+    ///   - targetSize: The target size for the resulting CMSampleBuffer.
+    /// - Returns: A transformed RTCVideoFrame or nil if transformation fails.
+    func transformAndResizeIfRequired(
+        _ frame: RTCVideoFrame,
+        targetSize: CGSize
+    ) -> RTCVideoFrame? {
+        let pixelBuffer: RTCVideoFrameBuffer? = {
+            if let i420buffer = frame.buffer as? RTCI420Buffer {
+                return i420buffer
+            } else {
+                return frame.buffer
+            }
+        }()
+
+        if
+            let pixelBuffer = pixelBuffer,
+            let buffer = transformAndResizeIfRequired(pixelBuffer, targetSize: targetSize) {
+            return .init(
+                buffer: buffer,
+                rotation: frame.rotation,
+                timeStampNs: frame.timeStampNs
+            )
+        } else {
+            return nil
+        }
+    }
+
+    // MARK: - Private API
+    
+    /// Transforms an RTCVideoFrameBuffer to a CMSampleBuffer with optional resizing.
+    /// - Note: The current implementation always handles an i420 buffer as RTCCVPixelBuffer have been
+    /// proven problematic.
+    /// - Parameters:
+    ///   - source: The source RTCVideoFrameBuffer to be transformed.
+    ///   - targetSize: The target size for the resulting CMSampleBuffer.
+    /// - Returns: A transformed CMSampleBuffer or nil if transformation fails.
+    func transformAndResizeIfRequired(
+        _ source: RTCVideoFrameBuffer,
+        targetSize: CGSize
+    ) -> StreamRTCYUVBuffer? {
+        let sourceSize = CGSize(width: Int(source.width), height: Int(source.height))
+        let resultBuffer: StreamRTCYUVBuffer? = {
+            if requiresResize {
+                return .init(source: source)
+                    .resize(to: resizeSize(sourceSize, toFitWithin: targetSize))
+            } else {
+                return .init(source: source)
+            }
+        }()
+        
+        return resultBuffer
+    }
+    
+    /// Calculates the new size to fit within a container size while maintaining the aspect ratio.
+    ///
+    /// - Parameters:
+    ///   - size: The original size.
+    ///   - containerSize: The container size to fit within.
+    /// - Returns: The new size that fits within the container while preserving the aspect ratio.
+    private func resizeSize(
+        _ size: CGSize,
+        toFitWithin containerSize: CGSize
+    ) -> CGSize {
+        let widthRatio = containerSize.width / size.width
+        let heightRatio = containerSize.height / size.height
+        
+        // Choose the smaller ratio to ensure that the entire original size fits
+        // within the container.
+        let ratioToUse = min(widthRatio, heightRatio)
+        
+        // Calculate the new size while maintaining the aspect ratio.
+        let newSize = CGSize(
+            width: size.width * ratioToUse,
+            height: size.height * ratioToUse
+        )
+        
+        return newSize
+    }
+}

package/ios/PictureInPicture/StreamPictureInPictureController.swift

@@ -0,0 +1,185 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import Combine
+import Foundation
+
+/// A controller class for picture-in-picture whenever that is possible.
+@objc final class StreamPictureInPictureController: NSObject, AVPictureInPictureControllerDelegate {
+    
+    // MARK: - Properties
+    
+    /// The RTCVideoTrack for which the picture-in-picture session is created.
+    @objc public var track: RTCVideoTrack? {
+        didSet {
+            didUpdate(track) // Called when the `track` property changes
+        }
+    }
+    
+    /// The UIView that contains the video content.
+    @objc public var sourceView: UIView? {
+        didSet {
+            didUpdate(sourceView) // Called when the `sourceView` property changes
+        }
+    }
+    
+    /// A closure called when the picture-in-picture view's size changes.
+    public var onSizeUpdate: ((CGSize) -> Void)? {
+        didSet {
+            contentViewController?.onSizeUpdate = onSizeUpdate // Updates the onSizeUpdate closure of the content view controller
+        }
+    }
+    
+    /// A boolean value indicating whether the picture-in-picture session should start automatically when the app enters background.
+    public var canStartPictureInPictureAutomaticallyFromInline: Bool
+    
+    // MARK: - Private Properties
+    
+    /// The AVPictureInPictureController object.
+    private var pictureInPictureController: AVPictureInPictureController?
+    
+    /// The StreamAVPictureInPictureViewControlling object that manages the picture-in-picture view.
+    private var contentViewController: StreamAVPictureInPictureViewControlling?
+    
+    /// A set of `AnyCancellable` objects used to manage subscriptions.
+    private var cancellableBag: Set<AnyCancellable> = []
+    
+    /// A `AnyCancellable` object used to ensure that the active track is enabled while in picture-in-picture
+    /// mode.
+    private var ensureActiveTrackIsEnabledCancellable: AnyCancellable?
+    
+    /// A `StreamPictureInPictureTrackStateAdapter` object that manages the state of the
+    /// active track.
+    private let trackStateAdapter: StreamPictureInPictureTrackStateAdapter = .init()
+    
+    // MARK: - Lifecycle
+    
+    /// Initializes the controller and creates the content view
+    ///
+    /// - Parameter canStartPictureInPictureAutomaticallyFromInline A boolean value
+    /// indicating whether the picture-in-picture session should start automatically when the app enters
+    /// background.
+    ///
+    /// - Returns `nil` if AVPictureInPictureController is not supported, or the controller otherwise.
+    init?(canStartPictureInPictureAutomaticallyFromInline: Bool = true) {
+        guard AVPictureInPictureController.isPictureInPictureSupported() else {
+            return nil
+        }
+        
+        let contentViewController: StreamAVPictureInPictureViewControlling? = {
+            if #available(iOS 15.0, *) {
+                return StreamAVPictureInPictureVideoCallViewController()
+            } else {
+                return nil
+            }
+        }()
+        // contentViewController?.preferredContentSize = .init(width: 400, height: 320)
+        self.contentViewController = contentViewController
+        self.canStartPictureInPictureAutomaticallyFromInline = canStartPictureInPictureAutomaticallyFromInline
+        super.init()
+    }
+    
+    // MARK: - AVPictureInPictureControllerDelegate
+    
+    func pictureInPictureController(
+        _ pictureInPictureController: AVPictureInPictureController,
+        restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
+    ) {
+        completionHandler(true)
+    }
+    
+    public func pictureInPictureControllerWillStartPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+    }
+    
+    public func pictureInPictureControllerDidStartPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+    }
+    
+    public func pictureInPictureController(
+        _ pictureInPictureController: AVPictureInPictureController,
+        failedToStartPictureInPictureWithError error: Error
+    ) {
+    }
+    
+    public func pictureInPictureControllerWillStopPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+    }
+    
+    public func pictureInPictureControllerDidStopPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+    }
+    
+    // MARK: - Private helpers
+    
+    private func didUpdate(_ track: RTCVideoTrack?) {
+        contentViewController?.track = track
+        trackStateAdapter.activeTrack = track
+    }
+    
+    @objc private func didUpdate(_ sourceView: UIView?) {
+        if let sourceView {
+            // If picture-in-picture isn't active, just create a new controller.
+            if pictureInPictureController?.isPictureInPictureActive != true {
+                makePictureInPictureController(with: sourceView)
+                
+                pictureInPictureController?
+                    .publisher(for: \.isPictureInPicturePossible)
+                    .sink { NSLog("PiP - isPictureInPicturePossible:\($0)") }
+                    .store(in: &cancellableBag)
+                
+                pictureInPictureController?
+                    .publisher(for: \.isPictureInPictureActive)
+                    .removeDuplicates()
+                    .sink { [weak self] in self?.didUpdatePictureInPictureActiveState($0) }
+                    .store(in: &cancellableBag)
+            } else {
+                // If picture-in-picture is active, simply update the sourceView.
+                makePictureInPictureController(with: sourceView)
+            }
+        } else {
+            if #available(iOS 15.0, *) {
+                pictureInPictureController?.contentSource = nil
+            }
+        }
+    }
+    
+    @objc func cleanup() {
+        contentViewController?.track = nil
+        if #available(iOS 15.0, *) {
+            pictureInPictureController?.contentSource = nil
+        }
+        pictureInPictureController?.delegate = nil
+        pictureInPictureController = nil
+        
+    }
+    
+    private func makePictureInPictureController(with sourceView: UIView) {
+        if #available(iOS 15.0, *),
+           let contentViewController = contentViewController as? StreamAVPictureInPictureVideoCallViewController {
+            pictureInPictureController = .init(
+                contentSource: .init(
+                    activeVideoCallSourceView: sourceView,
+                    contentViewController: contentViewController
+                )
+            )
+        }
+        
+        if #available(iOS 14.2, *) {
+            pictureInPictureController?
+                .canStartPictureInPictureAutomaticallyFromInline = canStartPictureInPictureAutomaticallyFromInline
+        }
+        
+        pictureInPictureController?.delegate = self
+    }
+    
+    private func didUpdatePictureInPictureActiveState(_ isActive: Bool) {
+        trackStateAdapter.isEnabled = isActive
+    }
+}

package/ios/PictureInPicture/StreamPictureInPictureTrackStateAdapter.swift

@@ -0,0 +1,68 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Combine
+import Foundation
+
+/// StreamPictureInPictureTrackStateAdapter serves as an adapter for managing the state of a video track
+/// used for picture-in-picture functionality. It can enable or disable observers based on its isEnabled property
+/// and ensures that the active track is always enabled when necessary.
+final class StreamPictureInPictureTrackStateAdapter {
+    
+    /// This property represents whether the adapter is enabled or not.
+    var isEnabled: Bool = false {
+        didSet {
+            /// When the 'isEnabled' property changes, this didSet observer is called.
+            /// It checks if the new value is different from the old value, and if so,
+            /// it calls the 'enableObserver' function.
+            guard isEnabled != oldValue else { return }
+            enableObserver(isEnabled)
+        }
+    }
+    
+    /// This property represents the active RTCVideoTrack.
+    var activeTrack: RTCVideoTrack? {
+        didSet {
+            /// When the 'activeTrack' property changes, this didSet observer is called.
+            /// If the adapter is enabled and the new 'activeTrack' is different from the old one,
+            /// it disables the old track (if it exists).
+            if isEnabled, oldValue?.trackId != activeTrack?.trackId {
+                oldValue?.isEnabled = false
+            }
+        }
+    }
+    
+    // MARK: - Private helpers
+    
+    /// This property holds a reference to the observer cancellable.
+    private var observerCancellable: AnyCancellable?
+    
+    /// This private function enables or disables an observer based on the 'isActive' parameter.
+    ///
+    /// - Parameter isActive: A Boolean value indicating whether the observer should be active.
+    private func enableObserver(_ isActive: Bool) {
+        if isActive {
+            /// If 'isActive' is true, it sets up an observer that checks tracks state periodically.
+            observerCancellable = Timer
+                .publish(every: 0.1, on: .main, in: .default)
+                .autoconnect()
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self] _ in
+                    self?.checkTracksState()
+                }
+        } else {
+            /// If 'isActive' is false, it cancels the observer.
+            observerCancellable?.cancel()
+            observerCancellable = nil
+        }
+    }
+    
+    /// This private function checks the state of the active track and enables it if it's not already enabled.
+    private func checkTracksState() {
+        if let activeTrack, !activeTrack.isEnabled {
+//            log.info("⚙️Active track:\(activeTrack.trackId) for picture-in-picture will be enabled now.")
+            self.activeTrack?.isEnabled = true
+        }
+    }
+}

package/ios/PictureInPicture/StreamPictureInPictureVideoRenderer.swift

@@ -0,0 +1,250 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Combine
+import Foundation
+
+/// A view that can be used to render an instance of `RTCVideoTrack`
+final class StreamPictureInPictureVideoRenderer: UIView, RTCVideoRenderer {
+    
+    /// The rendering track.
+    var track: RTCVideoTrack? {
+        didSet {
+            // Whenever the track changes we perform the following operations if possible:
+            // - stopFrameStreaming for the old track
+            // - startFrameStreaming for the new track and only if we are already
+            // in picture-in-picture.
+            guard oldValue != track else { return }
+            prepareForTrackRendering(oldValue)
+        }
+    }
+    
+    /// The layer that renders the track's frames.
+    var displayLayer: CALayer { contentView.layer }
+
+    /// A policy defining how the Picture in Picture window should be resized in order to better fit
+    /// the rendering frame size.
+    var pictureInPictureWindowSizePolicy: PictureInPictureWindowSizePolicy
+    
+    /// The publisher which is used to streamline the frames received from the track.
+    private let bufferPublisher: PassthroughSubject<CMSampleBuffer, Never> = .init()
+    
+    /// The view that contains the rendering layer.
+    private lazy var contentView: SampleBufferVideoCallView = {
+        let contentView = SampleBufferVideoCallView()
+        contentView.translatesAutoresizingMaskIntoConstraints = false
+        contentView.contentMode = .scaleAspectFill
+        contentView.videoGravity = .resizeAspectFill
+        contentView.preventsDisplaySleepDuringVideoPlayback = true
+        return contentView
+    }()
+    
+    /// The transformer used to transform and downsample a RTCVideoFrame's buffer.
+    private var bufferTransformer = StreamBufferTransformer()
+    
+    /// The cancellable used to control the bufferPublisher stream.
+    private var bufferUpdatesCancellable: AnyCancellable?
+    
+    /// The view's size.
+    /// - Note: We are using this property instead for `frame.size` or `bounds.size` so we can
+    /// access it from any thread.
+    private var contentSize: CGSize = .zero
+    
+    /// The track's size.
+    private var trackSize: CGSize = .zero {
+        didSet {
+            guard trackSize != oldValue else { return }
+            didUpdateTrackSize()
+        }
+    }
+    
+    /// A property that defines if the RTCVideoFrame instances that will be rendered need to be resized
+    /// to fid the view's contentSize.
+    private var requiresResize = false {
+        didSet { bufferTransformer.requiresResize = requiresResize }
+    }
+    
+    /// As we are operate in smaller rendering bounds we skip frames depending on this property's value
+    /// to improve performance.
+    /// - Note: The number of frames to skip is being calculated based on the ``trackSize`` and
+    /// ``contentSize``. It takes into account also the ``sizeRatioThreshold``
+    private var noOfFramesToSkipAfterRendering = 1
+    
+    /// The number of frames that we have skipped so far. This is used as a step counter in the
+    /// ``renderFrame(_:)``.
+    private var skippedFrames = 0
+    
+    /// We render frames every time the stepper/counter value is 0 and have a valid trackSize.
+    private var shouldRenderFrame: Bool { skippedFrames == 0 && trackSize != .zero }
+    
+    /// A size ratio threshold used to determine if resizing is required.
+    /// - Note: It seems that Picture-in-Picture doesn't like rendering frames that are bigger than its
+    /// window size. For this reason, we are setting the resizeThreshold to `1`.
+    private let resizeRequiredSizeRatioThreshold: CGFloat = 1
+    
+    /// A size ratio threshold used to determine if skipping frames is required.
+    private let sizeRatioThreshold: CGFloat = 15
+    
+    // MARK: - Lifecycle
+    
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+    
+    init(windowSizePolicy: PictureInPictureWindowSizePolicy) {
+        pictureInPictureWindowSizePolicy = windowSizePolicy
+        super.init(frame: .zero)
+        setUp()
+    }
+    
+    override func willMove(toWindow newWindow: UIWindow?) {
+        super.willMove(toWindow: newWindow)
+        // Depending on the window we are moving we either start or stop
+        // streaming frames from the track.
+        if newWindow != nil {
+            startFrameStreaming(for: track, on: newWindow)
+        } else {
+            stopFrameStreaming(for: track)
+        }
+    }
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        contentSize = frame.size
+    }
+    
+    // MARK: - Rendering lifecycle
+    
+    /// This method is being called from WebRTC and asks the container to set its size to the track's size.
+    func setSize(_ size: CGSize) {
+        trackSize = size
+    }
+    
+    func renderFrame(_ frame: RTCVideoFrame?) {
+        guard let frame = frame else {
+            return
+        }
+        
+        // Update the trackSize and re-calculate rendering properties if the size
+        // has changed.
+        trackSize = .init(width: Int(frame.width), height: Int(frame.height))
+        
+        defer {
+            handleFrameSkippingIfRequired()
+        }
+        
+        guard shouldRenderFrame else {
+            return
+        }
+
+        if
+            let yuvBuffer = bufferTransformer.transformAndResizeIfRequired(frame, targetSize: contentSize)?
+            .buffer as? StreamRTCYUVBuffer,
+            let sampleBuffer = yuvBuffer.sampleBuffer {
+            bufferPublisher.send(sampleBuffer)
+        } 
+    }
+    
+    // MARK: - Private helpers
+    
+    /// Set up the view's hierarchy.
+    private func setUp() {
+        addSubview(contentView)
+        NSLayoutConstraint.activate([
+            contentView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            contentView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            contentView.topAnchor.constraint(equalTo: topAnchor),
+            contentView.bottomAnchor.constraint(equalTo: bottomAnchor)
+        ])
+    }
+    
+    /// A method used to process the frame's buffer and enqueue on the rendering view.
+    private func process(_ buffer: CMSampleBuffer) {
+        guard
+            bufferUpdatesCancellable != nil,
+            let trackId = track?.trackId,
+            buffer.isValid
+        else {
+            contentView.renderingComponent.flush()
+            return
+        }
+        
+        if #available(iOS 14.0, *) {
+            if contentView.renderingComponent.requiresFlushToResumeDecoding == true {
+                contentView.renderingComponent.flush()
+            }
+        }
+        
+        if contentView.renderingComponent.isReadyForMoreMediaData {
+            contentView.renderingComponent.enqueue(buffer)
+        }
+    }
+    
+    /// A method used to start consuming frames from the track.
+    /// - Note: In order to avoid unnecessary processing, we only start consuming track's frames when
+    /// the view has been added on a window (which means that picture-in-picture view is visible).
+    private func startFrameStreaming(
+        for track: RTCVideoTrack?,
+        on window: UIWindow?
+    ) {
+        guard window != nil, let track else { return }
+        
+        bufferUpdatesCancellable = bufferPublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] in self?.process($0) }
+        
+        track.add(self)
+    }
+    
+    /// A method that stops the frame consumption from the track. Used automatically when the rendering
+    /// view move's away from the window or when the track changes.
+    private func stopFrameStreaming(for track: RTCVideoTrack?) {
+        guard bufferUpdatesCancellable != nil else { return }
+        bufferUpdatesCancellable?.cancel()
+        bufferUpdatesCancellable = nil
+        track?.remove(self)
+        contentView.renderingComponent.flush()
+    }
+    
+    /// A method used to calculate rendering required properties, every time the trackSize changes.
+    private func didUpdateTrackSize() {
+        guard contentSize != .zero, trackSize != .zero else { return }
+        
+        let widthDiffRatio = trackSize.width / contentSize.width
+        let heightDiffRatio = trackSize.height / contentSize.height
+        requiresResize = widthDiffRatio >= resizeRequiredSizeRatioThreshold || heightDiffRatio >= resizeRequiredSizeRatioThreshold
+        let requiresFramesSkipping = widthDiffRatio >= sizeRatioThreshold || heightDiffRatio >= sizeRatioThreshold
+        
+        /// Skipping frames is decided based on how much bigger is the incoming frame's size compared
+        /// to PiP window's size.
+        noOfFramesToSkipAfterRendering = requiresFramesSkipping ? max(Int(max(Int(widthDiffRatio), Int(heightDiffRatio)) / 2), 1) :
+        0
+        skippedFrames = 0
+
+         /// We update the provided windowSizePolicy with the size of the track we received, transformed
+        /// to the value that fits.
+        pictureInPictureWindowSizePolicy.trackSize = trackSize
+    }
+    
+    /// A method used to handle the frameSkipping(step) during frame consumption.
+    private func handleFrameSkippingIfRequired() {
+        if noOfFramesToSkipAfterRendering > 0 {
+            if skippedFrames == noOfFramesToSkipAfterRendering {
+                skippedFrames = 0
+            } else {
+                skippedFrames += 1
+            }
+        } else if skippedFrames > 0 {
+            skippedFrames = 0
+        }
+    }
+    
+    /// A method used to prepare the view for a new track rendering.
+    private func prepareForTrackRendering(_ oldValue: RTCVideoTrack?) {
+        stopFrameStreaming(for: oldValue)
+        noOfFramesToSkipAfterRendering = 0
+        skippedFrames = 0
+        requiresResize = false
+        startFrameStreaming(for: track, on: window)
+    }
+}