Add captions APIs and improve package structure

Author: SvenTiigi

README.md

@@ -226,6 +226,9 @@ let youTubePlayer = YouTubePlayer(
 
 // To update during runtime update the isLoggingEnabled property
 youTubePlayer.isLoggingEnabled = false
+
+// Additionally, you can retrieve an instance of the logger if logging is enabled.
+let logger: Logger? = youTubePlayer.logger()
 ```
 
 ### Source
@@ -427,6 +430,28 @@ try await youTubePlayer.set(playbackRate: 1.5)
 try await youTubePlayer.getAvailablePlaybackRates()
 ```
 
+#### Captions
+
+```swift
+// Sets the font size of the captions displayed in the player.
+try await youTubePlayer.setCaptions(fontSize: .large)
+
+// Sets the language of the captions.
+try await youTubePlayer.setCaptions(languageCode: .german)
+
+// Reloads the captions data for the video that is currently playing.
+try await youTubePlayer.reloadCaptions()
+
+// Returns the current captions track.
+try await youTubePlayer.getCaptionsTrack()
+
+// Returns the captions tracks.
+try await youTubePlayer.getCaptionsTracks()
+
+// Returns the captions translation languges.
+try await youTubePlayer.getCaptionsTranslationLanguages()
+```
+
 ## Video Thumbnail
 
 You can load a YouTube video thumbnail via the `YouTubeVideoThumbnail` object.

Sources/API/YouTubePlayer+CaptionsAPI.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+// MARK: - Captions
+
+public extension YouTubePlayer {
+    
+    /// Sets the font size of the captions displayed in the player.
+    /// - Parameter fontSize: The font size
+    func setCaptions(
+        fontSize: CaptionsFontSize
+    ) async throws(APIError) {
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "setOption",
+                parameters: [
+                    "'captions'",
+                    "'fontSize'",
+                    String(fontSize.value)
+                ]
+            )
+        )
+    }
+    
+    /// Reloads the captions data for the video that is currently playing.
+    func reloadCaptions() async throws(APIError) {
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "setOption",
+                parameters: [
+                    "'captions'",
+                    "'reload'",
+                    true
+                ]
+            )
+        )
+    }
+    
+    /// Sets the language of the captions.
+    /// - Parameter languageCode: The language code.
+    func setCaptions(
+        languageCode: CaptionsLanguageCode
+    ) async throws(APIError) {
+        struct LanguageCodeParameter: Encodable {
+            let languageCode: CaptionsLanguageCode
+        }
+        let encodedLanguageCodeParameter: Data
+        do {
+            encodedLanguageCodeParameter = try JSONEncoder()
+                .encode(
+                    LanguageCodeParameter(
+                        languageCode: languageCode
+                    )
+                )
+        } catch {
+            throw .init(
+                underlyingError: error,
+                reason: "Failed to encode language code parameter"
+            )
+        }
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "setOption",
+                parameters: [
+                    "'captions'",
+                    "'track'",
+                    String(
+                        decoding: encodedLanguageCodeParameter,
+                        as: UTF8.self
+                    )
+                ]
+            )
+        )
+    }
+    
+    /// Returns the current captions track.
+    func getCaptionsTrack() async throws(APIError) -> CaptionsTrack {
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "getOption",
+                parameters: [
+                    "'captions'",
+                    "'track'"
+                ]
+            ),
+            converter: .typeCast(
+                to: [String: Any].self
+            )
+            .decode()
+        )
+    }
+    
+    /// Returns the captions tracks.
+    func getCaptionsTracks() async throws(APIError) -> [CaptionsTrack] {
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "getOption",
+                parameters: [
+                    "'captions'",
+                    "'tracklist'"
+                ]
+            ),
+            converter: .typeCast(
+                to: [[String: Any]].self
+            )
+            .decode()
+        )
+    }
+    
+    /// Returns the captions translation languges.
+    func getCaptionsTranslationLanguages() async throws(APIError) -> [CaptionsTranslationLanguage] {
+        try await self.evaluate(
+            javaScript: .youTubePlayer(
+                functionName: "getOption",
+                parameters: [
+                    "'captions'",
+                    "'translationLanguages'"
+                ]
+            ),
+            converter: .typeCast(
+                to: [[String: Any]].self
+            )
+            .decode()
+        )
+    }
+    
+}

Sources/API/YouTubePlayer+EventAPI.swift

@@ -0,0 +1,96 @@
+import Combine
+import Foundation
+
+// MARK: - Events (https://developers.google.com/youtube/iframe_api_reference#Events)
+
+public extension YouTubePlayer {
+    
+    /// A Publisher that emits the current YouTube player source.
+    var sourcePublisher: some Publisher<Source?, Never> {
+        self.sourceSubject
+            .receive(on: DispatchQueue.main)
+    }
+    
+    /// The current YouTube player state.
+    var state: State {
+        self.stateSubject.value
+    }
+    
+    /// A Publisher that emits the current YouTube player state.
+    var statePublisher: some Publisher<State, Never> {
+        self.stateSubject
+            .removeDuplicates()
+            .receive(on: DispatchQueue.main)
+    }
+    
+    /// The current YouTube player playback state, if available.
+    var playbackState: PlaybackState? {
+        self.playbackStateSubject.value
+    }
+
+    /// A Boolean value that determines if the player is currently playing.
+    var isPlaying: Bool {
+        self.playbackState == .playing
+    }
+    
+    /// A Boolean value that determines if the player is currently paused.
+    var isPaused: Bool {
+        self.playbackState == .paused
+    }
+    
+    /// A Boolean value that determines if the player is currently buffering.
+    var isBuffering: Bool {
+        self.playbackState == .buffering
+    }
+    
+    /// A Boolean value that determines if the player is currently cued.
+    var isCued: Bool {
+        self.playbackState == .cued
+    }
+    
+    /// A Boolean value that determines if the player is ended.
+    var isEnded: Bool {
+        self.playbackState == .ended
+    }
+    
+    /// A Publisher that emits the current YouTube player playback state.
+    var playbackStatePublisher: some Publisher<PlaybackState, Never> {
+        self.playbackStateSubject
+            .compactMap { $0 }
+            .removeDuplicates()
+            .receive(on: DispatchQueue.main)
+    }
+    
+    /// The current YouTube player playback quality, if available.
+    var playbackQuality: PlaybackQuality? {
+        self.playbackQualitySubject.value
+    }
+    
+    /// A Publisher that emits the current YouTube player playback quality.
+    var playbackQualityPublisher: some Publisher<PlaybackQuality, Never> {
+        self.playbackQualitySubject
+            .compactMap { $0 }
+            .removeDuplicates()
+            .receive(on: DispatchQueue.main)
+    }
+    
+    /// The current YouTube player playback rate, if available.
+    var playbackRate: PlaybackRate? {
+        self.playbackRateSubject.value
+    }
+    
+    /// A Publisher that emits the current YouTube player playback rate.
+    var playbackRatePublisher: some Publisher<PlaybackRate, Never> {
+        self.playbackRateSubject
+            .compactMap { $0 }
+            .removeDuplicates()
+            .receive(on: DispatchQueue.main)
+    }
+    
+    /// A Publisher that emits whenever autoplay or scripted video playback features were blocked.
+    var autoplayBlockedPublisher: some Publisher<Void, Never> {
+        self.autoplayBlockedSubject
+            .receive(on: DispatchQueue.main)
+    }
+    
+}