react-native-theoplayer 1.8.2 → 2.0.0

package/ios/ads/THEOplayerRCTAdAggregator.swift

@@ -40,7 +40,7 @@ let PROP_COMPANION_RESOURCE_URI: String = "resourceURI"
 
 class THEOplayerRCTAdAggregator {
 
-#if (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
     class func aggregateAd(ad: Ad, processAdBreak: Bool = true) -> [String:Any] {
         var adData: [String:Any] = [:]
         adData[PROP_AD_INTEGRATION] = ad.integration._rawValue

package/ios/ads/THEOplayerRCTAdsAPI.swift

@@ -8,6 +8,9 @@
 
 import Foundation
 import UIKit
+#if canImport(THEOplayerGoogleIMAIntegration)
+import THEOplayerGoogleIMAIntegration
+#endif
 
 let ERROR_CODE_ADS_ACCESS_FAILURE = "ads_access_failure"
 let ERROR_CODE_ADS_GET_PLAYING_STATE_FAILED = "ads_get_playing_state_failure"
@@ -35,8 +38,7 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         return false
     }
 
-#if (GOOGLE_IMA || GOOGLE_DAI)
-    
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
     @objc(skip:)
     func skip(_ node: NSNumber) -> Void {
         

package/ios/ads/THEOplayerRCTAdsEventHandler.swift

@@ -54,7 +54,7 @@ class THEOplayerRCTAdsEventHandler {
             return
         }
         
-#if (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
         // AD_BEGIN
         self.adBeginListener = player.ads.addEventListener(type: AdsEventTypes.AD_BEGIN) { [weak self] event in
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_BEGIN event from THEOplayer Ads") }
@@ -180,7 +180,7 @@ class THEOplayerRCTAdsEventHandler {
             return
         }
         
-#if (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
         // AD_BEGIN
         if let adBeginListener = self.adBeginListener {
             player.ads.removeEventListener(type: AdsEventTypes.AD_BEGIN, listener: adBeginListener)

package/ios/ads/THEOplayerRCTSourceDescriptionBuilder+Ads.swift

@@ -15,7 +15,7 @@ extension THEOplayerRCTSourceDescriptionBuilder {
     static func buildAdDescriptions(_ sourceData: NSDictionary) -> [AdDescription]? {
         var adsDescriptions: [AdDescription]?
 
-#if GOOGLE_IMA
+#if GOOGLE_IMA || canImport(THEOplayerGoogleIMAIntegration)
         if let ads = sourceData[SD_PROP_ADS] {
             adsDescriptions = []
             // case: array of ads objects
@@ -53,7 +53,7 @@ extension THEOplayerRCTSourceDescriptionBuilder {
      - returns: a THEOplayer GoogleImaAdDescription
      */
     static func buildSingleAdDescription(_ adsData: [String:Any]) -> AdDescription? {
-#if GOOGLE_IMA
+#if GOOGLE_IMA || canImport(THEOplayerGoogleIMAIntegration)
         if let integration = adsData[SD_PROP_INTEGRATION] as? String,
            integration == AdIntegration.google_ima._rawValue {
             // timeOffset can be Int or String: 10, "01:32:54.78", "1234.56", "start", "end", "10%", ...

package/ios/ads/THEOplayerRCTView+Ads.swift

@@ -3,6 +3,10 @@
 import Foundation
 import THEOplayerSDK
 
+#if canImport(THEOplayerGoogleIMAIntegration)
+import THEOplayerGoogleIMAIntegration
+#endif
+
 extension THEOplayerRCTView {
     
     func ads() -> Ads? {
@@ -11,5 +15,14 @@ extension THEOplayerRCTView {
         }
         return player.ads
     }
-
+    
+    func initAdsIntegration() {
+        guard let player = self.player else {
+            return
+        }
+#if canImport(THEOplayerGoogleIMAIntegration)
+        let imaIntegration = GoogleIMAIntegrationFactory.createIntegration(on: player)
+        player.addIntegration(imaIntegration)
+#endif
+    }
 }

package/ios/ads/THEOplayerRCTView+AdsConfig.swift

@@ -25,12 +25,13 @@ extension THEOplayerRCTView {
         }
     }
 
-#if (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
     func playerAdsConfiguration() -> AdsConfiguration? {
-        // NOTE: GoogleIMAAdsConfiguration, GoogleDAIAdsConfigurationBuilder, GoogleDAIAdsConfigurationBuilder require iOS SDK 4.5.1 or higher
-        let googleIMAAdsConfiguration = GoogleIMAAdsConfiguration()
-        googleIMAAdsConfiguration.useNativeIma = self.adsConfig.googleImaUsesNativeIma
-        googleIMAAdsConfiguration.disableUI = !self.adsConfig.adSUIEnabled
+        let googleBuilder = GoogleIMAConfigurationBuilder()
+        googleBuilder.useNativeIMA = self.adsConfig.googleImaUsesNativeIma
+        googleBuilder.disableUI = !self.adsConfig.adSUIEnabled
+        googleBuilder.enableBackgroundPlayback = true
+        let googleIMAAdsConfiguration = googleBuilder.build()
         let daiBuilder = GoogleDAIAdsConfigurationBuilder()
         daiBuilder.disableUI = !self.adsConfig.adSUIEnabled
         daiBuilder.enableBackgroundPlayback = true
@@ -40,7 +41,7 @@ extension THEOplayerRCTView {
                                 googleIma: googleIMAAdsConfiguration,
                                 googleDai: googleDaiAdsConfiguration)
         
-        // For lower iOS SDK versions replace the above with:
+        // For older iOS SDK versions replace the above with:
         /*let googleIMAConfiguration = GoogleIMAConfiguration()
          googleIMAConfiguration.useNativeIma = self.googleImaUsesNativeIma
          googleIMAConfiguration.disableUI = !self.adSUIEnabled
@@ -71,7 +72,7 @@ extension THEOplayerRCTView {
     
     func parseAdsConfig(configDict: NSDictionary) {}
     
-#if GOOGLE_IMA
+#if GOOGLE_IMA || canImport(THEOplayerGoogleIMAIntegration)
     func playerAdsConfiguration() -> AdsConfiguration? { return AdsConfiguration() }
 #else
     func playerAdsConfiguration() -> AdsConfiguration? { return nil }

package/ios/backgroundAudio/THEOplayerRCTNowPlayingManager.swift

@@ -0,0 +1,254 @@
+// THEOplayerRCTView+BackgroundAudioConfig.swift
+
+import Foundation
+import THEOplayerSDK
+import MediaPlayer
+
+class THEOplayerRCTNowPlayingManager {
+    // MARK: Members
+    private weak var player: THEOplayer?
+    private var nowPlayingInfo = [String : Any]()
+    
+    // MARK: player Listeners
+    private var durationChangeListener: EventListener?
+    private var playingListener: EventListener?
+    private var pauseListener: EventListener?
+    private var rateChangeListener: EventListener?
+    private var seekedListener: EventListener?
+    private var sourceChangeListener: EventListener?
+    
+    // MARK: - destruction
+    func destroy() {
+        // dettach listeners
+        self.dettachListeners()
+    }
+    
+    // MARK: - player setup / breakdown
+    func setPlayer(_ player: THEOplayer) {
+        self.player = player;
+        
+        // attach listeners
+        self.attachListeners()
+    }
+    
+    func updateNowPlaying() {
+        // Reset any existing playing info
+        self.nowPlayingInfo = [:]
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
+        
+        // Gather new playing info
+        if let player = self.player,
+           let sourceDescription = player.source,
+           let metadata = sourceDescription.metadata {
+            let artWorkUrlString = self.getArtWorkUrlStringFromSourceDescription(sourceDescription)
+            DispatchQueue.global().async {
+                self.nowPlayingInfo = [String : Any]()
+                self.updatePlaybackState()
+                self.updateTitle(metadata.title)
+                self.updateSubtitle(metadata.metadataKeys?["subtitle"] as? String)
+                self.updateDuration(player.duration)
+                self.updateMediaType() // video
+                self.updateArtWork(artWorkUrlString)
+                self.updatePlaybackRate(player.playbackRate)
+                self.updateServiceIdentifier(metadata.metadataKeys?["nowPlayingServiceIdentifier"] as? String)
+                self.updateContentIdentifier(metadata.metadataKeys?["nowPlayingContentIdentifier"] as? String)
+                self.updateCurrentTime { [weak self] in
+                    if let welf = self {
+                        MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                        if DEBUG_NOWINFO { print("[NATIVE] NowPlayingInfoCenter Updated.") }
+                    }
+                }
+            }
+        }
+    }
+    
+    private func getArtWorkUrlStringFromSourceDescription(_ sourceDescription: SourceDescription) -> String? {
+        if let posterUrlString = sourceDescription.poster?.absoluteString {
+            return posterUrlString
+        }
+        
+        if let metadata = sourceDescription.metadata,
+           let displayIconUrlString = metadata.metadataKeys?["displayIconUri"] as? String {
+            return displayIconUrlString
+        }
+        
+        return nil
+    }
+    
+    private func updateTitle(_ metadataTitle: String?) {
+        if let title = metadataTitle {
+            self.nowPlayingInfo[MPMediaItemPropertyTitle] = title
+        }
+    }
+    
+    private func updateSubtitle(_ metadataSubtitle: String?) {
+        if let subtitle = metadataSubtitle {
+            self.nowPlayingInfo[MPMediaItemPropertyArtist] = subtitle
+        }
+    }
+    
+    private func updateDuration(_ playerDuration: Double?) {
+        if let duration = playerDuration {
+            self.nowPlayingInfo[MPNowPlayingInfoPropertyIsLiveStream] = duration.isInfinite
+            if (!duration.isInfinite) {
+                self.nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration
+            }
+        }
+    }
+    
+    private func updateServiceIdentifier(_ serviceId: String?) {
+        if let id = serviceId {
+            self.nowPlayingInfo[MPNowPlayingInfoPropertyServiceIdentifier] = id
+        }
+    }
+    
+    private func updateContentIdentifier(_ contentId: String?) {
+        if let id = contentId {
+            self.nowPlayingInfo[MPNowPlayingInfoPropertyExternalContentIdentifier] = id
+        }
+    }
+    
+    private func updateMediaType() {
+        self.nowPlayingInfo[MPNowPlayingInfoPropertyMediaType] = NSNumber(value: 2)
+    }
+    
+    private func updatePlaybackState() {
+        if #available(iOS 13.0, tvOS 13.0, *) {
+            if let player = self.player {
+                MPNowPlayingInfoCenter.default().playbackState = player.paused ? MPNowPlayingPlaybackState.paused : MPNowPlayingPlaybackState.playing
+            }
+        }
+    }
+    
+    private func updateArtWork(_ urlString: String?) {
+        if let artUrlString = urlString,
+           let artUrl = URL(string: artUrlString),
+           let displayIconData = try? Data(contentsOf: artUrl),
+           let displayIcon = UIImage(data: displayIconData) {
+            self.nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(boundsSize: displayIcon.size) { size in
+                return displayIcon
+            }
+        }
+    }
+    
+    private func updatePlaybackRate(_ playerPlaybackRate: Double) {
+        self.nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = NSNumber(value: playerPlaybackRate)
+    }
+    
+    private func updateCurrentTime(completion: (() -> Void)?) {
+        if let player = self.player {
+            player.requestCurrentTime(completionHandler: { [weak self] time, error in
+                if let welf = self,
+                   let currentTime = time {
+                    welf.nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = NSNumber(value: currentTime)
+                    DispatchQueue.main.async {
+                        completion?()
+                    }
+                }
+            })
+        }
+    }
+    
+    private func attachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // DURATION_CHANGE
+        self.durationChangeListener = player.addEventListener(type: PlayerEventTypes.DURATION_CHANGE) { [weak self] event in
+            if let welf = self,
+               let duration = player.duration {
+                welf.nowPlayingInfo[MPNowPlayingInfoPropertyIsLiveStream] = duration.isInfinite
+                if (!duration.isInfinite) {
+                    welf.nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration
+                    MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                    if DEBUG_NOWINFO { print("[NATIVE] DURATION_CHANGE: Duration updated on NowPlayingInfoCenter.") }
+                }
+            }
+        }
+        
+        // PLAYING
+        self.playingListener = player.addEventListener(type: PlayerEventTypes.PLAYING) { [weak self] event in
+            self?.updatePlaybackState()
+            self?.updateCurrentTime { [weak self] in
+                if let welf = self {
+                    MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                    if DEBUG_NOWINFO { print("[NATIVE] PLAYING: PlaybackState and time updated on NowPlayingInfoCenter.") }
+                }
+            }
+        }
+        
+        // PAUSE
+        self.pauseListener = player.addEventListener(type: PlayerEventTypes.PAUSE) { [weak self] event in
+            self?.updatePlaybackState()
+            self?.updateCurrentTime { [weak self] in
+                if let welf = self {
+                    MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                    if DEBUG_NOWINFO { print("[NATIVE] PAUSED: PlaybackState and time updated on NowPlayingInfoCenter.") }
+                }
+            }
+        }
+                                          
+        
+        // RATE_CHANGE
+        self.rateChangeListener = player.addEventListener(type: PlayerEventTypes.RATE_CHANGE) { [weak self] event in
+            if let welf = self {
+                welf.nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = NSNumber(value: player.playbackRate)
+                MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                if DEBUG_NOWINFO { print("[NATIVE] RATE_CHANGE: PlaybackRate updated on NowPlayingInfoCenter.") }
+            }
+        }
+        
+        // SEEKED
+        self.seekedListener = player.addEventListener(type: PlayerEventTypes.SEEKED) { [weak self] event in
+            self?.updateCurrentTime { [weak self] in
+                if let welf = self {
+                    MPNowPlayingInfoCenter.default().nowPlayingInfo = welf.nowPlayingInfo
+                    if DEBUG_NOWINFO { print("[NATIVE] SEEKED: Time updated on NowPlayingInfoCenter.") }
+                }
+            }
+        }
+        
+        // SOURCE_CHANGE
+        self.sourceChangeListener = player.addEventListener(type: PlayerEventTypes.SOURCE_CHANGE) { [weak self] event in
+            self?.updateNowPlaying()
+            if DEBUG_NOWINFO { print("[NATIVE] SOURCE_CHANGE: Full update on NowPlayingInfoCenter.") }
+        }
+    }
+    
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // DURATION_CHANGE
+        if let durationChangeListener = self.durationChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.DURATION_CHANGE, listener: durationChangeListener)
+        }
+        
+        // PLAYING
+        if let playingListener = self.playingListener {
+            player.removeEventListener(type: PlayerEventTypes.PLAYING, listener: playingListener)
+        }
+        
+        // PAUSE
+        if let pauseListener = self.pauseListener {
+            player.removeEventListener(type: PlayerEventTypes.PAUSE, listener: pauseListener)
+        }
+        
+        // RATE_CHANGE
+        if let rateChangeListener = self.rateChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.RATE_CHANGE, listener: rateChangeListener)
+        }
+        
+        // SEEKED
+        if let seekedListener = self.seekedListener {
+            player.removeEventListener(type: PlayerEventTypes.SEEKED, listener: seekedListener)
+        }
+        
+        // SOURCE_CHANGE
+        if let sourceChangeListener = self.sourceChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.SOURCE_CHANGE, listener: sourceChangeListener)
+        }
+    }
+}

package/ios/backgroundAudio/THEOplayerRCTRemoteCommandsManager.swift

@@ -0,0 +1,238 @@
+// THEOplayerRCTView+BackgroundAudioConfig.swift
+
+import Foundation
+import THEOplayerSDK
+import MediaPlayer
+
+let DEFAULT_SKIP_INTERVAL: UInt = 15
+
+class THEOplayerRCTRemoteCommandsManager: NSObject {
+    // MARK: Members
+    private weak var player: THEOplayer?
+    private var isLive: Bool = false
+    private var inAd: Bool = false
+    private var backgroundaudioConfig = BackgroundAudioConfig()
+    
+    // MARK: player Listeners
+    private var durationChangeListener: EventListener?
+    private var sourceChangeListener: EventListener?
+    private var adBreakBeginListener: EventListener?
+    private var adBreakEndListener: EventListener?
+    
+    // MARK: - destruction
+    func destroy() {
+        // dettach listeners
+        self.dettachListeners()
+    }
+    
+    // MARK: - player setup / breakdown
+    func setPlayer(_ player: THEOplayer) {
+        self.player = player;
+        self.initRemoteCommands()
+        
+        // attach listeners
+        self.attachListeners()
+    }
+    
+    func setBackGroundAudioConfig(_ newBackgroundAudioConfig: BackgroundAudioConfig) {
+        self.backgroundaudioConfig = newBackgroundAudioConfig
+        self.updateRemoteCommands()
+    }
+    
+    private func initRemoteCommands() {
+        self.isLive = false
+        self.inAd = false
+        let commandCenter = MPRemoteCommandCenter.shared()
+        
+        commandCenter.playCommand.isEnabled = true
+        commandCenter.pauseCommand.isEnabled = true
+        commandCenter.togglePlayPauseCommand.isEnabled = true
+        commandCenter.stopCommand.isEnabled = true
+        commandCenter.changePlaybackPositionCommand.isEnabled = true
+        
+        // PLAY
+        commandCenter.playCommand.addTarget(self, action: #selector(onPlayCommand(_:)))
+        // PAUSE
+        commandCenter.pauseCommand.addTarget(self, action: #selector(onPauseCommand(_:)))
+        // PLAY/PAUSE
+        commandCenter.togglePlayPauseCommand.addTarget(self, action: #selector(onTogglePlayPauseCommand(_:)))
+        // STOP
+        commandCenter.stopCommand.addTarget(self, action: #selector(onStopCommand(_:)))
+        // SCRUBBER
+        commandCenter.changePlaybackPositionCommand.addTarget(self, action: #selector(onScrubCommand(_:)))
+        // ADD SEEK FORWARD
+        commandCenter.skipForwardCommand.preferredIntervals = [NSNumber(value: DEFAULT_SKIP_INTERVAL)]
+        commandCenter.skipForwardCommand.addTarget(self, action: #selector(onSkipForwardCommand(_:)))
+        // ADD SEEK BACKWARD
+        commandCenter.skipBackwardCommand.preferredIntervals = [NSNumber(value: DEFAULT_SKIP_INTERVAL)]
+        commandCenter.skipBackwardCommand.addTarget(self, action: #selector(onSkipBackwardCommand(_:)))
+        
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Remote commands initialised.") }
+    }
+    
+    func updateRemoteCommands() {
+        let commandCenter = MPRemoteCommandCenter.shared()
+        commandCenter.playCommand.isEnabled = !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.pauseCommand.isEnabled = !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.togglePlayPauseCommand.isEnabled = !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.stopCommand.isEnabled = !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.changePlaybackPositionCommand.isEnabled = !isLive && !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.skipForwardCommand.isEnabled = !isLive && !self.inAd && self.backgroundaudioConfig.enabled
+        commandCenter.skipBackwardCommand.isEnabled = !isLive && !self.inAd && self.backgroundaudioConfig.enabled
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Remote commands updated for \(self.isLive ? "LIVE" : "VOD") (\(self.inAd ? "AD IS PLAYING" : "NO AD PLAYING"), \(self.backgroundaudioConfig.enabled ? "BGAUDIO ENABLED" : "BGAUDIO DISABLED") ).") }
+    }
+    
+    @objc private func onPlayCommand(_ event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player,
+           player.paused {
+            player.play()
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Play command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Play command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onPauseCommand(_ event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player,
+           !player.paused {
+            player.pause()
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Pause command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Pause command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onTogglePlayPauseCommand(_ event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player {
+            if player.paused {
+                player.play()
+            } else {
+                player.pause()
+            }
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Toggle play/pause command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Toggle play/pause command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onStopCommand(_ event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player {
+            if !player.paused {
+                player.pause()
+            }
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Stop command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Stop command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onScrubCommand(_ event: MPChangePlaybackPositionCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player {
+            player.setCurrentTime(event.positionTime)
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Scrub command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Scrub command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onSkipForwardCommand(_ event: MPSkipIntervalCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player {
+            player.requestCurrentTime(completionHandler: { time, error in
+                if let currentTime = time {
+                    player.setCurrentTime(currentTime + event.interval)
+                }
+            })
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Skip forward command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Skip forward command Failed.") }
+        return .commandFailed
+    }
+    
+    @objc private func onSkipBackwardCommand(_ event: MPSkipIntervalCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = self.player {
+            player.requestCurrentTime(completionHandler: { time, error in
+                if let currentTime = time {
+                    player.setCurrentTime(currentTime - event.interval)
+                }
+            })
+            if DEBUG_REMOTECOMMANDS { print("[NATIVE] Skip backward command triggered.") }
+            return .success
+        }
+        if DEBUG_REMOTECOMMANDS { print("[NATIVE] Skip backward command Failed.") }
+        return .commandFailed
+    }
+    
+    private func attachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // DURATION_CHANGE
+        self.durationChangeListener = player.addEventListener(type: PlayerEventTypes.DURATION_CHANGE) { [weak self] event in
+            if let duration = event.duration {
+                self?.isLive = duration.isInfinite
+                self?.updateRemoteCommands()
+            }
+        }
+        
+        // SOURCE_CHANGE
+        self.sourceChangeListener = player.addEventListener(type: PlayerEventTypes.SOURCE_CHANGE) { [weak self] event in
+            self?.isLive = false
+            self?.inAd = false
+            self?.updateRemoteCommands()
+        }
+        
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
+        
+        // ADBREAK_BEGIN
+        self.adBreakBeginListener = player.ads.addEventListener(type: AdsEventTypes.AD_BREAK_BEGIN) { [weak self] event in
+            self?.inAd = true
+        }
+        
+        // ADBREAK_END
+        self.adBreakEndListener = player.ads.addEventListener(type: AdsEventTypes.AD_BREAK_END) { [weak self] event in
+            self?.inAd = false
+        }
+        
+#endif
+        
+    }
+    
+    private func dettachListeners() {
+        guard let player = self.player else {
+            return
+        }
+        
+        // DURATION_CHANGE
+        if let durationChangeListener = self.durationChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.DURATION_CHANGE, listener: durationChangeListener)
+        }
+        
+        // SOURCE_CHANGE
+        if let sourceChangeListener = self.sourceChangeListener {
+            player.removeEventListener(type: PlayerEventTypes.SOURCE_CHANGE, listener: sourceChangeListener)
+        }
+        
+#if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
+        
+        // ADBREAK_BEGIN
+        if let adBreakBeginListener = self.adBreakBeginListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_BREAK_BEGIN, listener: adBreakBeginListener)
+        }
+        
+        // ADBREAK_END
+        if let adBreakEndListener = self.adBreakEndListener {
+            player.ads.removeEventListener(type: AdsEventTypes.AD_BREAK_END, listener: adBreakEndListener)
+        }
+        
+#endif
+        
+    }
+    
+}

package/ios/backgroundAudio/THEOplayerRCTView+BackgroundAudioConfig.swift

@@ -0,0 +1,33 @@
+// THEOplayerRCTView+BackgroundAudioConfig.swift
+
+import Foundation
+import THEOplayerSDK
+
+struct BackgroundAudioConfig {
+    var enabled: Bool = false
+}
+
+#if WEB
+
+extension THEOplayerRCTView {
+    func initBackgroundAudio() {}
+    public func shouldContinueAudioPlaybackInBackground() -> Bool { return false }
+}
+
+#else
+
+extension THEOplayerRCTView: BackgroundPlaybackDelegate {
+
+    func initBackgroundAudio() {
+        self.player?.backgroundPlaybackDelegate = self
+    }
+    
+    public func shouldContinueAudioPlaybackInBackground() -> Bool {
+        // Make sure to go to the background with updated NowPlayingInfo
+        self.nowPlayingManager.updateNowPlaying()
+        
+        return self.backgroundAudioConfig.enabled
+    }
+}
+
+#endif

package/ios/casting/THEOplayerRCTCastAPI+Chromecast.swift

@@ -8,7 +8,7 @@ let ERROR_MESSAGE_CHROMECAST_ACCESS_FAILURE = "Could not access THEOplayer Chrom
 
 extension THEOplayerRCTCastAPI {
    
-#if os(iOS) && CHROMECAST
+#if os(iOS) && (CHROMECAST || canImport(THEOplayerGoogleCastIntegration))
     
     @objc(chromecastCasting:resolver:rejecter:)
     func chromecastCasting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {

package/ios/casting/THEOplayerRCTCastEventHandler.swift

@@ -46,7 +46,7 @@ class THEOplayerRCTCastEventHandler {
             return
         }
         
-#if os(iOS) && CHROMECAST
+#if os(iOS) && (CHROMECAST || canImport(THEOplayerGoogleCastIntegration))
         // CHROMECAST STATE_CHANGE
         self.chromecastStateChangeListener = player.cast?.chromecast?.addEventListener(type: ChromecastEventTypes.STATE_CHANGE) { [weak self] event in
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received Chromecast STATE_CHANGE event from THEOplayer cast.chromecast") }
@@ -101,7 +101,7 @@ class THEOplayerRCTCastEventHandler {
             return
         }
 
-#if os(iOS) && CHROMECAST
+#if os(iOS) && (CHROMECAST || canImport(THEOplayerGoogleCastIntegration))
         // CHROMECAST STATE_CHANGE
         if let chromecastStateChangeListener = self.chromecastStateChangeListener {
             player.cast?.chromecast?.removeEventListener(type: ChromecastEventTypes.STATE_CHANGE, listener: chromecastStateChangeListener)