@capgo/capacitor-video-player 8.2.4 → 8.2.7

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.4"
+    private let pluginVersion: String = "8.2.7"
     public let identifier = "VideoPlayerPlugin"
     public let jsName = "VideoPlayer"
     public let pluginMethods: [CAPPluginMethod] = [

package/ios/Tests/VideoPlayerPluginTests/HLSSubtitlePlaylistTests.swift

@@ -77,6 +77,16 @@ final class HLSSubtitlePlaylistTests: XCTestCase {
         XCTAssertEqual(result.asset.url.scheme, "file")
     }
 
+    func testIsHLSStreamDetectsMpegurlQuery() {
+        let url = URL(string: "https://cdn.example.com/video?format=mpegurl")!
+        XCTAssertTrue(HLSVideoAssetFactory.isHLSStream(url))
+    }
+
+    func testIsHLSStreamRejectsProgressiveMp4() {
+        let url = URL(string: "https://cdn.example.com/video.mp4")!
+        XCTAssertFalse(HLSVideoAssetFactory.isHLSStream(url))
+    }
+
     func testMakeAssetUsesResourceLoaderForLocalHLSSubtitles() {
         let videoURL = URL(fileURLWithPath: "/var/mobile/Containers/Data/Application/stream.m3u8")
         let tracks = [

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.4",
+  "version": "8.2.7",
   "description": "Capacitor plugin to play video in native player",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",