react-native-theoplayer 2.16.1 → 3.0.0

package/ios/THEOplayerRCTSourceDescriptionBuilder.swift

@@ -12,6 +12,7 @@ let SD_PROP_SOURCES: String = "sources"
 let SD_PROP_POSTER: String = "poster"
 let SD_PROP_TEXTTRACKS: String = "textTracks"
 let SD_PROP_METADATA: String = "metadata"
+let SD_PROP_METADATAKEYS: String = "metadataKeys"
 let SD_PROP_SRC: String = "src"
 let SD_PROP_TYPE: String = "type"
 let SD_PROP_SSAI: String = "ssai"
@@ -289,7 +290,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
      Updates the contentProtectionData to a valid iOS SDK contentProtectionData, flattening out cross SDK differences
      - returns: a THEOplayer valid contentProtection data map
      */
-    private static func sanitiseContentProtectionData(_ contentProtectionData: [String:Any]) -> [String:Any] {
+    static func sanitiseContentProtectionData(_ contentProtectionData: [String:Any]) -> [String:Any] {
         var sanitisedContentProtectionData: [String:Any] = contentProtectionData
         // fairplay update
         if let fairplayData = contentProtectionData[SD_PROP_FAIRPLAY] as? [String:Any] {
@@ -348,7 +349,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
      Creates a THEOplayer DRMConfiguration. This requires a contentProtection property in the RN source description.
      - returns: a THEOplayer DRMConfiguration
      */
-    private static func buildContentProtection(_ contentProtectionData: [String:Any]) -> MultiplatformDRMConfiguration? {
+    static func buildContentProtection(_ contentProtectionData: [String:Any]) -> MultiplatformDRMConfiguration? {
         do {
             let data = try JSONSerialization.data(withJSONObject: contentProtectionData)
             if let integration = contentProtectionData[SD_PROP_INTEGRATION] as? String {

package/ios/THEOplayerRCTTypeUtils.swift

@@ -97,5 +97,42 @@ class THEOplayerRCTTypeUtils {
         default:
             return TextTrackStyleEdgeStyle.none
         }
+	}
+
+    class func cacheStatusToString(_ status: CacheStatus) -> String {
+        switch status {
+        case CacheStatus.initialised:
+            return "initialised"
+        default:
+            return "uninitialised"
+        }
+    }
+    
+    class func cachingTaskStatusToString(_ status: CachingTaskStatus) -> String {
+        switch status {
+        case CachingTaskStatus.error:
+            return "error"
+        case CachingTaskStatus.done:
+            return "done"
+        case CachingTaskStatus.evicted:
+            return "evicted"
+        case CachingTaskStatus.loading:
+            return "loading"
+        default:
+            return "idle"
+        }
+    }
+    
+    class func cacheStatusIdleReasonToString(_ status: CacheStatusIdleReason) -> String {
+        switch status {
+        case CacheStatusIdleReason.notStarted:
+            return "notStarted"
+        case CacheStatusIdleReason.paused:
+            return "paused"
+        case CacheStatusIdleReason.lostNetwork:
+            return "lostNetwork"
+        default:
+            return "notStarted"
+        }
     }
 }

package/ios/THEOplayerRCTView.swift

@@ -88,12 +88,11 @@ public class THEOplayerRCTView: UIView {
     private func notifyNativePlayerReady() {
         DispatchQueue.main.async {
             let versionString = THEOplayer.version
-            let suiteVersionString = THEOplayer.playerSuiteVersion
             if let forwardedNativeReady = self.onNativePlayerReady {
                 forwardedNativeReady([
                     "version":  [
                         "version" : versionString,
-                        "playerSuiteVersion": suiteVersionString
+                        "playerSuiteVersion": versionString
                     ],
                 ])
             }

package/ios/ads/THEOplayerRCTAdsAPI+DAI.swift

@@ -18,17 +18,7 @@ extension THEOplayerRCTAdsAPI {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let ads = theView.ads(),
                let dai = ads.dai {
-                dai.requestSnapBack { enabled, error in
-                    if let err = error {
-                        reject(ERROR_CODE_DAI_GET_SNAPBACK_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving dai snapback status failed: \(err.localizedDescription)") }
-                    } else if let snapBack = enabled {
-                        resolve(snapBack)
-                    } else {
-                        reject(ERROR_CODE_DAI_GET_SNAPBACK_UNDEFINED, ERROR_MESSAGE_DAI_GET_SNAPBACK_UNDEFINED, nil)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving dai snapback status failed.") }
-                    }
-                }
+                resolve(dai.snapback)
             } else {
                 reject(ERROR_CODE_DAI_ACCESS_FAILURE, ERROR_MESSAGE_DAI_ACCESS_FAILURE, nil)
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not retrieve dai snapback status (ads DAI module unavailable).") }
@@ -41,8 +31,8 @@ extension THEOplayerRCTAdsAPI {
         DispatchQueue.main.async {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let ads = theView.ads(),
-               let dai = ads.dai {
-                dai.setSnapBack(enabled, completionHandler: nil)
+               var dai = ads.dai {
+                dai.snapback = enabled
             } else {
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not update dai snapback status (ads DAI module unavailable).") }
             }

package/ios/ads/THEOplayerRCTAdsAPI.swift

@@ -53,14 +53,7 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         DispatchQueue.main.async {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let ads = theView.ads() {
-                ads.requestPlaying { playing, error in
-                    if let err = error {
-                        reject(ERROR_CODE_ADS_GET_PLAYING_STATE_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving ad playing state failed: \(err.localizedDescription)") }
-                    } else {
-                        resolve(playing)
-                    }
-                }
+                resolve(ads.playing)
             } else {
                 reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not skip ad (ads module unavailable).") }
@@ -72,18 +65,9 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
     func currentAdBreak(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
         DispatchQueue.main.async {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
-            if let ads = theView.ads() {
-                ads.requestCurrentAdBreak { adBreak, error in
-                    if let err = error {
-                        reject(ERROR_CODE_ADS_GET_CURRENT_ADBREAK_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving current adbreak failed: \(err.localizedDescription)") }
-                    } else if let currentAdBreak = adBreak {
-                        resolve(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak:currentAdBreak))
-                    } else {
-                        reject(ERROR_CODE_ADS_GET_CURRENT_ADBREAK_UNDEFINED, ERROR_MESSAGE_ADS_GET_CURRENT_ADBREAK_UNDEFINED, nil)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving current adbreak failed: could not load adbreak.") }
-                    }
-                }
+            if let ads = theView.ads(),
+               let currentAdBreak = ads.currentAdBreak {
+                resolve(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak:currentAdBreak))
             } else {
                 reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not retrieve current adbreak (ads module unavailable).") }
@@ -96,21 +80,12 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         DispatchQueue.main.async {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let ads = theView.ads() {
-                ads.requestCurrentAds { adsArray, error in
-                    if let err = error {
-                        reject(ERROR_CODE_ADS_GET_CURRENT_ADS_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving current ads failed: \(err.localizedDescription)") }
-                    } else if let currentAdsArray = adsArray {
-                        var currentAds: [[String:Any]] = []
-                        for ad in currentAdsArray {
-                            currentAds.append(THEOplayerRCTAdAggregator.aggregateAd(ad: ad))
-                        }
-                        resolve(currentAds)
-                    } else {
-                        reject(ERROR_CODE_ADS_GET_CURRENT_ADS_UNDEFINED, ERROR_MESSAGE_ADS_GET_CURRENT_ADS_UNDEFINED, nil)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving current ads failed: could not load ads.") }
-                    }
+                let currentAdsArray = ads.currentAds
+                var currentAds: [[String:Any]] = []
+                for ad in currentAdsArray {
+                    currentAds.append(THEOplayerRCTAdAggregator.aggregateAd(ad: ad))
                 }
+                resolve(currentAds)
             } else {
                 reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not retrieve current ad (ads module unavailable).") }
@@ -123,21 +98,12 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         DispatchQueue.main.async {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let ads = theView.ads() {
-                ads.requestScheduledAdBreaks { adBreaksArray, error in
-                    if let err = error {
-                        reject(ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving scheduled adbreaks failed: \(err.localizedDescription)") }
-                    } else if let currentAdBreaksArray = adBreaksArray {
-                        var currentAdBreaks: [[String:Any]] = []
-                        for adbreak in currentAdBreaksArray {
-                            currentAdBreaks.append(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adbreak))
-                        }
-                        resolve(currentAdBreaks)
-                    } else {
-                        reject(ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED, ERROR_MESSAGE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED, nil)
-                        if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Retrieving current adbreaks failed: could not load adbreaks.") }
-                    }
+                let currentAdBreaksArray = ads.scheduledAdBreaks
+                var currentAdBreaks: [[String:Any]] = []
+                for adbreak in currentAdBreaksArray {
+                    currentAdBreaks.append(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adbreak))
                 }
+                resolve(currentAdBreaks)
             } else {
                 reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
                 if DEBUG_ADS_API { PrintUtils.printLog(logText: "[NATIVE] Could not retrieve current ad (ads module unavailable).") }

package/ios/ads/THEOplayerRCTView+AdsConfig.swift

@@ -5,7 +5,6 @@ import THEOplayerSDK
 
 struct AdsConfig {
     var adSUIEnabled: Bool = true
-    var googleImaUsesNativeIma: Bool = true
     var adPreloadTypeString: String = "none"
 }
 
@@ -19,16 +18,12 @@ extension THEOplayerRCTView {
             if let adPreloadType = adsConfig["preload"] as? String {
                 self.adsConfig.adPreloadTypeString = adPreloadType
             }
-            if let googleImaConfiguration = adsConfig["googleImaConfiguration"] as? NSDictionary {
-                self.adsConfig.googleImaUsesNativeIma = googleImaConfiguration["useNativeIma"] as? Bool ?? true
-            }
         }
     }
 
 #if (GOOGLE_IMA || GOOGLE_DAI) || canImport(THEOplayerGoogleIMAIntegration)
     func playerAdsConfiguration() -> AdsConfiguration? {
         let googleBuilder = GoogleIMAConfigurationBuilder()
-        googleBuilder.useNativeIMA = self.adsConfig.googleImaUsesNativeIma
         googleBuilder.disableUI = !self.adsConfig.adSUIEnabled
         googleBuilder.enableBackgroundPlayback = true
         let googleIMAAdsConfiguration = googleBuilder.build()
@@ -40,14 +35,6 @@ extension THEOplayerRCTView {
                                 preload: self.adPreloadType(),
                                 googleIma: googleIMAAdsConfiguration,
                                 googleDai: googleDaiAdsConfiguration)
-        
-        // For older iOS SDK versions replace the above with:
-        /*let googleIMAConfiguration = GoogleIMAConfiguration()
-         googleIMAConfiguration.useNativeIma = self.googleImaUsesNativeIma
-         googleIMAConfiguration.disableUI = !self.adSUIEnabled
-         return AdsConfiguration(showCountdown: self.adSUIEnabled,
-         preload: self.adPreloadType,
-         googleImaConfiguration: googleIMAConfiguration)*/
     }
     
     private func adPreloadType() -> THEOplayerSDK.AdPreloadType {

package/ios/backgroundAudio/THEOplayerRCTNowPlayingManager.swift

@@ -50,10 +50,9 @@ class THEOplayerRCTNowPlayingManager {
             self.updatePlaybackRate(player.playbackRate)
             self.updateServiceIdentifier(metadata.metadataKeys?["nowPlayingServiceIdentifier"] as? String)
             self.updateContentIdentifier(metadata.metadataKeys?["nowPlayingContentIdentifier"] as? String)
+            self.updateCurrentTime(player.currentTime)
             self.updateArtWork(artWorkUrlString) { [weak self] in
-                self?.updateCurrentTime { [weak self] in
-                    self?.processNowPlayingToInfoCenter()
-                }
+                self?.processNowPlayingToInfoCenter()
             }
         }
     }
@@ -160,19 +159,8 @@ class THEOplayerRCTNowPlayingManager {
         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)
-                    if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] CurrentTime updated in nowPlayingInfo.") }
-                    DispatchQueue.main.async {
-                        completion?()
-                    }
-                }
-            })
-        }
+    private func updateCurrentTime(_ currentTime: Double) {
+        self.nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = NSNumber(value: currentTime)
     }
     
     private func attachListeners() {
@@ -195,24 +183,24 @@ class THEOplayerRCTNowPlayingManager {
         }
         
         // PLAYING
-        self.playingListener = player.addEventListener(type: PlayerEventTypes.PLAYING) { [weak self] event in
-            self?.updatePlaybackState()
-            self?.updateCurrentTime { [weak self] in
-                if let welf = self {
-                    if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] PLAYING: Updating playbackState and time on NowPlayingInfoCenter...") }
-                    welf.processNowPlayingToInfoCenter()
-                }
+        self.playingListener = player.addEventListener(type: PlayerEventTypes.PLAYING) { [weak self, weak player] event in
+            if let welf = self,
+               let wplayer = player {
+                welf.updatePlaybackState()
+                welf.updateCurrentTime(wplayer.currentTime)
+                if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] PLAYING: Updating playbackState and time on NowPlayingInfoCenter...") }
+                welf.processNowPlayingToInfoCenter()
             }
         }
         
         // PAUSE
-        self.pauseListener = player.addEventListener(type: PlayerEventTypes.PAUSE) { [weak self] event in
-            self?.updatePlaybackState()
-            self?.updateCurrentTime { [weak self] in
-                if let welf = self {
-                    if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] PAUSED: Updating PlaybackState and time on NowPlayingInfoCenter...") }
-                    welf.processNowPlayingToInfoCenter()
-                }
+        self.pauseListener = player.addEventListener(type: PlayerEventTypes.PAUSE) { [weak self, weak player] event in
+            if let welf = self,
+               let wplayer = player {
+                welf.updatePlaybackState()
+                welf.updateCurrentTime(wplayer.currentTime)
+                if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] PAUSED: Updating PlaybackState and time on NowPlayingInfoCenter...") }
+                welf.processNowPlayingToInfoCenter()
             }
         }
                                           
@@ -228,12 +216,12 @@ class THEOplayerRCTNowPlayingManager {
         }
         
         // SEEKED
-        self.seekedListener = player.addEventListener(type: PlayerEventTypes.SEEKED) { [weak self] event in
-            self?.updateCurrentTime { [weak self] in
-                if let welf = self {
-                    if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] SEEKED: Time updated on NowPlayingInfoCenter.") }
-                    welf.processNowPlayingToInfoCenter()
-                }
+        self.seekedListener = player.addEventListener(type: PlayerEventTypes.SEEKED) { [weak self, weak player] event in
+            if let welf = self,
+               let wplayer = player {
+                welf.updateCurrentTime(wplayer.currentTime)
+                if DEBUG_NOWINFO { PrintUtils.printLog(logText: "[NATIVE] SEEKED: Time updated on NowPlayingInfoCenter.") }
+                welf.processNowPlayingToInfoCenter()
             }
         }
         

package/ios/backgroundAudio/THEOplayerRCTRemoteCommandsManager.swift

@@ -153,11 +153,7 @@ class THEOplayerRCTRemoteCommandsManager: NSObject {
         if let player = self.player,
            !self.isLive,
            !self.inAd {
-            player.requestCurrentTime(completionHandler: { time, error in
-                if let currentTime = time {
-                    player.setCurrentTime(currentTime + event.interval)
-                }
-            })
+            player.currentTime = player.currentTime + event.interval
             if DEBUG_REMOTECOMMANDS { PrintUtils.printLog(logText: "[NATIVE] Skip forward command handled.") }
         } else {
             if DEBUG_REMOTECOMMANDS { PrintUtils.printLog(logText: "[NATIVE] Skip forward command not handled.") }
@@ -169,11 +165,7 @@ class THEOplayerRCTRemoteCommandsManager: NSObject {
         if let player = self.player ,
            !self.isLive,
            !self.inAd {
-            player.requestCurrentTime(completionHandler: { time, error in
-                if let currentTime = time {
-                    player.setCurrentTime(currentTime - event.interval)
-                }
-            })
+            player.currentTime = player.currentTime - event.interval
             if DEBUG_REMOTECOMMANDS { PrintUtils.printLog(logText: "[NATIVE] Skip backward command handled.") }
         } else {
             if DEBUG_REMOTECOMMANDS { PrintUtils.printLog(logText: "[NATIVE] Skip backward command not handled.") }

package/ios/cache/THEOplayerRCTCacheAPI.swift

@@ -0,0 +1,203 @@
+//
+//  THEOplayerRCTCacheAPI.swift
+//  Theoplayer
+//
+//  Created by William Van Haevre on 01/08/2023.
+//
+
+import Foundation
+import UIKit
+import THEOplayerSDK
+
+let CACHE_EVENT_PROP_STATUS: String = "status"
+let CACHE_EVENT_PROP_PROGRESS: String = "progress"
+let CACHE_EVENT_PROP_TASK: String = "task"
+let CACHE_EVENT_PROP_TASKS: String = "tasks"
+
+let CACHE_TAG: String = "[CacheAPI]"
+
+@objc(THEOplayerRCTCacheAPI)
+class THEOplayerRCTCacheAPI: RCTEventEmitter {
+    // MARK: Cache Listeners
+    private var cacheStatusListener: EventListener?
+    
+    // MARK: CacheTask listeners (attached dynamically to new tasks)
+    private var taskStateChangeListeners: [String:EventListener] = [:] // key is CacheTask.id
+    private var taskProgressListeners: [String:EventListener] = [:] // key is CacheTask.id
+    
+    override static func moduleName() -> String! {
+        return "CacheModule"
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return [
+            "onCacheStatusChange",
+            "onAddCachingTaskEvent",
+            "onRemoveCachingTaskEvent",
+            "onCachingTaskProgressEvent",
+            "onCachingTaskStatusChangeEvent"
+        ]
+    }
+    
+    override init() {
+        super.init()
+        
+        // attach listeners
+        self.attachCacheListeners()
+    }
+    
+    deinit {
+        self.detachCacheListeners()
+    }
+    
+    // MARK: - attach/dettach cache Listeners
+    private func attachCacheListeners() {
+        // STATE_CHANGE
+        self.cacheStatusListener = THEOplayer.cache.addEventListener(type: CacheEventTypes.STATE_CHANGE) { [weak self] event in
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received STATE_CHANGE event from THEOplayer.cache") }
+            self?.sendEvent(withName: "onCacheStatusChange", body: [
+                CACHE_EVENT_PROP_STATUS: THEOplayerRCTTypeUtils.cacheStatusToString(THEOplayer.cache.status)
+            ])
+        }
+        if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] StateChange listener attached to THEOplayer.cache") }
+        
+        // Attach listeners to all task currently known to cache
+        for cachingTask in THEOplayer.cache.tasks {
+            self.attachTaskListenersToTask(cachingTask)
+        }
+    }
+    
+    private func detachCacheListeners() {
+        // STATE_CHANGE
+        if let cacheStatusListener = self.cacheStatusListener {
+            THEOplayer.cache.removeEventListener(type: CacheEventTypes.STATE_CHANGE, listener: cacheStatusListener)
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] StateChange listener dettached from THEOplayer.cache") }
+        }
+    }
+    
+    private func attachTaskListenersToTask(_ newTask: CachingTask) {
+        // add STATE_CHANGE listeners to newly created task
+        self.taskStateChangeListeners[newTask.id] = newTask.addEventListener(type: CachingTaskEventTypes.STATE_CHANGE) { [weak self] event in
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received STATE_CHANGE event for task with id \(newTask.id): status is \(THEOplayerRCTTypeUtils.cachingTaskStatusToString(newTask.status))") }
+            self?.sendEvent(withName: "onCachingTaskStatusChangeEvent", body: [
+                CACHETASK_PROP_ID: newTask.id,
+                CACHE_EVENT_PROP_STATUS: THEOplayerRCTTypeUtils.cachingTaskStatusToString(newTask.status)
+            ])
+            
+            if let errorEvent = event as? CachingTaskErrorStateChangeEvent,
+               let error = errorEvent.error {
+                if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] STATE_CHANGE_ERROR event for task with id \(newTask.id): [error] \(error.code):\(error.category) - \(error.message)") }
+            } else if let idleEvent = event as? CachingTaskIdleStateChangeEvent {
+                if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] STATE_CHANGE_IDLE event for task with id \(newTask.id): [reason] \(THEOplayerRCTTypeUtils.cacheStatusIdleReasonToString(idleEvent.idleReason))") }
+            }
+        }
+        if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] StateChange listener attached to task with id \(newTask.id).") }
+        
+        // add PROGRESS listeners to newly created task
+        self.taskProgressListeners[newTask.id] = newTask.addEventListener(type: CachingTaskEventTypes.PROGRESS) { [weak self] event in
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PROGRESS event from task with id \(newTask.id): progress is \(newTask.percentageCached * 100.0)% of \(newTask.duration) sec.") }
+            self?.sendEvent(withName: "onCachingTaskProgressEvent", body: [
+                CACHETASK_PROP_ID: newTask.id,
+                CACHE_EVENT_PROP_PROGRESS: THEOplayerRCTCacheAggregator.aggregateCacheTaskProgress(task: newTask)
+            ] as [String : Any])
+        }
+        if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Progress listener attached to task with id \(newTask.id).") }
+    }
+    
+    private func detachTaskListenersFromTask(_ task: CachingTask) {
+        // STATE_CHANGE
+        if let taskStateChangeListener = self.taskStateChangeListeners[task.id] {
+            task.removeEventListener(type: CachingTaskEventTypes.STATE_CHANGE, listener: taskStateChangeListener)
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] StateChange listener dettached from task with id \(task.id)") }
+        }
+        // PROGRESS
+        if let taskProgressListener = self.taskProgressListeners[task.id] {
+            task.removeEventListener(type: CachingTaskEventTypes.PROGRESS, listener: taskProgressListener)
+            if DEBUG_CACHE_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Progress listener dettached from task with id \(task.id)") }
+        }
+    }
+    
+    // MARK: API
+    
+    @objc(getInitialState:rejecter:)
+    func getInitialState(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        resolve([
+            CACHE_EVENT_PROP_STATUS: THEOplayerRCTTypeUtils.cacheStatusToString(THEOplayer.cache.status),
+            CACHE_EVENT_PROP_TASKS: THEOplayerRCTCacheAggregator.aggregateCacheTasks(tasks: THEOplayer.cache.tasks)
+        ] as [String : Any])
+    }
+    
+    @objc(createTask:params:)
+    func createTask(_ src: NSDictionary, params: NSDictionary) -> Void {
+        if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] createTask triggered on Cache API.") }
+		let params = THEOplayerRCTCachingParametersBuilder.buildCachingParameters(params)
+		let (sourceDescription, _) = THEOplayerRCTSourceDescriptionBuilder.buildSourceDescription(src)
+		if let srcDescription = sourceDescription,
+		   let newTask = THEOplayer.cache.createTask(source: srcDescription, parameters: params) {
+            if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] New cache task created with id \(newTask.id)") }
+            
+            // emit onAddCachingTaskEvent
+            self.sendEvent(withName: "onAddCachingTaskEvent", body: [
+                CACHE_EVENT_PROP_TASK: THEOplayerRCTCacheAggregator.aggregateCacheTask(task: newTask)
+            ])
+            
+            // attach the state and progress listeners to the new task
+            self.attachTaskListenersToTask(newTask)
+        }
+    }
+    
+    @objc(startCachingTask:)
+    func startCachingTask(_ id: NSString) -> Void {
+        if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Start task triggered on Cache API for task with id \(id).") }
+        if let task = self.taskById(id as String) {
+            task.start()
+        }
+    }
+    
+    @objc(pauseCachingTask:)
+    func pauseCachingTask(_ id: NSString) -> Void {
+        if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Pause task triggered on Cache API for task with id \(id).") }
+        if let task = self.taskById(id as String) {
+            task.pause()
+        }
+    }
+    
+    @objc(removeCachingTask:)
+    func removeCachingTask(_ id: NSString) -> Void {
+        if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Remove task triggered on Cache API for task with id \(id).") }
+        if let task = self.taskById(id as String) {
+            // remove the task
+            task.remove()
+            // remove the listeners
+            self.detachTaskListenersFromTask(task)
+        }
+    }
+    
+    @objc(renewLicense:drmConfig:)
+    func renewLicense(_ id: NSString, drmConfig: NSDictionary) -> Void {
+        if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Renew license triggered on Cache API for task with id \(id).") }
+        if let task = self.taskById(id as String) {
+            guard let contentProtectionData = drmConfig as? [String:Any] else {
+                if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Renew license failed for task with id \(id): Unable to extract drm configuration data.") }
+                return
+            }
+            let sanitisedContentProtectionData = THEOplayerRCTSourceDescriptionBuilder.sanitiseContentProtectionData(contentProtectionData)
+            if let contentProtectionConfig = THEOplayerRCTSourceDescriptionBuilder.buildContentProtection(sanitisedContentProtectionData) {
+                task.license.renew(contentProtectionConfig)
+                if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] License renewed for task with id \(id).") }
+            } else {
+                if DEBUG_CACHE_API { PrintUtils.printLog(logText: "[NATIVE] Renew license failed for task with id \(id): Invalid contentProtection input.") }
+            }
+        }
+    }
+    
+    private func taskById(_ id: String) -> CachingTask? {
+        return THEOplayer.cache.tasks.first {
+            cachingTask in cachingTask.id == id
+        }
+    }
+}

package/ios/cache/THEOplayerRCTCacheAggregator.swift

@@ -0,0 +1,87 @@
+// THEOplayerRCTContentProtectionAggregator.swift
+
+import Foundation
+import THEOplayerSDK
+
+let CACHETASK_PROP_ID: String = "id"
+let CACHETASK_PROP_STATUS: String = "status"
+let CACHETASK_PROP_SOURCE: String = "source"
+let CACHETASK_PROP_PARAMETERS: String = "parameters"
+let CACHETASK_PROP_DURATION: String = "duration"
+let CACHETASK_PROP_CACHED: String = "cached"
+let CACHETASK_PROP_SECONDS_CACHED: String = "secondsCached"
+let CACHETASK_PROP_PERCENTAGE_CACHED: String = "percentageCached"
+let CACHETASK_PROP_BYTES: String = "bytes"
+let CACHETASK_PROP_BYTES_CACHED: String = "bytesCached"
+let CACHETASK_PROP_PARAMETERS_AMOUNT: String = "amount"
+let CACHETASK_PROP_PARAMETERS_BANDWIDTH: String = "bandwidth"
+let CACHETASK_PROP_PARAMETERS_EXPIRATION_DATE: String = "expirationDate"
+let CACHETASK_PROP_TIMERANGE_START: String = "start"
+let CACHETASK_PROP_TIMERANGE_END: String = "end"
+let CACHETASK_PROP_PARAMETERS_CELLULAR: String = "allowsCellularAccess"
+let CACHETASK_PROP_PARAMETERS_TRACK_SELECTION: String = "preferredTrackSelection"
+let CACHETASK_PROP_PARAMETERS_AUDIO_TRACK_SELECTION: String = "audioTrackSelection"
+let CACHETASK_PROP_PARAMETERS_TEXT_TRACK_SELECTION: String = "textTrackSelection"
+
+let CACHE_AGGREGATOR_TAG: String = "[CacheAggregator]"
+
+class THEOplayerRCTCacheAggregator {
+    
+    class func aggregateCacheTasks(tasks: [CachingTask]) -> [[String:Any]] {
+        var aggregatedData: [[String:Any]] = []
+        tasks.forEach { task in
+            aggregatedData.append(THEOplayerRCTCacheAggregator.aggregateCacheTask(task: task))
+        }
+        return aggregatedData
+    }
+    
+    class func aggregateCacheTask(task: CachingTask) -> [String:Any] {
+        var aggregatedData: [String:Any] = [:]
+        aggregatedData[CACHETASK_PROP_ID] = task.id
+        aggregatedData[CACHETASK_PROP_STATUS] = THEOplayerRCTTypeUtils.cachingTaskStatusToString(task.status)
+        aggregatedData[CACHETASK_PROP_PARAMETERS] = THEOplayerRCTCacheAggregator.aggregateCacheTaskParameters(params: task.parameters)
+        aggregatedData[CACHETASK_PROP_SOURCE] = THEOplayerRCTSourceDescriptionAggregator.aggregateCacheTaskSourceDescription(sourceDescription: task.source)
+        for (key, value) in THEOplayerRCTCacheAggregator.aggregateCacheTaskProgress(task: task) {
+            aggregatedData[key] = value
+        }
+        return aggregatedData
+    }
+                                                     
+    class func aggregateCacheTaskProgress(task: CachingTask) -> [String:Any] {
+        var aggregatedData: [String:Any] = [:]
+        aggregatedData[CACHETASK_PROP_DURATION] = task.duration // in sec
+        aggregatedData[CACHETASK_PROP_CACHED] = THEOplayerRCTCacheAggregator.aggregateCachedTimeRanges(ranges: task.cached)
+        aggregatedData[CACHETASK_PROP_SECONDS_CACHED] = task.secondsCached
+        aggregatedData[CACHETASK_PROP_PERCENTAGE_CACHED] = task.percentageCached
+        aggregatedData[CACHETASK_PROP_BYTES] = -1 // default setting, as iOS does not provide estimate yet.
+        aggregatedData[CACHETASK_PROP_BYTES_CACHED] = task.bytesCached
+        return aggregatedData
+        
+    }
+    
+    private class func aggregateCacheTaskParameters(params: CachingParameters) -> [String:Any] {
+        var aggregatedData: [String:Any] = [:]
+        aggregatedData[CACHETASK_PROP_PARAMETERS_AMOUNT] = "100%"
+        if let bandwidthValue = params.bandwidth {
+            aggregatedData[CACHETASK_PROP_PARAMETERS_BANDWIDTH] = bandwidthValue
+        }
+        aggregatedData[CACHETASK_PROP_PARAMETERS_EXPIRATION_DATE] = params.expirationDate.timeIntervalSince1970 * 1000 // sec -> msec
+        aggregatedData[CACHETASK_PROP_PARAMETERS_CELLULAR] = params.allowsCellularAccess
+        aggregatedData[CACHETASK_PROP_PARAMETERS_TRACK_SELECTION] = [
+            CACHETASK_PROP_PARAMETERS_AUDIO_TRACK_SELECTION : params.preferredTrackSelection.audioTrackSelection,
+            CACHETASK_PROP_PARAMETERS_TEXT_TRACK_SELECTION: params.preferredTrackSelection.textTrackSelection
+        ]
+        return aggregatedData
+    }
+    
+    private class func aggregateCachedTimeRanges(ranges: [TimeRange]) -> [[String:Any]] {
+        var aggregatedData: [[String:Any]] = []
+        for timeRange in ranges {
+            aggregatedData.append([
+                CACHETASK_PROP_TIMERANGE_START : timeRange.start * 1000, // sec -> msec
+                CACHETASK_PROP_TIMERANGE_END : timeRange.end * 1000 // sec -> msec
+            ])
+        }
+        return aggregatedData
+    }
+}