@capgo/capacitor-video-player 8.2.5 → 8.2.7

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.7";
 
     // 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,20 @@
+import AVKit
+import UIKit
+
+final class DismissObservingPlayerViewController: AVPlayerViewController {
+    var onDismiss: (() -> Void)?
+    var shouldReportDismiss: (() -> Bool)?
+    weak var adaptivePresentationDelegate: UIAdaptivePresentationControllerDelegate?
+
+    override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+        presentationController?.delegate = adaptivePresentationDelegate
+    }
+
+    override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        guard isBeingDismissed 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/VideoPlayerCastController.swift

@@ -38,9 +38,20 @@ final class VideoPlayerCastController: NSObject {
     private var onPlay: (() -> Void)?
     private var onPause: (() -> Void)?
     private var onEnd: (() -> Void)?
-    private var controlsHideTimer: Timer?
-    private weak var tapGestureRecognizer: UITapGestureRecognizer?
-    private static let overlayAutoHideDuration: TimeInterval = 3.0
+    private let controlsVisibilityObserver = AVPlayerControlsVisibilityObserver()
+    private var localSeekTimeObserver: Any?
+    private var timeJumpObserver: NSObjectProtocol?
+    private var observedPlayerForSeek: AVPlayer?
+    private var overlayInstallRetryWorkItem: DispatchWorkItem?
+    private var overlayInstallAttemptsRemaining = 0
+    private var lastForwardedSeekTime: Double?
+    private var arePlaybackControlsVisible = true
+
+    deinit {
+        overlayInstallRetryWorkItem?.cancel()
+        stopObservingLocalSeek()
+        controlsVisibilityObserver.stop()
+    }
 
     var isCasting: Bool {
         return remoteMediaClient != nil && isLoadedOnCast
@@ -73,9 +84,7 @@ final class VideoPlayerCastController: NSObject {
             }
 
             GCKCastContext.sharedInstance().sessionManager.add(self)
-            self.addCastButton(to: playerViewController)
-            self.addCastIndicator(to: playerViewController)
-            self.beginObservingPlayerTaps(playerViewController)
+            self.installOverlayIfNeeded()
             self.loadMediaIfCastSessionAvailable()
         }
 
@@ -86,6 +95,20 @@ final class VideoPlayerCastController: NSObject {
         }
     }
 
+    func installOverlayIfNeeded() {
+        overlayInstallAttemptsRemaining = 30
+        let installOnMain = { [weak self] in
+            guard let self else { return }
+            self.installOverlayIfNeededOnMain()
+        }
+
+        if Thread.isMainThread {
+            installOnMain()
+        } else {
+            DispatchQueue.main.async(execute: installOnMain)
+        }
+    }
+
     func detach(stopRemoteMedia: Bool) {
         guard !isDetached else {
             return
@@ -95,24 +118,21 @@ final class VideoPlayerCastController: NSObject {
         pendingCastCommands.removeAll()
 
         DispatchQueue.main.async { [weak self] in
-            guard let self = self,
-                  GCKCastContext.isSharedInstanceInitialized() else {
-                return
-            }
+            guard let self else { return }
 
-            if stopRemoteMedia {
-                self.remoteMediaClient?.stop()
+            if GCKCastContext.isSharedInstanceInitialized() {
+                if stopRemoteMedia {
+                    self.remoteMediaClient?.stop()
+                }
+                self.stopRemoteMediaObservation()
+                GCKCastContext.sharedInstance().sessionManager.remove(self)
+            } else {
+                self.stopRemoteMediaObservation()
             }
 
-            self.stopRemoteMediaObservation()
-            GCKCastContext.sharedInstance().sessionManager.remove(self)
-            self.controlsHideTimer?.invalidate()
-            self.controlsHideTimer = nil
-            if let tapRecognizer = self.tapGestureRecognizer,
-               let view = self.playerViewController?.view {
-                view.removeGestureRecognizer(tapRecognizer)
-            }
-            self.tapGestureRecognizer = nil
+            self.cancelOverlayInstallRetry()
+            self.stopObservingLocalSeek()
+            self.controlsVisibilityObserver.stop()
             self.castButton?.removeFromSuperview()
             self.castButton = nil
             self.castIndicatorLabel?.removeFromSuperview()
@@ -151,6 +171,7 @@ final class VideoPlayerCastController: NSObject {
             return false
         }
         guard isLoadedOnCast else {
+            syncLocalPlayhead(to: time)
             return enqueuePendingCastCommand(.seek(time))
         }
         let options = GCKMediaSeekOptions()
@@ -158,6 +179,7 @@ final class VideoPlayerCastController: NSObject {
         options.relative = false
         options.resumeState = .unchanged
         remoteMediaClient.seek(with: options)
+        syncLocalPlayhead(to: time)
         return true
     }
 
@@ -272,12 +294,63 @@ private extension VideoPlayerCastController {
         return GCKCastContext.setSharedInstanceWith(options, error: &error)
     }
 
-    func addCastButton(to playerViewController: AVPlayerViewController) {
-        guard castButton == nil else {
+    func installOverlayIfNeededOnMain() {
+        guard !isDetached,
+              castButton == nil,
+              let playerViewController = playerViewController else {
+            return
+        }
+
+        guard let overlayView = VideoPlayerCastOverlayLayout.overlayView(for: playerViewController) else {
+            scheduleOverlayInstallRetry()
             return
         }
 
-        guard let overlayView = playerViewController.view else {
+        cancelOverlayInstallRetry()
+        addCastButton(to: overlayView)
+        addCastIndicator(to: overlayView)
+        beginObservingControlsVisibility(playerViewController)
+        updateCastOverlayVisibility(visible: arePlaybackControlsVisible)
+    }
+
+    func scheduleOverlayInstallRetry() {
+        guard !isDetached, castButton == nil, overlayInstallAttemptsRemaining > 0 else {
+            return
+        }
+        overlayInstallAttemptsRemaining -= 1
+        overlayInstallRetryWorkItem?.cancel()
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self, !self.isDetached else { return }
+            self.installOverlayIfNeededOnMain()
+        }
+        overlayInstallRetryWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: workItem)
+    }
+
+    func cancelOverlayInstallRetry() {
+        overlayInstallRetryWorkItem?.cancel()
+        overlayInstallRetryWorkItem = nil
+        overlayInstallAttemptsRemaining = 0
+    }
+
+    func syncLocalPlayhead(to time: Double) {
+        let apply = { [weak self] in
+            self?.player?.seek(
+                to: CMTime(seconds: time, preferredTimescale: 600),
+                toleranceBefore: .zero,
+                toleranceAfter: .zero
+            )
+            self?.lastForwardedSeekTime = time
+        }
+        if Thread.isMainThread {
+            apply()
+        } else {
+            DispatchQueue.main.async(execute: apply)
+        }
+    }
+
+    func addCastButton(to overlayView: UIView) {
+        guard castButton == nil else {
             return
         }
 
@@ -303,15 +376,11 @@ private extension VideoPlayerCastController {
         castButton = button
     }
 
-    func addCastIndicator(to playerViewController: AVPlayerViewController) {
+    func addCastIndicator(to overlayView: UIView) {
         guard castIndicatorLabel == nil else {
             return
         }
 
-        guard let overlayView = playerViewController.view else {
-            return
-        }
-
         let label = UILabel(frame: .zero)
         label.translatesAutoresizingMaskIntoConstraints = false
         label.text = "Casting"
@@ -339,46 +408,90 @@ private extension VideoPlayerCastController {
         castIndicatorLabel = label
     }
 
-    func beginObservingPlayerTaps(_ playerViewController: AVPlayerViewController) {
-        guard let overlayView = playerViewController.view else { return }
-        // Remove any existing recognizer before adding a new one to prevent duplicates.
-        if let existing = tapGestureRecognizer {
-            overlayView.removeGestureRecognizer(existing)
+    func beginObservingControlsVisibility(_ playerViewController: AVPlayerViewController) {
+        controlsVisibilityObserver.start(observing: playerViewController) { [weak self] visible in
+            self?.arePlaybackControlsVisible = visible
+            self?.updateCastOverlayVisibility(visible: visible)
         }
-        let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(handlePlayerTap))
-        tapRecognizer.cancelsTouchesInView = false
-        overlayView.addGestureRecognizer(tapRecognizer)
-        self.tapGestureRecognizer = tapRecognizer
-        // Show the overlay immediately; it will auto-hide after the standard controls delay.
-        showOverlayControls()
     }
 
-    @objc func handlePlayerTap() {
-        showOverlayControls()
+    func updateCastOverlayVisibility(visible: Bool) {
+        castButton?.isHidden = !visible
+        castButton?.alpha = visible ? 1 : 0
+        castIndicatorLabel?.isHidden = !visible || !isCasting
+        castIndicatorLabel?.alpha = visible ? 1 : 0
     }
 
-    func showOverlayControls() {
-        castButton?.isHidden = false
-        castIndicatorLabel?.isHidden = !isCasting
-        controlsHideTimer?.invalidate()
-        controlsHideTimer = Timer.scheduledTimer(withTimeInterval: Self.overlayAutoHideDuration, repeats: false) { [weak self] _ in
-            self?.hideOverlayControls()
+    func beginObservingLocalSeekWhileCasting() {
+        stopObservingLocalSeek()
+        guard let player = player else {
+            return
+        }
+
+        observedPlayerForSeek = player
+        timeJumpObserver = NotificationCenter.default.addObserver(
+            forName: .AVPlayerItemTimeJumped,
+            object: nil,
+            queue: .main
+        ) { [weak self] notification in
+            guard let self,
+                  let item = notification.object as? AVPlayerItem,
+                  item === self.player?.currentItem else {
+                return
+            }
+            self.forwardLocalSeekToRemoteIfNeeded()
+        }
+
+        let interval = CMTime(seconds: 0.25, preferredTimescale: 600)
+        localSeekTimeObserver = player.addPeriodicTimeObserver(forInterval: interval, queue: .main) { [weak self] _ in
+            self?.forwardLocalSeekToRemoteIfNeeded()
         }
     }
 
-    func hideOverlayControls() {
-        controlsHideTimer = nil
-        let button = castButton
-        let label = castIndicatorLabel
-        UIView.animate(withDuration: 0.3, animations: {
-            button?.alpha = 0
-            label?.alpha = 0
-        }, completion: { _ in
-            button?.isHidden = true
-            label?.isHidden = true
-            button?.alpha = 1
-            label?.alpha = 1
-        })
+    func stopObservingLocalSeek() {
+        if let timeJumpObserver {
+            NotificationCenter.default.removeObserver(timeJumpObserver)
+            self.timeJumpObserver = nil
+        }
+        if let localSeekTimeObserver {
+            observedPlayerForSeek?.removeTimeObserver(localSeekTimeObserver)
+            self.localSeekTimeObserver = nil
+        }
+        observedPlayerForSeek = nil
+    }
+
+    func syncCastingObserversIfNeeded() {
+        guard isCasting else {
+            stopObservingLocalSeek()
+            return
+        }
+        if localSeekTimeObserver == nil {
+            beginObservingLocalSeekWhileCasting()
+        }
+    }
+
+    func forwardLocalSeekToRemoteIfNeeded() {
+        guard !isDetached,
+              isCasting,
+              let remoteMediaClient = remoteMediaClient,
+              let player = player else {
+            return
+        }
+
+        let localTime = player.currentTime().seconds
+        guard VideoPlayerCastSeekSync.shouldForwardLocalSeek(
+            localTime: localTime,
+            lastForwardedTime: lastForwardedSeekTime
+        ) else {
+            return
+        }
+
+        lastForwardedSeekTime = localTime
+        let options = GCKMediaSeekOptions()
+        options.interval = localTime
+        options.relative = false
+        options.resumeState = .unchanged
+        remoteMediaClient.seek(with: options)
     }
 
     func loadMediaIfCastSessionAvailable() {
@@ -401,6 +514,9 @@ private extension VideoPlayerCastController {
         mediaLoadRequestDataBuilder.mediaInformation = mediaInfo
         mediaLoadRequestDataBuilder.autoplay = NSNumber(value: localWasPlaying)
         mediaLoadRequestDataBuilder.startTime = playPosition.isFinite ? playPosition : 0
+        if playPosition.isFinite {
+            lastForwardedSeekTime = playPosition
+        }
         let request = remoteMediaClient.loadMedia(with: mediaLoadRequestDataBuilder.build())
         request.delegate = self
         mediaLoadRequest = request
@@ -419,6 +535,14 @@ private extension VideoPlayerCastController {
 
         observeRemoteMediaClient(remoteMediaClient)
         isLoadedOnCast = isCurrentVideo(remoteMediaClient.mediaStatus?.mediaInformation)
+        if isLoadedOnCast {
+            player?.pause()
+            let position = remoteMediaClient.approximateStreamPosition()
+            if position.isFinite {
+                syncLocalPlayhead(to: position)
+            }
+            syncCastingObserversIfNeeded()
+        }
         handleRemoteMediaStatus(remoteMediaClient.mediaStatus)
     }
 
@@ -477,6 +601,7 @@ private extension VideoPlayerCastController {
             options.relative = false
             options.resumeState = .unchanged
             remoteMediaClient.seek(with: options)
+            syncLocalPlayhead(to: time)
         case .volume(let volume):
             remoteMediaClient.setStreamVolume(volume)
         case .muted(let muted):
@@ -591,6 +716,9 @@ private extension VideoPlayerCastController {
         stopRemoteMediaObservation()
         clearMediaLoadRequest()
         pendingCastCommands.removeAll()
+        DispatchQueue.main.async { [weak self] in
+            self?.syncCastingObserversIfNeeded()
+        }
         let seekTime = CMTime(seconds: position, preferredTimescale: 600)
         player?.seek(to: seekTime) { [weak self] _ in
             if shouldResume {
@@ -613,8 +741,12 @@ private extension VideoPlayerCastController {
         isLoadedOnCast = true
         didNotifyRemoteEnd = false
         DispatchQueue.main.async { [weak self] in
-            // Reveal the cast indicator and extend the controls visibility window.
-            self?.showOverlayControls()
+            guard let self else { return }
+            if let position = self.player?.currentTime().seconds, position.isFinite {
+                self.lastForwardedSeekTime = position
+            }
+            self.syncCastingObserversIfNeeded()
+            self.updateCastOverlayVisibility(visible: self.arePlaybackControlsVisible)
         }
         flushPendingCastCommands()
     }
@@ -630,6 +762,9 @@ private extension VideoPlayerCastController {
         clearMediaLoadRequest()
         isLoadingOnCast = false
         isLoadedOnCast = false
+        DispatchQueue.main.async { [weak self] in
+            self?.syncCastingObserversIfNeeded()
+        }
         if !pendingCastCommands.isEmpty {
             let didApplyPlaybackCommand = applyPendingCastCommandsToLocalPlayer()
             if localWasPlaying && !didApplyPlaybackCommand {
@@ -755,6 +890,8 @@ final class VideoPlayerCastController {
         _ = player
     }
 
+    func installOverlayIfNeeded() {}
+
     func detach(stopRemoteMedia: Bool) {
         _ = stopRemoteMedia
     }

package/ios/Sources/VideoPlayerPlugin/VideoPlayerPlugin.swift

@@ -8,7 +8,7 @@ import AVKit
  */
 @objc(VideoPlayerPlugin)
 public class VideoPlayerPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.5"
+    private let pluginVersion: String = "8.2.7"
     public let identifier = "VideoPlayerPlugin"
     public let jsName = "VideoPlayer"
     public let pluginMethods: [CAPPluginMethod] = [

package/ios/Tests/VideoPlayerPluginTests/VideoPlayerCastControllerTests.swift

@@ -0,0 +1,103 @@
+import AVKit
+import XCTest
+@testable import VideoPlayerPlugin
+
+final class VideoPlayerCastControllerTests: XCTestCase {
+    func testCastOverlayTargetsContentOverlayView() {
+        let playerViewController = AVPlayerViewController()
+        playerViewController.loadViewIfNeeded()
+
+        let overlayView = VideoPlayerCastOverlayLayout.overlayView(for: playerViewController)
+
+        XCTAssertNotNil(overlayView)
+        XCTAssertIdentical(overlayView, playerViewController.contentOverlayView)
+    }
+
+    func testSeekSyncRequiresBaselineAndMeaningfulDelta() {
+        XCTAssertFalse(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: 42, lastForwardedTime: nil)
+        )
+        XCTAssertFalse(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: 10.1, lastForwardedTime: 10)
+        )
+        XCTAssertTrue(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: 10.5, lastForwardedTime: 10)
+        )
+        XCTAssertFalse(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: .nan, lastForwardedTime: 10)
+        )
+        XCTAssertFalse(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: .infinity, lastForwardedTime: 10)
+        )
+        XCTAssertTrue(
+            VideoPlayerCastSeekSync.shouldForwardLocalSeek(localTime: 10.25, lastForwardedTime: 10)
+        )
+    }
+
+    func testControlsVisibilityReflectsHiddenAndAlpha() {
+        let controlsView = UIView()
+        controlsView.isHidden = false
+        controlsView.alpha = 1
+
+        XCTAssertTrue(AVPlayerControlsVisibilityObserver.areControlsVisible(in: controlsView))
+
+        controlsView.isHidden = true
+        XCTAssertFalse(AVPlayerControlsVisibilityObserver.areControlsVisible(in: controlsView))
+
+        controlsView.isHidden = false
+        controlsView.alpha = 0
+        XCTAssertFalse(AVPlayerControlsVisibilityObserver.areControlsVisible(in: controlsView))
+    }
+
+    func testControlsContainerLocatorFindsLastSubviewInFirstContainer() {
+        let rootView = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 240))
+        let container = UIView(frame: rootView.bounds)
+        let contentView = UIView(frame: rootView.bounds)
+        let controlsView = UIView(frame: CGRect(x: 0, y: 180, width: 320, height: 60))
+
+        rootView.addSubview(container)
+        container.addSubview(contentView)
+        container.addSubview(controlsView)
+
+        XCTAssertIdentical(
+            AVPlayerControlsVisibilityObserver.controlsContainer(in: rootView),
+            controlsView
+        )
+    }
+
+    func testShouldReanchorWhenControlsViewChanges() {
+        let oldControls = UIView()
+        let newControls = UIView()
+
+        XCTAssertTrue(
+            AVPlayerControlsVisibilityObserver.shouldReanchor(
+                monitoredView: oldControls,
+                currentControlsView: newControls
+            )
+        )
+    }
+
+    func testShouldReanchorWhenMonitoredViewIsDetached() {
+        let detachedControls = UIView()
+
+        XCTAssertTrue(
+            AVPlayerControlsVisibilityObserver.shouldReanchor(
+                monitoredView: detachedControls,
+                currentControlsView: detachedControls
+            )
+        )
+    }
+
+    func testShouldNotReanchorWhenMonitoringCurrentControls() {
+        let container = UIView()
+        let controls = UIView()
+        container.addSubview(controls)
+
+        XCTAssertFalse(
+            AVPlayerControlsVisibilityObserver.shouldReanchor(
+                monitoredView: controls,
+                currentControlsView: controls
+            )
+        )
+    }
+}

package/ios/Tests/VideoPlayerPluginTests/VideoPlayerPluginTests.swift

@@ -25,9 +25,14 @@ class VideoPlayerTests: XCTestCase {
         XCTAssertEqual(tracks[1].language, "fr")
     }
 
-    func testSubtitleTrackResolvesBareFilePath() {
-        let track = VideoSubtitleTrack(url: "/var/mobile/Containers/Data/Application/subtitles-en.vtt", language: "en")
-        XCTAssertEqual(track.resolvedURL?.isFileURL, true)
-        XCTAssertEqual(track.resolvedURL?.path, "/var/mobile/Containers/Data/Application/subtitles-en.vtt")
+    func testExitEmissionGuardEmitsOnce() {
+        var guardState = ExitEmissionGuard()
+        var emitCount = 0
+
+        guardState.emitIfNeeded { emitCount += 1 }
+        guardState.emitIfNeeded { emitCount += 1 }
+
+        XCTAssertEqual(emitCount, 1)
+        XCTAssertTrue(guardState.didEmit)
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-video-player",
-  "version": "8.2.5",
+  "version": "8.2.7",
   "description": "Capacitor plugin to play video in native player",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",