@stream-io/video-react-native-sdk 1.29.4-beta.0 → 1.30.0

package/ios/PictureInPicture/StreamAVPictureInPictureVideoCallViewController.swift

@@ -7,13 +7,13 @@ 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`
@@ -24,17 +24,65 @@ protocol StreamAVPictureInPictureViewControlling: AnyObject {
     
     /// The layer that renders the incoming frames from WebRTC.
     var displayLayer: CALayer { get }
+
+    // MARK: - Avatar Placeholder Properties
+
+    /// The participant's name for the avatar placeholder
+    var participantName: String? { get set }
+
+    /// The URL string for the participant's profile image
+    var participantImageURL: String? { get set }
+
+    /// Whether video is enabled - when false, shows avatar placeholder
+    var isVideoEnabled: Bool { get set }
+
+    // MARK: - Reconnection Properties
+
+    /// Whether the call is reconnecting - when true, shows reconnection view
+    var isReconnecting: Bool { get set }
+
+    // MARK: - Screen Sharing Properties
+
+    /// Whether screen sharing is active (used for content state tracking)
+    var isScreenSharing: Bool { get set }
+
+    // MARK: - Participant Overlay Properties
+
+    /// Whether the participant has audio enabled (shown in participant overlay)
+    var hasAudio: Bool { get set }
+
+    /// Whether the video track is paused (shown in participant overlay)
+    var isTrackPaused: Bool { get set }
+
+    /// Whether the participant is pinned (shown in participant overlay)
+    var isPinned: Bool { get set }
+
+    /// Whether the participant is currently speaking (shows border highlight)
+    var isSpeaking: Bool { get set }
+
+    /// The connection quality level (0: unknown, 1: poor, 2: good, 3: excellent)
+    var connectionQuality: Int { get set }
+
+    // MARK: - Content State System
+
+    /// The content state manager for unified state handling.
+    /// When set, the view controller subscribes to content changes automatically.
+    var contentState: PictureInPictureContentState? { get set }
+
+    /// The current content being displayed.
+    /// Can be set directly for one-off updates or managed via contentState for reactive updates.
+    var content: PictureInPictureContent { get set }
 }
 
 @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 }
@@ -46,7 +94,77 @@ final class StreamAVPictureInPictureVideoCallViewController: AVPictureInPictureV
     }
     
     var displayLayer: CALayer { contentView.displayLayer }
-    
+
+    // MARK: - Avatar Placeholder Properties
+
+    var participantName: String? {
+        get { contentView.participantName }
+        set { contentView.participantName = newValue }
+    }
+
+    var participantImageURL: String? {
+        get { contentView.participantImageURL }
+        set { contentView.participantImageURL = newValue }
+    }
+
+    var isVideoEnabled: Bool {
+        get { contentView.isVideoEnabled }
+        set { contentView.isVideoEnabled = newValue }
+    }
+
+    // MARK: - Reconnection Properties
+
+    var isReconnecting: Bool {
+        get { contentView.isReconnecting }
+        set { contentView.isReconnecting = newValue }
+    }
+
+    // MARK: - Screen Sharing Properties
+
+    var isScreenSharing: Bool {
+        get { contentView.isScreenSharing }
+        set { contentView.isScreenSharing = newValue }
+    }
+
+    // MARK: - Participant Overlay Properties
+
+    var hasAudio: Bool {
+        get { contentView.hasAudio }
+        set { contentView.hasAudio = newValue }
+    }
+
+    var isTrackPaused: Bool {
+        get { contentView.isTrackPaused }
+        set { contentView.isTrackPaused = newValue }
+    }
+
+    var isPinned: Bool {
+        get { contentView.isPinned }
+        set { contentView.isPinned = newValue }
+    }
+
+    var isSpeaking: Bool {
+        get { contentView.isSpeaking }
+        set { contentView.isSpeaking = newValue }
+    }
+
+    var connectionQuality: Int {
+        get { contentView.connectionQuality }
+        set { contentView.connectionQuality = newValue }
+    }
+
+    // MARK: - Content State System
+
+    var contentState: PictureInPictureContentState? {
+        get { contentView.contentState }
+        set { contentView.contentState = newValue }
+    }
+
+    var content: PictureInPictureContent {
+        get { contentView.content }
+        set { contentView.content = newValue }
+    }
+
     // MARK: - Lifecycle
 
      @available(*, unavailable)

package/ios/PictureInPicture/StreamPictureInPictureController.swift

@@ -7,31 +7,36 @@ import Combine
 import Foundation
 
 /// A controller class for picture-in-picture whenever that is possible.
-@objc final class StreamPictureInPictureController: NSObject, AVPictureInPictureControllerDelegate {
-    
+///
+/// This controller manages the Picture-in-Picture window state and handles transitions
+/// between foreground and background states. It uses the `PictureInPictureContentState`
+/// for centralized state management and a delegate proxy pattern to enable reactive
+/// handling of PiP lifecycle events.
+@objc final class StreamPictureInPictureController: NSObject {
+
     // 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 closure called when the picture-in-picture state changes.
     public var onPiPStateChange: ((Bool) -> Void)?
 
@@ -44,28 +49,118 @@ import Foundation
     
     /// A boolean value indicating whether the picture-in-picture session should start automatically when the app enters background.
     public var canStartPictureInPictureAutomaticallyFromInline: Bool
-    
+
+    // MARK: - Content State Properties
+    // These properties update the centralized content state, which manages view switching
+
+    /// The participant's name for the avatar placeholder
+    @objc public var participantName: String? {
+        didSet {
+            syncContentStateIfNeeded()
+        }
+    }
+
+    /// The URL string for the participant's profile image
+    @objc public var participantImageURL: String? {
+        didSet {
+            syncContentStateIfNeeded()
+        }
+    }
+
+    /// Whether video is enabled - when false, shows avatar placeholder
+    @objc public var isVideoEnabled: Bool = true {
+        didSet {
+            syncContentStateIfNeeded()
+        }
+    }
+
+    /// Whether the call is reconnecting - when true, shows reconnection view
+    @objc public var isReconnecting: Bool = false {
+        didSet {
+            syncContentStateIfNeeded()
+        }
+    }
+
+    /// Whether screen sharing is active (used for content state tracking)
+    @objc public var isScreenSharing: Bool = false {
+        didSet {
+            syncContentStateIfNeeded()
+        }
+    }
+
+    /// Whether the participant has audio enabled (shown in participant overlay)
+    @objc public var hasAudio: Bool = true {
+        didSet {
+            contentViewController?.hasAudio = hasAudio
+        }
+    }
+
+    /// Whether the video track is paused (shown in participant overlay)
+    @objc public var isTrackPaused: Bool = false {
+        didSet {
+            contentViewController?.isTrackPaused = isTrackPaused
+        }
+    }
+
+    /// Whether the participant is pinned (shown in participant overlay)
+    @objc public var isPinned: Bool = false {
+        didSet {
+            contentViewController?.isPinned = isPinned
+        }
+    }
+
+    /// Whether the participant is currently speaking (shows border highlight)
+    @objc public var isSpeaking: Bool = false {
+        didSet {
+            contentViewController?.isSpeaking = isSpeaking
+        }
+    }
+
+    /// The connection quality level (0: unknown, 1: poor, 2: good, 3: excellent)
+    @objc public var connectionQuality: Int = 0 {
+        didSet {
+            contentViewController?.connectionQuality = connectionQuality
+        }
+    }
+
     // MARK: - Private Properties
-    
+
     /// The AVPictureInPictureController object.
     private var pictureInPictureController: AVPictureInPictureController?
-    
+
     /// The StreamAVPictureInPictureViewControlling object that manages the picture-in-picture view.
     private var contentViewController: StreamAVPictureInPictureViewControlling?
-    
+
+    /// Centralized content state manager for unified state handling.
+    /// This manages the content switching between video, avatar, reconnection, and screen share views.
+    private let contentState = PictureInPictureContentState()
+
     /// 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?
-    
+
+    /// Delegate proxy that publishes PiP lifecycle events via Combine.
+    private let delegateProxy = PictureInPictureDelegateProxy()
+
+    /// Adapter responsible for enforcing the stop of PiP when the app returns to foreground.
+    private var enforcedStopAdapter: PictureInPictureEnforcedStopAdapter?
+
     /// A `StreamPictureInPictureTrackStateAdapter` object that manages the state of the
     /// active track.
     private let trackStateAdapter: StreamPictureInPictureTrackStateAdapter = .init()
+
+    /// When true, multiple content fields are being updated as one transition.
+    private var isApplyingContentSnapshot = false
     
+    // MARK: - Content State Access
+
+    /// Returns the current content being displayed in the PiP window.
+    /// This is useful for debugging and logging purposes.
+    var currentContent: PictureInPictureContent {
+        contentState.content
+    }
+
     // MARK: - Lifecycle
-    
+
     /// Initializes the controller and creates the content view
     ///
     /// - Parameter canStartPictureInPictureAutomaticallyFromInline A boolean value
@@ -77,7 +172,7 @@ import Foundation
         guard AVPictureInPictureController.isPictureInPictureSupported() else {
             return nil
         }
-        
+
         let contentViewController: StreamAVPictureInPictureViewControlling? = {
             if #available(iOS 15.0, *) {
                 return StreamAVPictureInPictureVideoCallViewController()
@@ -85,60 +180,121 @@ import Foundation
                 return nil
             }
         }()
-        // contentViewController?.preferredContentSize = .init(width: 400, height: 320)
+        // Set a default preferred content size to avoid iOS PGPegasus code:-1003 error
+        // This will be updated later when track dimensions become available
+        contentViewController?.preferredContentSize = .init(width: 640, height: 480)
         self.contentViewController = contentViewController
         self.contentViewController?.isMirrored = isMirrored
         self.canStartPictureInPictureAutomaticallyFromInline = canStartPictureInPictureAutomaticallyFromInline
         super.init()
+
+        // Wire up the content state to the view controller for reactive updates (US-008)
+        // This enables the unified content view system where contentState changes
+        // automatically drive view switching in the renderer
+        contentViewController?.contentState = contentState
+        syncContentState()
+
+        // Subscribe to delegate proxy events for reactive PiP state handling
+        setupDelegateProxySubscriptions()
+
+        // Subscribe to content state changes for logging
+        setupContentStateSubscriptions()
     }
-    
-    func setPreferredContentSize(_ size: CGSize) {
-        contentViewController?.preferredContentSize = size
-    }
-    
-    // MARK: - AVPictureInPictureControllerDelegate
-    
-    func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
-    ) {
-        completionHandler(true)
-    }
-    
-    public func pictureInPictureControllerWillStartPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
-    ) {
-    }
-    
-    public func pictureInPictureControllerDidStartPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
-    ) {
-        onPiPStateChange?(true)
+
+    // MARK: - Private Setup
+
+    /// Sets up subscriptions to the delegate proxy's event publisher.
+    private func setupDelegateProxySubscriptions() {
+        delegateProxy.publisher
+            .sink { [weak self] event in
+                self?.handleDelegateEvent(event)
+            }
+            .store(in: &cancellableBag)
     }
-    
-    public func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        failedToStartPictureInPictureWithError error: Error
-    ) {
-        NSLog("PiP - failedToStartPictureInPictureWithError:\(error)")
+
+    /// Sets up subscriptions to content state changes for logging and debugging.
+    private func setupContentStateSubscriptions() {
+        contentState.contentPublisher
+            .removeDuplicates()
+            .sink { content in
+                PictureInPictureLogger.log("Content state changed to: \(content)")
+            }
+            .store(in: &cancellableBag)
     }
-    
-    public func pictureInPictureControllerWillStopPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
-    ) {
+
+    /// Handles events from the delegate proxy.
+    private func handleDelegateEvent(_ event: PictureInPictureDelegateProxy.Event) {
+        switch event {
+        case .didStart:
+            onPiPStateChange?(true)
+        case .didStop:
+            onPiPStateChange?(false)
+        case let .failedToStart(_, error):
+            PictureInPictureLogger.log("failedToStartPictureInPictureWithError: \(error.localizedDescription)")
+            // Notify JS that PiP failed to start so it can update its state accordingly
+            onPiPStateChange?(false)
+        case let .restoreUI(_, completionHandler):
+            completionHandler(true)
+        case .willStart, .willStop:
+            // No action needed for will start/stop events
+            break
+        }
     }
     
-    public func pictureInPictureControllerDidStopPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
-    ) {
-        onPiPStateChange?(false)
+    func setPreferredContentSize(_ size: CGSize) {
+        // Guard against setting zero size to avoid iOS PGPegasus code:-1003 error
+        guard size.width > 0, size.height > 0 else {
+            PictureInPictureLogger.log("Ignoring setPreferredContentSize with zero dimensions: \(size)")
+            return
+        }
+        contentViewController?.preferredContentSize = size
     }
-    
+
     // MARK: - Private helpers
-    
+
     private func didUpdate(_ track: RTCVideoTrack?) {
-        contentViewController?.track = track
         trackStateAdapter.activeTrack = track
+        syncContentStateIfNeeded()
+    }
+
+    private func syncContentStateIfNeeded() {
+        guard !isApplyingContentSnapshot else { return }
+        syncContentState()
+    }
+
+    private func syncContentState() {
+        let snapshot = PictureInPictureContentState.Snapshot(
+            track: track,
+            participantName: participantName,
+            participantImageURL: participantImageURL,
+            isVideoEnabled: isVideoEnabled,
+            isScreenSharing: isScreenSharing,
+            isReconnecting: isReconnecting
+        )
+        contentState.apply(snapshot)
+    }
+
+    /// Applies all content-driving fields as a single state transition.
+    func applyContentSnapshot(
+        track: RTCVideoTrack?,
+        participantName: String?,
+        participantImageURL: String?,
+        isVideoEnabled: Bool,
+        isScreenSharing: Bool,
+        isReconnecting: Bool
+    ) {
+        isApplyingContentSnapshot = true
+        defer {
+            isApplyingContentSnapshot = false
+            syncContentState()
+        }
+
+        self.track = track
+        self.participantName = participantName
+        self.participantImageURL = participantImageURL
+        self.isVideoEnabled = isVideoEnabled
+        self.isScreenSharing = isScreenSharing
+        self.isReconnecting = isReconnecting
     }
     
     @objc private func didUpdate(_ sourceView: UIView?) {
@@ -149,7 +305,7 @@ import Foundation
                 
                 pictureInPictureController?
                     .publisher(for: \.isPictureInPicturePossible)
-                    .sink { NSLog("PiP - isPictureInPicturePossible:\($0)") }
+                    .sink { PictureInPictureLogger.log("isPictureInPicturePossible:\($0)") }
                     .store(in: &cancellableBag)
                 
                 pictureInPictureController?
@@ -169,6 +325,19 @@ import Foundation
     }
     
     @objc func cleanup() {
+        // Cancel all Combine subscriptions
+        cancellableBag.removeAll()
+
+        // Reset the content state to inactive
+        contentState.reset()
+
+        // Disable the track state adapter to stop its timer
+        trackStateAdapter.isEnabled = false
+        trackStateAdapter.activeTrack = nil
+
+        // Release the enforced stop adapter
+        enforcedStopAdapter = nil
+
         sourceView = nil
         contentViewController?.track = nil
         contentViewController = nil
@@ -177,7 +346,6 @@ import Foundation
         }
         pictureInPictureController?.delegate = nil
         pictureInPictureController = nil
-        
     }
     
     private func makePictureInPictureController(with sourceView: UIView) {
@@ -190,13 +358,19 @@ import Foundation
                 )
             )
         }
-        
+
         if #available(iOS 14.2, *) {
             pictureInPictureController?
                 .canStartPictureInPictureAutomaticallyFromInline = canStartPictureInPictureAutomaticallyFromInline
         }
-        
-        pictureInPictureController?.delegate = self
+
+        // Use the delegate proxy for reactive event handling
+        pictureInPictureController?.delegate = delegateProxy
+
+        // Create the enforced stop adapter to handle app foreground transitions
+        if let pipController = pictureInPictureController {
+            enforcedStopAdapter = PictureInPictureEnforcedStopAdapter(pipController)
+        }
     }
     
     private func didUpdatePictureInPictureActiveState(_ isActive: Bool) {

package/ios/PictureInPicture/StreamPictureInPictureControllerProtocol.swift

@@ -0,0 +1,30 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import Combine
+import Foundation
+
+/// Protocol defining the interface for Picture-in-Picture controller functionality.
+///
+/// This abstraction allows for easier testing and decouples components from the
+/// concrete `AVPictureInPictureController` implementation.
+protocol StreamPictureInPictureControllerProtocol: AnyObject {
+    /// Publisher that emits whenever the Picture-in-Picture active state changes.
+    /// Consumers should rely on this stream instead of synchronous snapshots so
+    /// lifecycle adapters can react to state transitions deterministically.
+    var isPictureInPictureActivePublisher: AnyPublisher<Bool, Never> { get }
+
+    /// Stops the Picture-in-Picture playback if it is currently active.
+    func stopPictureInPicture()
+}
+
+/// Extends `AVPictureInPictureController` to conform to `StreamPictureInPictureControllerProtocol`.
+///
+/// This extension provides a Combine publisher for observing the `isPictureInPictureActive` property.
+extension AVPictureInPictureController: StreamPictureInPictureControllerProtocol {
+    var isPictureInPictureActivePublisher: AnyPublisher<Bool, Never> {
+        publisher(for: \.isPictureInPictureActive).eraseToAnyPublisher()
+    }
+}