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

package/dist/typescript/components/Call/CallLayout/CallParticipantsSpotlight.d.ts

@@ -5,7 +5,7 @@ import { CallContentProps } from '../CallContent';
 /**
  * Props for the CallParticipantsSpotlight component.
  */
-export type CallParticipantsSpotlightProps = ParticipantViewComponentProps & Pick<CallContentProps, 'supportedReactions' | 'CallParticipantsList' | 'ScreenShareOverlay'> & Pick<CallParticipantsListComponentProps, 'ParticipantView'> & {
+export type CallParticipantsSpotlightProps = ParticipantViewComponentProps & Pick<CallContentProps, 'supportedReactions' | 'CallParticipantsList' | 'ScreenShareOverlay' | 'disablePictureInPicture'> & Pick<CallParticipantsListComponentProps, 'ParticipantView'> & {
     /**
      * Check if device is in landscape mode.
      * This will apply the landscape mode styles to the component.
@@ -16,5 +16,5 @@ export type CallParticipantsSpotlightProps = ParticipantViewComponentProps & Pic
  * Component used to display the list of participants in a spotlight mode.
  * This can be used when you want to render the screen sharing stream.
  */
-export declare const CallParticipantsSpotlight: ({ CallParticipantsList, ParticipantLabel, ParticipantNetworkQualityIndicator, ParticipantReaction, ParticipantVideoFallback, ParticipantView, ScreenShareOverlay, VideoRenderer, supportedReactions, landscape, }: CallParticipantsSpotlightProps) => React.JSX.Element;
+export declare const CallParticipantsSpotlight: ({ CallParticipantsList, ParticipantLabel, ParticipantNetworkQualityIndicator, ParticipantReaction, ParticipantVideoFallback, ParticipantView, ScreenShareOverlay, VideoRenderer, supportedReactions, landscape, disablePictureInPicture, }: CallParticipantsSpotlightProps) => React.JSX.Element;
 //# sourceMappingURL=CallParticipantsSpotlight.d.ts.map

package/dist/typescript/components/Call/CallLayout/CallParticipantsSpotlight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallParticipantsSpotlight.d.ts","sourceRoot":"","sources":["../../../../../src/components/Call/CallLayout/CallParticipantsSpotlight.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,OAAO,EAEL,kCAAkC,EACnC,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAEL,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,6BAA6B,GACxE,IAAI,CACF,gBAAgB,EAChB,oBAAoB,GAAG,sBAAsB,GAAG,oBAAoB,CACrE,GACD,IAAI,CAAC,kCAAkC,EAAE,iBAAiB,CAAC,GAAG;IAC5D;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,yBAAyB,sNAWnC,8BAA8B,sBAmGhC,CAAC"}
+{"version":3,"file":"CallParticipantsSpotlight.d.ts","sourceRoot":"","sources":["../../../../../src/components/Call/CallLayout/CallParticipantsSpotlight.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,OAAO,EAEL,kCAAkC,EACnC,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAEL,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,6BAA6B,GACxE,IAAI,CACF,gBAAgB,EACd,oBAAoB,GACpB,sBAAsB,GACtB,oBAAoB,GACpB,yBAAyB,CAC5B,GACD,IAAI,CAAC,kCAAkC,EAAE,iBAAiB,CAAC,GAAG;IAC5D;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,yBAAyB,+OAYnC,8BAA8B,sBAmGhC,CAAC"}

package/dist/typescript/hooks/useAutoEnterPiPEffect.d.ts

@@ -1,2 +1,2 @@
-export declare function useAutoEnterPiPEffect(): void;
+export declare function useAutoEnterPiPEffect(disablePictureInPicture: boolean | undefined): void;
 //# sourceMappingURL=useAutoEnterPiPEffect.d.ts.map

package/dist/typescript/hooks/useAutoEnterPiPEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAutoEnterPiPEffect.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAutoEnterPiPEffect.tsx"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,SAYpC"}
+{"version":3,"file":"useAutoEnterPiPEffect.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAutoEnterPiPEffect.tsx"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CACnC,uBAAuB,EAAE,OAAO,GAAG,SAAS,QAe7C"}

package/dist/typescript/hooks/useIsInPiPMode.d.ts

@@ -1,2 +1,2 @@
-export declare function useIsInPiPMode(): boolean;
+export declare function useIsInPiPMode(disablePictureInPicture: boolean | undefined): boolean | undefined;
 //# sourceMappingURL=useIsInPiPMode.d.ts.map

package/dist/typescript/hooks/useIsInPiPMode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsInPiPMode.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsInPiPMode.tsx"],"names":[],"mappings":"AAYA,wBAAgB,cAAc,YA6C7B"}
+{"version":3,"file":"useIsInPiPMode.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsInPiPMode.tsx"],"names":[],"mappings":"AAYA,wBAAgB,cAAc,CAAC,uBAAuB,EAAE,OAAO,GAAG,SAAS,uBA+C1E"}

package/dist/typescript/providers/StreamCall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StreamCall.d.ts","sourceRoot":"","sources":["../../../src/providers/StreamCall.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,iBAAiB,EAAqB,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAS/C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AACF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wBAGpB,iBAAiB,CAAC,eAAe,CAAC,sBAUpC,CAAC"}
+{"version":3,"file":"StreamCall.d.ts","sourceRoot":"","sources":["../../../src/providers/StreamCall.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,iBAAiB,EAAqB,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAU/C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AACF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wBAGpB,iBAAiB,CAAC,eAAe,CAAC,sBAUpC,CAAC"}

package/dist/typescript/utils/internal/shouldDisableIOSLocalVideoOnBackground.d.ts

@@ -0,0 +1,4 @@
+export declare const shouldDisableIOSLocalVideoOnBackgroundRef: {
+    current: boolean;
+};
+//# sourceMappingURL=shouldDisableIOSLocalVideoOnBackground.d.ts.map

package/dist/typescript/utils/internal/shouldDisableIOSLocalVideoOnBackground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldDisableIOSLocalVideoOnBackground.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/shouldDisableIOSLocalVideoOnBackground.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yCAAyC;;CAErD,CAAC"}

package/dist/typescript/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.0.0-rc2.0";
+export declare const version = "1.0.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/typescript/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,gBAAgB,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/ios/PictureInPicture/SampleBufferVideoCallView.swift

@@ -0,0 +1,52 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import UIKit
+
+final class SampleBufferVideoCallView: UIView {
+    override class var layerClass: AnyClass {
+        AVSampleBufferDisplayLayer.self
+    }
+    
+    private var sampleBufferDisplayLayer: AVSampleBufferDisplayLayer {
+        layer as! AVSampleBufferDisplayLayer
+    }
+
+    var renderingComponent: SampleBufferVideoRendering {
+        #if swift(>=5.9)
+        if #available(iOS 17.0, *) {
+            return sampleBufferDisplayLayer.sampleBufferRenderer
+        } else {
+            return sampleBufferDisplayLayer
+        }
+        #else
+        return sampleBufferDisplayLayer
+        #endif
+    }
+
+    var videoGravity: AVLayerVideoGravity {
+        get { sampleBufferDisplayLayer.videoGravity }
+        set { sampleBufferDisplayLayer.videoGravity = newValue }
+    }
+
+    var preventsDisplaySleepDuringVideoPlayback: Bool {
+        get { sampleBufferDisplayLayer.preventsDisplaySleepDuringVideoPlayback }
+        set { sampleBufferDisplayLayer.preventsDisplaySleepDuringVideoPlayback = newValue }
+    }
+}
+
+protocol SampleBufferVideoRendering {
+    @available(iOS 14.0, *)
+    var requiresFlushToResumeDecoding: Bool { get }
+    var isReadyForMoreMediaData: Bool { get }
+    func flush()
+    func enqueue(_ sampleBuffer: CMSampleBuffer)
+}
+
+extension AVSampleBufferDisplayLayer: SampleBufferVideoRendering {}
+#if swift(>=5.9)
+@available(iOS 17.0, *)
+extension AVSampleBufferVideoRenderer: SampleBufferVideoRendering {}
+#endif

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
+        }
+    }
+}