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

package/ios/PictureInPicture/PictureInPictureContentState.swift

@@ -0,0 +1,123 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+// Adapted from stream-video-swift PictureInPictureStore for React Native SDK
+// The React Native SDK receives state from the JavaScript bridge rather than
+// observing call state internally, so this is a simplified state container.
+//
+
+import Combine
+import Foundation
+
+/// Manages the content state for the Picture-in-Picture window.
+///
+/// This class provides centralized state management for the PiP content view system.
+/// Unlike the upstream `PictureInPictureStore` which uses a Flux-like action/dispatch pattern,
+/// this implementation is optimized for the React Native bridge where state updates come
+/// from the JavaScript layer.
+///
+/// State changes are published via Combine to allow reactive updates in the view layer.
+///
+/// Concurrency model:
+/// - This state container is main-thread confined.
+/// - `RTCVideoTrack` references are never sent across queues.
+final class PictureInPictureContentState {
+
+    /// A full state snapshot that can be applied atomically.
+    struct Snapshot {
+        var track: RTCVideoTrack?
+        var participantName: String?
+        var participantImageURL: String?
+        var isVideoEnabled: Bool
+        var isScreenSharing: Bool
+        var isReconnecting: Bool
+    }
+
+    // MARK: - Published State
+
+    /// The current content being displayed in the PiP window.
+    @Published private(set) var content: PictureInPictureContent = .inactive
+
+    /// Publisher for observing content changes.
+    var contentPublisher: AnyPublisher<PictureInPictureContent, Never> {
+        $content.eraseToAnyPublisher()
+    }
+
+    // MARK: - Private
+
+    private var snapshot: Snapshot = makeDefaultSnapshot()
+
+    // MARK: - Initialization
+
+    init() {}
+
+    // MARK: - State Update
+
+    /// Applies all content inputs in one step to avoid parallel update paths.
+    func apply(_ snapshot: Snapshot) {
+        ensureMainThread()
+        self.snapshot = snapshot
+        publishIfNeeded(for: snapshot)
+    }
+
+    /// Resets all state to defaults.
+    /// Called when cleaning up after a call ends.
+    func reset() {
+        ensureMainThread()
+        snapshot = Self.makeDefaultSnapshot()
+        if content != .inactive {
+            content = .inactive
+        }
+    }
+
+    /// Computes and publishes content based on the latest snapshot.
+    private func publishIfNeeded(for snapshot: Snapshot) {
+        let newContent: PictureInPictureContent
+
+        // Priority order: reconnecting > screen sharing > avatar (video disabled) > video > avatar fallback
+        if snapshot.isReconnecting {
+            newContent = .reconnecting
+        } else if snapshot.isScreenSharing {
+            newContent = .screenSharing(
+                track: snapshot.track,
+                participantName: snapshot.participantName
+            )
+        } else if !snapshot.isVideoEnabled {
+            newContent = .avatar(
+                participantName: snapshot.participantName,
+                participantImageURL: snapshot.participantImageURL
+            )
+        } else if snapshot.isVideoEnabled, snapshot.track != nil {
+            newContent = .video(
+                track: snapshot.track,
+                participantName: snapshot.participantName,
+                participantImageURL: snapshot.participantImageURL
+            )
+        } else {
+            newContent = .avatar(
+                participantName: snapshot.participantName,
+                participantImageURL: snapshot.participantImageURL
+            )
+        }
+
+        if content != newContent {
+            content = newContent
+        }
+    }
+
+    /// PiP content state is expected to be mutated on the main thread only.
+    private func ensureMainThread() {
+        dispatchPrecondition(condition: .onQueue(.main))
+    }
+
+    private static func makeDefaultSnapshot() -> Snapshot {
+        Snapshot(
+            track: nil,
+            participantName: nil,
+            participantImageURL: nil,
+            isVideoEnabled: true,
+            isScreenSharing: false,
+            isReconnecting: false
+        )
+    }
+}

package/ios/PictureInPicture/PictureInPictureDelegateProxy.swift

@@ -0,0 +1,89 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import Combine
+
+/// A wrapper around AVPictureInPictureControllerDelegate that publishes all
+/// delegate method calls via a single Combine publisher.
+///
+/// This proxy enables reactive handling of PiP lifecycle events and allows
+/// multiple subscribers to observe PiP state changes through a unified interface.
+final class PictureInPictureDelegateProxy: NSObject, AVPictureInPictureControllerDelegate {
+
+    /// Enum representing each AVPictureInPictureControllerDelegate method call
+    /// with its respective associated values.
+    enum Event: CustomStringConvertible {
+        case willStart(AVPictureInPictureController)
+        case didStart(AVPictureInPictureController)
+        case failedToStart(AVPictureInPictureController, Error)
+        case willStop(AVPictureInPictureController)
+        case didStop(AVPictureInPictureController)
+        case restoreUI(AVPictureInPictureController, (Bool) -> Void)
+
+        var description: String {
+            switch self {
+            case .willStart:
+                return ".willStart"
+            case .didStart:
+                return ".didStart"
+            case let .failedToStart(_, error):
+                return ".failedToStart(error: \(error.localizedDescription))"
+            case .willStop:
+                return ".willStop"
+            case .didStop:
+                return ".didStop"
+            case .restoreUI:
+                return ".restoreUI"
+            }
+        }
+    }
+
+    /// The Combine publisher that emits Picture-in-Picture delegate events.
+    var publisher: AnyPublisher<Event, Never> {
+        eventSubject.eraseToAnyPublisher()
+    }
+
+    private let eventSubject = PassthroughSubject<Event, Never>()
+
+    // MARK: - AVPictureInPictureControllerDelegate
+
+    func pictureInPictureControllerWillStartPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+        eventSubject.send(.willStart(pictureInPictureController))
+    }
+
+    func pictureInPictureControllerDidStartPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+        eventSubject.send(.didStart(pictureInPictureController))
+    }
+
+    func pictureInPictureController(
+        _ pictureInPictureController: AVPictureInPictureController,
+        failedToStartPictureInPictureWithError error: Error
+    ) {
+        eventSubject.send(.failedToStart(pictureInPictureController, error))
+    }
+
+    func pictureInPictureControllerWillStopPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+        eventSubject.send(.willStop(pictureInPictureController))
+    }
+
+    func pictureInPictureControllerDidStopPictureInPicture(
+        _ pictureInPictureController: AVPictureInPictureController
+    ) {
+        eventSubject.send(.didStop(pictureInPictureController))
+    }
+
+    func pictureInPictureController(
+        _ pictureInPictureController: AVPictureInPictureController,
+        restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
+    ) {
+        eventSubject.send(.restoreUI(pictureInPictureController, completionHandler))
+    }
+}

package/ios/PictureInPicture/PictureInPictureEnforcedStopAdapter.swift

@@ -0,0 +1,166 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import AVKit
+import Combine
+import UIKit
+
+/// An adapter responsible for enforcing the stop of Picture-in-Picture
+/// playback when the application returns to the foreground.
+///
+/// This adapter listens to application state changes and PiP activity to ensure
+/// PiP is stopped when the app becomes active (foreground). This behavior matches
+/// iOS user expectations where PiP should dismiss when returning to the app.
+final class PictureInPictureEnforcedStopAdapter {
+
+    private enum DisposableKey: String {
+        case stopEnforceOperation
+    }
+
+    private enum ApplicationState: Equatable {
+        case foreground
+        case background
+        case unknown
+    }
+
+    /// Refresh-rate-based timer interval used for enforcement attempts.
+    private let refreshRate: TimeInterval
+
+    /// Lifecycle subscriptions.
+    private var cancellables: Set<AnyCancellable> = []
+
+    /// Keyed operations that can be replaced/cancelled independently.
+    private var operationCancellables: [String: AnyCancellable] = [:]
+
+    /// Initializes the adapter with a Picture-in-Picture controller and
+    /// starts observing application state and PiP activity to enforce stop.
+    ///
+    /// - Parameter pictureInPictureController: The PiP controller to manage.
+    init(_ pictureInPictureController: StreamPictureInPictureControllerProtocol) {
+        refreshRate = Self.makeRefreshRate()
+
+        // Keep enforcement strictly state-driven: we only run the stop loop
+        // while the app is foregrounded *and* PiP is still active.
+        Publishers
+            .CombineLatest(
+                Self.makeApplicationStatePublisher(),
+                pictureInPictureController
+                    .isPictureInPictureActivePublisher
+                    .removeDuplicates()
+            )
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self, weak pictureInPictureController] applicationState, isActive in
+                self?.didUpdate(
+                    applicationState: applicationState,
+                    isPictureInPictureActive: isActive,
+                    pictureInPictureController: pictureInPictureController
+                )
+            }
+            .store(in: &cancellables)
+    }
+
+    deinit {
+        cancellables.removeAll()
+        removeAllOperations()
+    }
+
+    // MARK: - Private helpers
+
+    private func didUpdate(
+        applicationState: ApplicationState,
+        isPictureInPictureActive: Bool,
+        pictureInPictureController: StreamPictureInPictureControllerProtocol?
+    ) {
+        switch (applicationState, isPictureInPictureActive) {
+        case (.foreground, true):
+            // Foreground + active PiP is the only state where we enforce stop.
+            startStopEnforcement(for: pictureInPictureController)
+        default:
+            // Any other state (background/inactive PiP) should tear down the loop.
+            removeOperation(for: DisposableKey.stopEnforceOperation.rawValue)
+        }
+    }
+
+    private func startStopEnforcement(
+        for pictureInPictureController: StreamPictureInPictureControllerProtocol?
+    ) {
+        guard let pictureInPictureController else {
+            removeOperation(for: DisposableKey.stopEnforceOperation.rawValue)
+            return
+        }
+
+        let operation = Timer
+            .publish(every: refreshRate, on: .main, in: .common)
+            .autoconnect()
+            .filter { _ in
+                UIApplication.shared.applicationState == .active
+            }
+            .sink { [weak pictureInPictureController] _ in
+                // Calling stop repeatedly at display cadence covers cases where
+                // AVKit does not settle PiP shutdown on the first attempt.
+                pictureInPictureController?.stopPictureInPicture()
+            }
+
+        store(operation, key: DisposableKey.stopEnforceOperation.rawValue)
+    }
+
+    private func store(_ operation: AnyCancellable, key: String) {
+        // Keyed replacement ensures exactly one enforcement loop is active.
+        removeOperation(for: key)
+        operationCancellables[key] = operation
+    }
+
+    private func removeOperation(for key: String) {
+        operationCancellables[key]?.cancel()
+        operationCancellables[key] = nil
+    }
+
+    private func removeAllOperations() {
+        operationCancellables.values.forEach { $0.cancel() }
+        operationCancellables.removeAll()
+    }
+
+    private static func makeApplicationStatePublisher(
+        notificationCenter: NotificationCenter = .default
+    ) -> AnyPublisher<ApplicationState, Never> {
+        let foreground = Publishers.Merge(
+            notificationCenter
+                .publisher(for: UIApplication.willEnterForegroundNotification)
+                .map { _ in ApplicationState.foreground },
+            notificationCenter
+                .publisher(for: UIApplication.didBecomeActiveNotification)
+                .map { _ in ApplicationState.foreground }
+        )
+        let background = notificationCenter
+            .publisher(for: UIApplication.didEnterBackgroundNotification)
+            .map { _ in ApplicationState.background }
+
+        return Publishers.Merge(foreground, background)
+            // Emit the current app state immediately so newly created adapters
+            // do not wait for the next lifecycle notification.
+            .prepend(currentApplicationState())
+            .removeDuplicates()
+            .eraseToAnyPublisher()
+    }
+
+    private static func currentApplicationState() -> ApplicationState {
+        switch UIApplication.shared.applicationState {
+        case .active:
+            return .foreground
+        case .background:
+            return .background
+        case .inactive:
+            return .unknown
+        @unknown default:
+            return .unknown
+        }
+    }
+
+    private static func makeRefreshRate() -> TimeInterval {
+        // Keep cadence aligned to the device's display refresh rate while
+        // enforcing a practical minimum (30fps) for older/limited devices.
+        let maximumFramesPerSecond = max(30, UIScreen.main.maximumFramesPerSecond)
+        return 1.0 / Double(maximumFramesPerSecond)
+    }
+}

package/ios/PictureInPicture/PictureInPictureLogger.swift

@@ -0,0 +1,16 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+/// Centralized logger for Picture in Picture diagnostics.
+///
+/// Logging is debug-only to avoid production noise and overhead.
+enum PictureInPictureLogger {
+    static func log(_ message: @autoclosure () -> String) {
+        #if DEBUG
+        NSLog("PiP - %@", message())
+        #endif
+    }
+}

package/ios/PictureInPicture/PictureInPictureParticipantOverlayView.swift

@@ -0,0 +1,217 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import UIKit
+
+/// A view that displays participant information overlay in Picture-in-Picture mode.
+/// Shows participant name, pin indicator, sound indicator, and video paused indicator
+/// at the bottom-left of the PiP window.
+/// This aligns with upstream stream-video-swift ParticipantInfoView.
+final class PictureInPictureParticipantOverlayView: UIView {
+
+    // MARK: - Properties
+
+    /// The participant's name to display
+    var participantName: String? {
+        didSet {
+            nameLabel.text = participantName
+            updateVisibility()
+        }
+    }
+
+    /// Whether the participant is pinned
+    var isPinned: Bool = false {
+        didSet {
+            pinIconView.isHidden = !isPinned
+        }
+    }
+
+    /// Whether the participant has audio enabled (not muted)
+    var hasAudio: Bool = true {
+        didSet {
+            updateSoundIndicator()
+        }
+    }
+
+    /// Whether the video track is paused/disabled
+    var isTrackPaused: Bool = false {
+        didSet {
+            updateVideoPausedIndicator()
+        }
+    }
+
+    /// Controls whether the overlay is shown
+    var isOverlayEnabled: Bool = true {
+        didSet {
+            updateVisibility()
+        }
+    }
+
+    // MARK: - UI Components
+
+    /// Container for the bottom info bar with gradient background
+    private lazy var containerView: UIView = {
+        let view = UIView()
+        view.translatesAutoresizingMaskIntoConstraints = false
+        return view
+    }()
+
+    /// Gradient layer for the bottom fade effect
+    private lazy var gradientLayer: CAGradientLayer = {
+        let layer = CAGradientLayer()
+        layer.colors = [
+            UIColor.clear.cgColor,
+            UIColor.black.withAlphaComponent(0.6).cgColor
+        ]
+        layer.locations = [0.0, 1.0]
+        return layer
+    }()
+
+    /// Container for the content (name + indicators)
+    private lazy var contentStackView: UIStackView = {
+        let stack = UIStackView()
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        stack.axis = .horizontal
+        stack.spacing = 4
+        stack.alignment = .center
+        return stack
+    }()
+
+    /// Pin indicator icon (shown when participant is pinned)
+    private lazy var pinIconView: UIImageView = {
+        let imageView = UIImageView()
+        imageView.translatesAutoresizingMaskIntoConstraints = false
+        imageView.contentMode = .scaleAspectFit
+        imageView.tintColor = .white
+
+        // Use SF Symbol for pin
+        let config = UIImage.SymbolConfiguration(pointSize: 10, weight: .medium)
+        imageView.image = UIImage(systemName: "pin.fill", withConfiguration: config)
+        imageView.isHidden = true // Hidden by default
+        imageView.setContentHuggingPriority(.required, for: .horizontal)
+        imageView.setContentCompressionResistancePriority(.required, for: .horizontal)
+        return imageView
+    }()
+
+    /// Label showing participant name
+    private lazy var nameLabel: UILabel = {
+        let label = UILabel()
+        label.translatesAutoresizingMaskIntoConstraints = false
+        label.font = .systemFont(ofSize: 11, weight: .medium)
+        label.textColor = .white
+        label.lineBreakMode = .byTruncatingTail
+        label.setContentHuggingPriority(.defaultLow, for: .horizontal)
+        label.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+        return label
+    }()
+
+    /// Video paused indicator icon (wifi.slash when track is paused)
+    private lazy var videoPausedIconView: UIImageView = {
+        let imageView = UIImageView()
+        imageView.translatesAutoresizingMaskIntoConstraints = false
+        imageView.contentMode = .scaleAspectFit
+        imageView.tintColor = .white
+
+        // Use SF Symbol for video paused (wifi.slash as in upstream)
+        let config = UIImage.SymbolConfiguration(pointSize: 10, weight: .medium)
+        imageView.image = UIImage(systemName: "wifi.slash", withConfiguration: config)
+        imageView.isHidden = true // Hidden by default
+        imageView.setContentHuggingPriority(.required, for: .horizontal)
+        imageView.setContentCompressionResistancePriority(.required, for: .horizontal)
+        return imageView
+    }()
+
+    /// Sound indicator icon (microphone on/off)
+    private lazy var soundIndicatorView: UIImageView = {
+        let imageView = UIImageView()
+        imageView.translatesAutoresizingMaskIntoConstraints = false
+        imageView.contentMode = .scaleAspectFit
+        imageView.tintColor = .white
+        imageView.setContentHuggingPriority(.required, for: .horizontal)
+        imageView.setContentCompressionResistancePriority(.required, for: .horizontal)
+        return imageView
+    }()
+
+    // MARK: - Initialization
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setUp()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        // Update gradient frame when view bounds change
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        gradientLayer.frame = containerView.bounds
+        CATransaction.commit()
+    }
+
+    // MARK: - Private Methods
+
+    private func setUp() {
+        isUserInteractionEnabled = false
+        isHidden = true // Hidden by default until participant info is set
+
+        addSubview(containerView)
+        containerView.layer.insertSublayer(gradientLayer, at: 0)
+        containerView.addSubview(contentStackView)
+
+        contentStackView.addArrangedSubview(pinIconView)
+        contentStackView.addArrangedSubview(nameLabel)
+        contentStackView.addArrangedSubview(videoPausedIconView)
+        contentStackView.addArrangedSubview(soundIndicatorView)
+
+        NSLayoutConstraint.activate([
+            // Container positioned at the bottom
+            containerView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            containerView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            containerView.bottomAnchor.constraint(equalTo: bottomAnchor),
+            containerView.heightAnchor.constraint(equalToConstant: 28),
+
+            // Content stack with padding
+            contentStackView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor, constant: 8),
+            contentStackView.trailingAnchor.constraint(lessThanOrEqualTo: containerView.trailingAnchor, constant: -8),
+            contentStackView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor, constant: -6),
+
+            // Icon sizes
+            pinIconView.widthAnchor.constraint(equalToConstant: 12),
+            pinIconView.heightAnchor.constraint(equalToConstant: 12),
+            videoPausedIconView.widthAnchor.constraint(equalToConstant: 12),
+            videoPausedIconView.heightAnchor.constraint(equalToConstant: 12),
+            soundIndicatorView.widthAnchor.constraint(equalToConstant: 12),
+            soundIndicatorView.heightAnchor.constraint(equalToConstant: 12)
+        ])
+
+        // Initialize indicators
+        updateSoundIndicator()
+        updateVideoPausedIndicator()
+    }
+
+    private func updateVisibility() {
+        // Show overlay only if enabled and we have a participant name
+        let hasName = participantName != nil && !(participantName?.isEmpty ?? true)
+        isHidden = !isOverlayEnabled || !hasName
+    }
+
+    private func updateSoundIndicator() {
+        let config = UIImage.SymbolConfiguration(pointSize: 10, weight: .medium)
+        if hasAudio {
+            soundIndicatorView.image = UIImage(systemName: "mic.fill", withConfiguration: config)
+            soundIndicatorView.tintColor = .white
+        } else {
+            soundIndicatorView.image = UIImage(systemName: "mic.slash.fill", withConfiguration: config)
+            soundIndicatorView.tintColor = UIColor(white: 0.7, alpha: 1.0) // Slightly dimmed when muted
+        }
+    }
+
+    private func updateVideoPausedIndicator() {
+        videoPausedIconView.isHidden = !isTrackPaused
+    }
+}