update

Author: swiftuiux

Sources/swiftui-loop-videoplayer/protocol/player/AbstractPlayer.swift

@@ -135,6 +135,64 @@ extension AbstractPlayer{
     func pause() {
         player?.pause()
     }
+    
+    /// Clears all items from the player's queue.
+    func clearPlayerQueue() {
+        guard let items = player?.items() else { return }
+        for item in items {
+            player?.remove(item)
+        }
+    }
+    
+    /// Updates the current playback asset, settings, and initializes playback or a specific action when the asset is ready.
+    ///
+    /// This method sets a new asset to be played, optionally loops it, and can automatically start playback.
+    /// If provided, a callback is executed when the asset is ready to play.
+    ///
+    /// - Parameters:
+    ///   - asset: The AVURLAsset to be loaded into the player.
+    ///   - loop: A Boolean value indicating whether the video should loop.
+    ///   - autoPlay: A Boolean value indicating whether playback should start automatically. Default is true.
+    ///   - callback: An optional closure to be called when the asset is ready to play.
+    func update(asset: AVURLAsset, loop: Bool, autoPlay: Bool = true,  callback: (() -> Void)? = nil) {
+
+        guard let player = player else { return }
+
+        let wasPlaying = player.rate != 0
+
+        if wasPlaying {
+            pause()
+        }
+
+        if !player.items().isEmpty {
+            // Cleaning
+            unloop()
+            clearPlayerQueue()
+            removeAllFilters()
+        }
+
+        let newItem = AVPlayerItem(asset: asset)
+        player.insert(newItem, after: nil)
+
+        if loop {
+            self.loop()
+        }
+
+        if let callback{
+            var token: NSKeyValueObservation?
+            token = newItem.observe(\.status, options: [.new, .old]) { item, change in
+                if item.status == .readyToPlay {
+                    callback()
+                    token?.invalidate() // Invalidate token to stop observing
+                    token = nil
+                }
+            }
+        }
+      
+        if autoPlay{
+            player.play()
+        }
+    }
 
     /// Seeks the video to a specific time.
     /// This method moves the playback position to the specified time with precise accuracy.
@@ -146,6 +204,18 @@ extension AbstractPlayer{
             return
         }
 
+        guard player.currentItem?.status == .readyToPlay else{
+            if let asset = currentAsset{
+                update(asset: asset , loop: false, autoPlay: false){[weak self] in
+                    self?.seek(to: time)
+                }
+                return
+            }
+            
+            delegate?.didSeek(value: false, currentTime: time)
+            return
+        }
+        
         guard duration.value != 0 else{
             delegate?.didSeek(value: false, currentTime: time)
             return
@@ -414,3 +484,4 @@ internal func cleanUp(player: inout AVQueuePlayer?, playerLooper: inout AVPlayer
     print("Cleaned up.")
     #endif
 }
+

Sources/swiftui-loop-videoplayer/protocol/player/LoopingPlayerProtocol.swift

@@ -51,7 +51,7 @@ public protocol LoopingPlayerProtocol: AbstractPlayer, LayerMakerProtocol{
     /// - Parameters:
     ///   - item: The AVPlayerItem to observe for status changes.
     ///   - player: The AVQueuePlayer to observe for errors.
-    func setupObservers(for item: AVPlayerItem, player: AVQueuePlayer)
+    func setupObservers(for player: AVQueuePlayer)
 
     /// Responds to errors reported by the AVQueuePlayer.
     ///
@@ -61,34 +61,6 @@ public protocol LoopingPlayerProtocol: AbstractPlayer, LayerMakerProtocol{
 
 internal extension LoopingPlayerProtocol {
 
-    /// Updates the player to play a new asset and handles the playback state.
-    ///
-    /// - Parameters:
-    ///   - asset: The AVURLAsset to load into the player.
-    func update(asset: AVURLAsset, loop : Bool){
-        
-        guard let player = player else { return }
-        
-        let wasPlaying = player.rate != 0
-        
-        if wasPlaying {
-            pause()
-        }
-
-        // Cleaning
-        unloop()
-        clearPlayerQueue()
-        removeAllFilters()
-        
-        // Replace the current item
-        let newItem = AVPlayerItem(asset: asset)
-        player.insert(newItem, after: nil)
-        if loop{
-            self.loop()
-        }
-        play()
-    }
-    
     /// Sets up the player components with the specified media asset, display properties, and optional time publishing interval.
     ///
     /// - Parameters:
@@ -101,14 +73,15 @@ internal extension LoopingPlayerProtocol {
         timePublishing:  CMTime?,
         loop: Bool
     ) {
-        let item = AVPlayerItem(asset: asset)
 
-        let player = AVQueuePlayer(items: [item])
+        let player = AVQueuePlayer(items: [])
         self.player = player
 
+        update(asset: asset, loop: loop)
+        
         configurePlayer(player, gravity: gravity, timePublishing: timePublishing, loop: loop)
 
-        setupObservers(for: item, player: player)
+        setupObservers(for: player)
     }
 
     /// Configures the provided AVQueuePlayer with specific properties for video playback.
@@ -140,31 +113,21 @@ internal extension LoopingPlayerProtocol {
         #endif
         compositeLayer.frame = CGRect(x: 0, y: 0, width: bounds.width, height: bounds.height)
 
-        if loop{
-            self.loop()
-        }
-        
-        if !filters.isEmpty{ // have an idea for the feature
-            applyVideoComposition()
-        }
-        
         if let timePublishing{
             timeObserverToken = player.addPeriodicTimeObserver(forInterval: timePublishing, queue: .main) { [weak self] time in
                 guard let self = self else{ return }
 
                 self.delegate?.didPassedTime(seconds: time.seconds)
             }
         }
-        
-        player.play()
     }
 
     /// Sets up observers on the player item and the player to track their status and error states.
     ///
     /// - Parameters:
     ///   - item: The player item to observe.
     ///   - player: The player to observe.
-    func setupObservers(for item: AVPlayerItem, player: AVQueuePlayer) {
+    func setupObservers(for player: AVQueuePlayer) {
         errorObserver = player.observe(\.error, options: [.new]) { [weak self] player, _ in
             self?.handlePlayerError(player)
         }
@@ -190,13 +153,7 @@ internal extension LoopingPlayerProtocol {
         delegate?.didReceiveError(.remoteVideoError(error))
     }
 
-    /// Clears all items from the player's queue.
-    func clearPlayerQueue() {
-        guard let items = player?.items() else { return }
-        for item in items {
-            player?.remove(item)
-        }
-    }
+
 
     /// Sets the playback command for the video player.
     /// - Parameter value: The `PlaybackCommand` to set. This can be one of the following:

Sources/swiftui-loop-videoplayer/view/main/LoopPlayerMultiPlatform.swift

@@ -178,7 +178,7 @@ extension LoopPlayerMultiPlatform: NSViewRepresentable{
 fileprivate func getAssetIfChanged(for settings: VideoSettings, and asset: AVURLAsset?) -> AVURLAsset?{
     let newAsset =  assetFor(settings)
 
-    guard asset != nil else{
+    if asset == nil {
         return newAsset
     }