@capgo/capacitor-video-player 8.2.5 → 8.2.8

package/android/src/main/java/com/capgo/videoplayer/VideoPlayerPlugin.java

@@ -46,7 +46,7 @@ import org.json.JSONObject;
 )
 public class VideoPlayerPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.5";
+    private final String pluginVersion = "8.2.8";
 
     // Permission alias constants
     private static final String PERMISSION_DENIED_ERROR = "Unable to access media videos, user denied permission request";

package/ios/Sources/VideoPlayerPlugin/AVPlayerControlsVisibilityObserver.swift

@@ -0,0 +1,227 @@
+import AVKit
+import UIKit
+
+/// Mirrors AVKit playback-control visibility for custom overlay views.
+///
+/// AVPlayerViewController does not expose control visibility publicly. This observer
+/// locates the controls container using only the public view hierarchy and watches
+/// `hidden` / `alpha` so overlay controls can follow native chrome.
+final class AVPlayerControlsVisibilityObserver: NSObject {
+    private weak var playerViewController: AVPlayerViewController?
+    private weak var monitoredView: UIView?
+    private var onVisibilityChange: ((Bool) -> Void)?
+    private var retryWorkItem: DispatchWorkItem?
+    private var reanchorWorkItem: DispatchWorkItem?
+    private var hiddenObservation: NSKeyValueObservation?
+    private var alphaObservation: NSKeyValueObservation?
+    private var lastReportedVisible: Bool?
+    private var remainingInstallAttempts = 30
+    private var isActive = false
+
+    private static let reanchorInterval: TimeInterval = 0.25
+
+    deinit {
+        stop()
+    }
+
+    func start(
+        observing playerViewController: AVPlayerViewController,
+        onChange: @escaping (Bool) -> Void
+    ) {
+        stop()
+        isActive = true
+        self.playerViewController = playerViewController
+        self.onVisibilityChange = onChange
+        remainingInstallAttempts = 30
+        installObserverIfPossible()
+        scheduleReanchorCheck()
+    }
+
+    func stop() {
+        isActive = false
+        retryWorkItem?.cancel()
+        retryWorkItem = nil
+        reanchorWorkItem?.cancel()
+        reanchorWorkItem = nil
+        removeMonitoredViewObserver()
+        playerViewController = nil
+        onVisibilityChange = nil
+        lastReportedVisible = nil
+    }
+
+    static func controlsContainer(in playerView: UIView) -> UIView? {
+        guard let container = playerView.subviews.first else {
+            return nil
+        }
+        return container.subviews.last
+    }
+
+    static func areControlsVisible(in controlsView: UIView?) -> Bool {
+        guard let controlsView else {
+            return true
+        }
+        return !controlsView.isHidden && controlsView.alpha > 0.05
+    }
+
+    static func shouldReanchor(
+        monitoredView: UIView?,
+        currentControlsView: UIView?
+    ) -> Bool {
+        guard let monitoredView else {
+            return currentControlsView != nil
+        }
+        guard let currentControlsView else {
+            return true
+        }
+        if monitoredView !== currentControlsView {
+            return true
+        }
+        return monitoredView.superview == nil && monitoredView.window == nil
+    }
+
+    private func installObserverIfPossible() {
+        guard isActive else {
+            return
+        }
+
+        guard let playerView = playerViewController?.view else {
+            scheduleRetry()
+            return
+        }
+
+        guard let controlsView = Self.controlsContainer(in: playerView) else {
+            scheduleRetry()
+            return
+        }
+
+        if monitoredView === controlsView {
+            reportVisibilityIfNeeded(for: controlsView)
+            return
+        }
+
+        removeMonitoredViewObserver()
+        attachObserver(to: controlsView)
+    }
+
+    private func attachObserver(to controlsView: UIView) {
+        monitoredView = controlsView
+        hiddenObservation = controlsView.observe(\.isHidden, options: [.new]) { [weak self] view, _ in
+            self?.reportVisibilityIfNeeded(for: view)
+        }
+        alphaObservation = controlsView.observe(\.alpha, options: [.new]) { [weak self] view, _ in
+            self?.reportVisibilityIfNeeded(for: view)
+        }
+        reportVisibilityIfNeeded(for: controlsView)
+    }
+
+    private func reanchorIfNeeded() {
+        guard isActive else {
+            return
+        }
+
+        guard let playerView = playerViewController?.view else {
+            if monitoredView != nil {
+                removeMonitoredViewObserver()
+            }
+            scheduleRetry()
+            return
+        }
+
+        let currentControlsView = Self.controlsContainer(in: playerView)
+        guard Self.shouldReanchor(
+            monitoredView: monitoredView,
+            currentControlsView: currentControlsView
+        ) else {
+            if let monitoredView {
+                reportVisibilityIfNeeded(for: monitoredView)
+            }
+            return
+        }
+
+        removeMonitoredViewObserver()
+        if let currentControlsView {
+            remainingInstallAttempts = 30
+            attachObserver(to: currentControlsView)
+        } else {
+            scheduleRetry()
+        }
+    }
+
+    private func scheduleReanchorCheck() {
+        reanchorWorkItem?.cancel()
+        guard isActive else {
+            return
+        }
+
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self, self.isActive else {
+                return
+            }
+            self.reanchorIfNeeded()
+            self.scheduleReanchorCheck()
+        }
+        reanchorWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.reanchorInterval, execute: workItem)
+    }
+
+    private func scheduleRetry() {
+        guard isActive else {
+            return
+        }
+
+        retryWorkItem?.cancel()
+        guard remainingInstallAttempts > 0 else {
+            lastReportedVisible = true
+            onVisibilityChange?(true)
+            return
+        }
+        remainingInstallAttempts -= 1
+
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self, self.isActive else {
+                return
+            }
+            self.installObserverIfPossible()
+        }
+        retryWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: workItem)
+    }
+
+    private func removeMonitoredViewObserver() {
+        hiddenObservation = nil
+        alphaObservation = nil
+        monitoredView = nil
+    }
+
+    private func reportVisibilityIfNeeded(for controlsView: UIView) {
+        let visible = Self.areControlsVisible(in: controlsView)
+        guard lastReportedVisible != visible else {
+            return
+        }
+        lastReportedVisible = visible
+        onVisibilityChange?(visible)
+    }
+}
+
+enum VideoPlayerCastSeekSync {
+    static let minimumForwardDelta: Double = 0.25
+
+    static func shouldForwardLocalSeek(
+        localTime: Double,
+        lastForwardedTime: Double?
+    ) -> Bool {
+        guard localTime.isFinite else {
+            return false
+        }
+        guard let lastForwardedTime else {
+            return false
+        }
+        return abs(localTime - lastForwardedTime) >= minimumForwardDelta
+    }
+}
+
+enum VideoPlayerCastOverlayLayout {
+    static func overlayView(for playerViewController: AVPlayerViewController) -> UIView? {
+        playerViewController.contentOverlayView
+    }
+}

package/ios/Sources/VideoPlayerPlugin/DismissObservingPlayerViewController.swift

@@ -0,0 +1,43 @@
+import AVKit
+import UIKit
+
+final class DismissObservingPlayerViewController: AVPlayerViewController {
+    var onDismiss: (() -> Void)?
+    var shouldReportDismiss: (() -> Bool)?
+    weak var adaptivePresentationDelegate: UIAdaptivePresentationControllerDelegate?
+    private var wasVisibleInHierarchy = false
+
+    override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+        presentationController?.delegate = adaptivePresentationDelegate
+    }
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        wasVisibleInHierarchy = true
+    }
+
+    override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        reportDismissIfNeeded()
+    }
+
+    override func dismiss(animated: Bool, completion: (() -> Void)? = nil) {
+        super.dismiss(animated: animated) { [weak self] in
+            self?.reportDismissIfNeeded()
+            completion?()
+        }
+    }
+
+    private func reportDismissIfNeeded() {
+        guard wasVisibleInHierarchy else { return }
+        guard PlayerDismissExitDetection.shouldReportExit(
+            presentingViewController: presentingViewController,
+            viewWindow: view.window
+        ) else {
+            return
+        }
+        guard shouldReportDismiss?() ?? true else { return }
+        onDismiss?()
+    }
+}

package/ios/Sources/VideoPlayerPlugin/ExitEmissionGuard.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+struct ExitEmissionGuard {
+    private(set) var didEmit = false
+
+    mutating func emitIfNeeded(_ action: () -> Void) {
+        guard !didEmit else { return }
+        didEmit = true
+        action()
+    }
+}

package/ios/Sources/VideoPlayerPlugin/FullscreenVideoPlayer.swift

@@ -23,7 +23,9 @@ class FullscreenVideoPlayer: NSObject {
     private var audioCategory: String?
     private var didActivateAudioSession: Bool = false
     private var didEmitReady: Bool = false
-    private var didEmitExit: Bool = false
+    private var exitEmission = ExitEmissionGuard()
+    private var isTransitioningToPictureInPicture = false
+    private var suppressDismissExit = false
     private var timeObserver: Any?
     private var onPlay: (() -> Void)?
     private var onPause: (() -> Void)?
@@ -215,11 +217,20 @@ class FullscreenVideoPlayer: NSObject {
         player = AVPlayer(playerItem: playerItem)
         player?.rate = rate
 
-        playerViewController = AVPlayerViewController()
-        playerViewController?.player = player
-        playerViewController?.showsPlaybackControls = showControls
-        playerViewController?.allowsPictureInPicturePlayback = pipEnabled
-        playerViewController?.delegate = self
+        let playerVC = DismissObservingPlayerViewController()
+        playerVC.player = player
+        playerVC.showsPlaybackControls = showControls
+        playerVC.allowsPictureInPicturePlayback = pipEnabled
+        playerVC.delegate = self
+        playerVC.shouldReportDismiss = { [weak self] in
+            guard let self else { return true }
+            return !self.isTransitioningToPictureInPicture && !self.suppressDismissExit
+        }
+        playerVC.onDismiss = { [weak self] in
+            self?.emitExitIfNeeded()
+        }
+        playerVC.adaptivePresentationDelegate = self
+        playerViewController = playerVC
 
         setupChromecast()
         setupObservers()
@@ -694,11 +705,12 @@ class FullscreenVideoPlayer: NSObject {
 
         presentingViewController = viewController
         viewController.present(playerVC, animated: true) {
-            playerVC.presentationController?.delegate = self
             self.refreshSubtitleButton()
+            self.castController?.installOverlayIfNeeded()
             self.play()
             completion()
         }
+        configurePresentationDelegate(for: playerVC)
     }
 
     func show(on viewController: UIViewController, completion: @escaping () -> Void) {
@@ -712,9 +724,9 @@ class FullscreenVideoPlayer: NSObject {
         }
         presentingViewController = viewController
         viewController.present(playerVC, animated: true) {
-            playerVC.presentationController?.delegate = self
             completion()
         }
+        configurePresentationDelegate(for: playerVC)
     }
 
     func hide(completion: @escaping () -> Void) {
@@ -726,7 +738,9 @@ class FullscreenVideoPlayer: NSObject {
             completion()
             return
         }
-        playerVC.dismiss(animated: true) {
+        suppressDismissExit = true
+        playerVC.dismiss(animated: true) { [weak self] in
+            self?.suppressDismissExit = false
             completion()
         }
     }
@@ -807,13 +821,16 @@ class FullscreenVideoPlayer: NSObject {
         }
     }
 
-    private func emitExitIfNeeded(currentTime: Double? = nil) {
-        guard !didEmitExit else { return }
-        didEmitExit = true
+    private func configurePresentationDelegate(for playerVC: UIViewController) {
+        playerVC.presentationController?.delegate = self
+    }
 
-        let time = currentTime ?? getCurrentTime()
-        cleanup(stopRemoteMedia: true)
-        onExit?(time)
+    private func emitExitIfNeeded(currentTime: Double? = nil) {
+        exitEmission.emitIfNeeded {
+            let time = currentTime ?? getCurrentTime()
+            cleanup(stopRemoteMedia: true)
+            onExit?(time)
+        }
     }
 
     private func emitReadyIfNeeded() {
@@ -968,6 +985,14 @@ extension FullscreenVideoPlayer: AVPlayerViewControllerDelegate {
         emitExitIfNeeded()
     }
 
+    func playerViewControllerWillStartPictureInPicture(_ playerViewController: AVPlayerViewController) {
+        isTransitioningToPictureInPicture = true
+    }
+
+    func playerViewControllerDidStopPictureInPicture(_ playerViewController: AVPlayerViewController) {
+        isTransitioningToPictureInPicture = false
+    }
+
     func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(
         _ playerViewController: AVPlayerViewController
     ) -> Bool {

package/ios/Sources/VideoPlayerPlugin/PlayerDismissExitDetection.swift

@@ -0,0 +1,16 @@
+import UIKit
+
+enum PlayerDismissExitDetection {
+    /// Returns true when a player view controller has left the visible hierarchy
+    /// because it was dismissed, not merely covered by another view controller.
+    static func shouldReportExit(
+        presentingViewController: UIViewController?,
+        viewWindow: UIWindow?
+    ) -> Bool {
+        // iOS 18+/26: AVKit Done/X can dismiss a modal AVPlayerViewController without
+        // setting isBeingDismissed or calling presentationControllerDidDismiss.
+        // Require both presenter and window to be nil so parent dismissals that only
+        // transiently set isBeingDismissed/isMovingFromParent do not emit exit.
+        presentingViewController == nil && viewWindow == nil
+    }
+}