added time publishing

Author: swiftuiux

Sources/swiftui-loop-videoplayer/LoopPlayerView.swift

@@ -6,20 +6,27 @@
 //
 
 import SwiftUI
+import Combine
 #if canImport(AVKit)
 import AVKit
 #endif
 
 /// Player view for running a video in loop
 @available(iOS 14.0, macOS 11.0, tvOS 14.0, *)
-public struct LoopPlayerView: View {
+public struct LoopPlayerView: View {    
 
     /// Set of settings for video the player
     @Binding public var settings: VideoSettings
 
     /// Binding to a playback command that controls playback actions
     @Binding public var command: PlaybackCommand
 
+    /// The current playback time, represented as a Double.
+    @State private var currentTime: Double = 0.0
+    
+    /// A publisher that emits the current time as a Double value.
+    @State var timePublisher = PassthroughSubject<Double, Never>()
+    
     private var videoId : String{
         [settings.name, settings.ext].joined(separator: ".")
     }
@@ -28,33 +35,42 @@ public struct LoopPlayerView: View {
 
     /// Player initializer
     /// - Parameters:
-    ///   - fileName: Name of the video to play
-    ///   - ext: Video extension
-    ///   - gravity: A structure that defines how a layer displays a player’s visual content within the layer’s bounds
-    ///   - eColor: Color of the error message text if the file is not found
-    ///   - eFontSize: Size of the error text
-    ///   - command: A binding to control playback actions
+    ///   - fileName: The name of the video file.
+    ///   - ext: The file extension, with a default value of "mp4".
+    ///   - gravity: The video gravity setting, with a default value of `.resizeAspect`.
+    ///   - timePublishing: An optional `CMTime` value for time publishing, with a default value of 1 second.
+    ///   - eColor: The color to be used, with a default value of `.accentColor`.
+    ///   - eFontSize: The font size to be used, with a default value of 17.0.
+    ///   - command: A binding to the playback command, with a default value of `.play`.
     public init(
         fileName: String,
         ext: String = "mp4",
         gravity: AVLayerVideoGravity = .resizeAspect,
+        timePublishing : CMTime? = CMTime(seconds: 1, preferredTimescale: 600),
         eColor: Color = .accentColor,
         eFontSize: CGFloat = 17.0,
         command : Binding<PlaybackCommand> = .constant(.play)
     ) {
         self._command = command
+
+        func description(@SettingsBuilder content: () -> [Setting]) -> [Setting] {
+          return content()
+        }
 
-        _settings = .constant(
-            VideoSettings {
-                SourceName(fileName)
-                Ext(ext)
-                Gravity(gravity)
-                ErrorGroup {
-                    EColor(eColor)
-                    EFontSize(eFontSize)
-                }
+        let settings: VideoSettings = VideoSettings {
+            SourceName(fileName)
+            Ext(ext)
+            Gravity(gravity)
+            if let timePublishing{
+                timePublishing
+           }
+            ErrorGroup {
+                EColor(eColor)
+                EFontSize(eFontSize)
             }
-        )
+        }
+        
+        _settings = .constant(settings)
     }
 
     /// Player initializer in a declarative way
@@ -85,7 +101,11 @@ public struct LoopPlayerView: View {
     // MARK: - API
 
    public var body: some View {
-       LoopPlayerMultiPlatform(settings: $settings, command: $command)
+       LoopPlayerMultiPlatform(settings: $settings, command: $command, timePublisher: timePublisher)
            .frame(maxWidth: .infinity, maxHeight: .infinity)
+           .onReceive(timePublisher, perform: { time in
+               currentTime = time
+           })
+           .preference(key: CurrentTimePreferenceKey.self, value: currentTime)
    }
 }

Sources/swiftui-loop-videoplayer/enum/PlaybackCommand.swift

@@ -1,5 +1,14 @@
+//
+//  PlaybackCommand.swift
+//
+//
+//  Created by Igor Shelopaev on 05.08.24.
+//
+
 import AVFoundation
+#if canImport(CoreImage)
 import CoreImage
+#endif
 
 /// An enumeration of possible playback commands.
 @available(iOS 14.0, macOS 11.0, tvOS 14.0, *)

Sources/swiftui-loop-videoplayer/enum/Setting.swift

@@ -11,16 +11,23 @@ import SwiftUI
 import AVKit
 #endif
 
-
 /// Settings for loop video player
 @available(iOS 14.0, macOS 11.0, tvOS 14.0, *)
-public enum Setting: Equatable{
+public enum Setting: Equatable, SettingsConvertible{
+    
+    public func asSettings() -> [Setting] {
+        [self]
+    }
 
     /// File name
     case name(String)
 
     /// File extension
     case ext(String)
+    
+    /// A CMTime value representing the interval at which the player's current time should be published.
+    /// If set, the player will publish periodic time updates based on this interval.
+    case timePublishing(CMTime)
 
     /// Video gravity
     case gravity(AVLayerVideoGravity = .resizeAspect)

Sources/swiftui-loop-videoplayer/ext+/CMTime+.swift

@@ -0,0 +1,16 @@
+//
+//  CMTime+.swift
+//
+//
+//  Created by Igor  on 15.08.24.
+//
+
+#if canImport(AVKit)
+import AVKit
+#endif
+
+extension CMTime : SettingsConvertible{
+    public func asSettings() -> [Setting] {
+        [.timePublishing(self)]
+    }
+}

Sources/swiftui-loop-videoplayer/fn/fn+.swift

@@ -7,7 +7,9 @@
 
 import Foundation
 import AVFoundation
+#if canImport(CoreImage)
 import CoreImage
+#endif
 
 /// Retrieves an `AVURLAsset` based on specified video settings.
 /// - Parameter settings: The `VideoSettings` object containing details like name and extension of the video.

Sources/swiftui-loop-videoplayer/protocol/helpers/PlayerErrorDelegate.swift renamed to Sources/swiftui-loop-videoplayer/protocol/helpers/PlayerDelegateProtocol.swift

@@ -1,5 +1,5 @@
 //
-//  PlayerErrorDelegate.swift
+//  PlayerDelegateProtocol.swift
 //
 //
 //  Created by Igor Shelopaev on 05.08.24.
@@ -11,7 +11,7 @@ import Foundation
 ///
 /// Conforming to this protocol allows a class to respond to error events that occur within a media player context.
 @available(iOS 14, macOS 11, tvOS 14, *)
-public protocol PlayerErrorDelegate: AnyObject {
+public protocol PlayerDelegateProtocol: AnyObject {
     /// Called when an error is encountered within the media player.
     ///
     /// This method provides a way for delegate objects to respond to error conditions, allowing them to handle or
@@ -20,4 +20,6 @@ public protocol PlayerErrorDelegate: AnyObject {
     /// - Parameter error: The specific `VPErrors` instance describing what went wrong.
     @MainActor
     func didReceiveError(_ error: VPErrors)
+    
+    func didPassedTime(seconds : Double)
 }

Sources/swiftui-loop-videoplayer/protocol/helpers/SettingsConvertible.swift

@@ -15,3 +15,4 @@ public protocol SettingsConvertible {
     /// - Returns: Array of settings
     func asSettings() -> [Setting]
 }
+

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

@@ -6,7 +6,9 @@
 //
 
 import AVFoundation
+#if canImport(CoreImage)
 import CoreImage
+#endif
 
 @available(iOS 14, macOS 11, tvOS 14, *)
 @MainActor @preconcurrency
@@ -339,7 +341,7 @@ extension AbstractPlayer{
 ///   - player: A reference to the AVQueuePlayer to be cleaned up. Modified directly to deallocate resources.
 ///   - playerLooper: A reference to the AVPlayerLooper associated with the player. It's disabled and set to nil.
 ///   - errorObserver: A reference to an NSKeyValueObservation monitoring the player, which is invalidated and set to nil.
-internal func cleanUp(player: inout AVQueuePlayer?, playerLooper: inout AVPlayerLooper?, errorObserver: inout NSKeyValueObservation?) {
+internal func cleanUp(player: inout AVQueuePlayer?, playerLooper: inout AVPlayerLooper?, errorObserver: inout NSKeyValueObservation?, timeObserverToken: inout Any?) {
     errorObserver?.invalidate()
     errorObserver = nil
 
@@ -353,6 +355,11 @@ internal func cleanUp(player: inout AVQueuePlayer?, playerLooper: inout AVPlayer
         player?.remove(item)
     }
 
+    if let observerToken = timeObserverToken {
+        player?.removeTimeObserver(observerToken)
+        timeObserverToken = nil
+    }
+    
     player = nil
 
     #if DEBUG

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

@@ -30,18 +30,23 @@ public protocol LoopingPlayerProtocol: AbstractPlayer, LayerMakerProtocol{
     var playerLayer : AVPlayerLayer { get }
 
     /// The delegate to be notified about errors encountered by the player.
-    var delegate: PlayerErrorDelegate? { get set }
+    var delegate: PlayerDelegateProtocol? { get set }
 
     /// An optional NSKeyValueObservation to monitor errors encountered by the video player.
     /// This observer should be configured to detect and handle errors from the AVQueuePlayer,
     /// ensuring that all playback errors are managed and reported appropriately.
     var errorObserver: NSKeyValueObservation? { get set }
+    
+    /// Declare a variable to hold the time observer token outside the if statement
+    var timeObserverToken: Any? { get set }
 
-    /// Initializes a video player with a specified media asset and layer gravity.
+    /// Initializes a new instance of the view
+    ///
     /// - Parameters:
-    ///   - asset: The `AVURLAsset` representing the media content to be played. This asset encapsulates the properties of the media file.
-    ///   - gravity: The `AVLayerVideoGravity` that determines how the video content is displayed within the bounds of the player layer. Common values are `.resizeAspect`, `.resizeAspectFill`, and `.resize` to control the scaling and filling behavior of the video content.
-    init(asset: AVURLAsset, gravity: AVLayerVideoGravity)
+    ///   - asset: The AVURLAsset to be used in the player.
+    ///   - gravity: Specifies how the video content should be displayed within the layer bounds.
+    ///   - timePublishing: Optional CMTime that determines the interval at which the video current time should be published. Pass nil to disable time publishing.
+    init(asset: AVURLAsset, gravity: AVLayerVideoGravity, timePublishing: CMTime?)
 
     /// Sets up the necessary observers on the AVPlayerItem and AVQueuePlayer to monitor changes and errors.
     ///
@@ -90,23 +95,24 @@ internal extension LoopingPlayerProtocol {
         })
     }
 
-    /// Sets up the player components using the provided asset and video gravity.
+    /// Sets up the player components with the specified media asset, display properties, and optional time publishing interval.
     ///
     /// - Parameters:
-    ///   - asset: The AVURLAsset to be played.
-    ///   - gravity: The AVLayerVideoGravity to be applied to the video layer.
-    func setupPlayerComponents(asset: AVURLAsset, gravity: AVLayerVideoGravity) {
-        // Create an AVPlayerItem with the provided asset
+    ///   - asset: The AVURLAsset representing the video content.
+    ///   - gravity: Determines how the video content is scaled or fit within the player view.
+    ///   - timePublishing: Optional interval for publishing the current playback time; nil disables this feature.
+    func setupPlayerComponents(
+        asset: AVURLAsset,
+        gravity: AVLayerVideoGravity,
+        timePublishing:  CMTime?
+    ) {
         let item = AVPlayerItem(asset: asset)
 
-        // Initialize an AVQueuePlayer with the player item
         let player = AVQueuePlayer(items: [item])
         self.player = player
 
-        // Configure the player with the specified gravity
-        configurePlayer(player, gravity: gravity)
+        configurePlayer(player, gravity: gravity, timePublishing: timePublishing)
 
-        // Set up observers to monitor status and errors
         setupObservers(for: item, player: player)
     }
 
@@ -115,7 +121,12 @@ internal extension LoopingPlayerProtocol {
     /// - Parameters:
     ///   - player: The AVQueuePlayer to be configured.
     ///   - gravity: The AVLayerVideoGravity determining how the video content should be scaled or fit within the player layer.
-    func configurePlayer(_ player: AVQueuePlayer, gravity: AVLayerVideoGravity) {
+    ///   - timePublishing: Optional interval for publishing the current playback time; nil disables this feature.
+    func configurePlayer(
+        _ player: AVQueuePlayer,
+        gravity: AVLayerVideoGravity,
+        timePublishing:  CMTime?
+    ) {
         player.isMuted = true
         playerLayer.player = player
         playerLayer.videoGravity = gravity
@@ -133,9 +144,18 @@ internal extension LoopingPlayerProtocol {
         #endif
         compositeLayer.frame = CGRect(x: 0, y: 0, width: bounds.width, height: bounds.height)
         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
+                self?.delegate?.didPassedTime(seconds: time.seconds)
+                print(time.seconds)
+            }
+        }
+        
         player.play()
     }
 

Sources/swiftui-loop-videoplayer/protocol/vector/ShapeLayerBuilderProtocol.swift

@@ -5,9 +5,13 @@
 //  Created by Igor  on 13.08.24.
 //
 
-import QuartzCore
 import CoreGraphics
 
+#if canImport(QuartzCore)
+import QuartzCore
+#endif
+
+
 /// A protocol defining a builder for creating shape layers with a unique identifier.
 ///
 /// Conforming types will be able to construct a CAShapeLayer based on provided frame, bounds, and center.

Sources/swiftui-loop-videoplayer/protocol/vector/VectorLayerProtocol.swift

@@ -10,7 +10,9 @@ import UIKit
 #elseif canImport(AppKit)
 import AppKit
 #endif
+#if canImport(QuartzCore)
 import QuartzCore
+#endif
 
 /// A protocol that defines methods and properties for managing vector layers within a composite layer.
 ///

Sources/swiftui-loop-videoplayer/protocol/view/LoopPlayerViewProtocol.swift

@@ -7,6 +7,7 @@
 
 import AVFoundation
 import SwiftUI
+import Combine
 
 /// Protocol that defines the common functionalities and properties
 /// for looping video players on different platforms.
@@ -42,7 +43,7 @@ public protocol LoopPlayerViewProtocol {
     ///   - command: A binding to a `PlaybackCommand` that controls playback actions.
     ///
     /// This initializer sets up the necessary configuration and command bindings for playback functionality.
-    init(settings: Binding<VideoSettings>, command: Binding<PlaybackCommand>)
+    init(settings: Binding<VideoSettings>, command: Binding<PlaybackCommand>, timePublisher : PassthroughSubject<Double, Never>)
 
 }
 
@@ -83,7 +84,7 @@ public extension LoopPlayerViewProtocol{
         asset: AVURLAsset?) -> PlayerView? {
 
         if let asset{
-            let player = PlayerView(asset: asset, gravity: settings.gravity)
+            let player = PlayerView(asset: asset, gravity: settings.gravity, timePublishing: settings.timePublishing)
             container.addSubview(player)
             activateFullScreenConstraints(for: player, in: container)
             return player