react-native-theoplayer 2.16.1 → 3.0.0

package/android/src/main/java/com/theoplayer/cache/CacheModule.kt

@@ -0,0 +1,238 @@
+@file:Suppress("unused")
+
+package com.theoplayer.cache
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.gson.Gson
+import com.theoplayer.util.ViewResolver
+import com.theoplayer.android.api.THEOplayerGlobal
+import com.theoplayer.android.api.cache.Cache
+import com.theoplayer.android.api.cache.CachingTask
+import com.theoplayer.android.api.event.EventListener
+import com.theoplayer.android.api.event.cache.CacheEventTypes
+import com.theoplayer.android.api.event.cache.task.CachingTaskErrorEvent
+import com.theoplayer.android.api.event.cache.task.CachingTaskEventTypes
+import com.theoplayer.android.api.event.cache.task.CachingTaskProgressEvent
+import com.theoplayer.android.api.event.cache.task.CachingTaskStateChangeEvent
+import com.theoplayer.android.api.event.cache.tasklist.CachingTaskListEventTypes
+import com.theoplayer.drm.ContentProtectionAdapter
+import com.theoplayer.source.SourceAdapter
+import org.json.JSONException
+import org.json.JSONObject
+
+private const val TAG = "CacheModule"
+
+private const val PROP_STATUS = "status"
+private const val PROP_ID = "id"
+private const val PROP_TASK = "task"
+private const val PROP_TASKS = "tasks"
+private const val PROP_PROGRESS = "progress"
+private const val PROP_ERROR = "error"
+
+class CacheModule(private val context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+  private val viewResolver: ViewResolver = ViewResolver(context)
+  private val onTaskProgress = mutableMapOf<String, EventListener<CachingTaskProgressEvent>>()
+  private val onTaskError = mutableMapOf<String, EventListener<CachingTaskErrorEvent>>()
+  private val onTaskStateChange = mutableMapOf<String, EventListener<CachingTaskStateChangeEvent>>()
+  private val sourceAdapter = SourceAdapter()
+  private val cache: Cache?
+    get() = THEOplayerGlobal.getSharedInstance(context.applicationContext).cache
+  private val handler = Handler(Looper.getMainLooper())
+
+  init {
+    // Add cache event listeners
+    cache?.apply {
+      // Listen for cache state changes
+      addEventListener(CacheEventTypes.CACHE_STATE_CHANGE) { event ->
+        emit("onCacheStatusChange", Arguments.createMap().apply {
+          putString(PROP_STATUS, CacheAdapter.fromCacheStatus(event.status))
+        })
+      }
+      // Listen for add task events
+      tasks.addEventListener(CachingTaskListEventTypes.ADD_TASK) { event ->
+        event.task?.let { task ->
+          // Notify AddCachingTaskEvent event
+          emit("onAddCachingTaskEvent", Arguments.createMap().apply {
+            putMap(PROP_TASK, CacheAdapter.fromCachingTask(task))
+          })
+          // Add CachingTask listeners
+          addCachingTaskListeners(task)
+        }
+      }
+
+      // Listen for task removal
+      tasks.addEventListener(CachingTaskListEventTypes.REMOVE_TASK) { event ->
+        event.task?.let { task ->
+          // Notify RemoveCachingTaskEvent event
+          emit("onRemoveCachingTaskEvent", Arguments.createMap().apply {
+            putMap(PROP_TASK, CacheAdapter.fromCachingTask(event.task))
+          })
+          // Remove CachingTask listeners
+          removeCachingTaskListeners(task)
+        }
+      }
+    }
+  }
+
+  override fun getName(): String {
+    return TAG
+  }
+
+  private fun addCachingTaskListeners(task: CachingTask) {
+    // Listen for task progress
+    onTaskProgress[task.id] = EventListener<CachingTaskProgressEvent> { progressEvent ->
+      emit("onCachingTaskProgressEvent", Arguments.createMap().apply {
+        putString(PROP_ID, task.id)
+        putMap(PROP_PROGRESS, CacheAdapter.fromCachingTaskProgress(progressEvent.progress))
+      })
+    }.also { listener ->
+      task.addEventListener(CachingTaskEventTypes.CACHING_TASK_PROGRESS, listener)
+    }
+
+    // Listen for task errors
+    onTaskError[task.id] = EventListener<CachingTaskErrorEvent> { errorEvent ->
+      emit("onCachingTaskErrorEvent", Arguments.createMap().apply {
+        putString(PROP_ID, task.id)
+        putString(PROP_ERROR, errorEvent.error.description)
+      })
+    }.also { listener ->
+      task.addEventListener(CachingTaskEventTypes.CACHING_TASK_ERROR, listener)
+    }
+
+    // Listen for task state changes
+    onTaskStateChange[task.id] = EventListener<CachingTaskStateChangeEvent> { changeEvent ->
+      emit("onCachingTaskStatusChangeEvent", Arguments.createMap().apply {
+        putString(PROP_ID, task.id)
+        putString(PROP_STATUS, CacheAdapter.fromCacheTaskStatus(changeEvent.status))
+      })
+    }.also { listener ->
+      task.addEventListener(CachingTaskEventTypes.CACHING_TASK_STATE_CHANGE, listener)
+    }
+  }
+
+  private fun removeCachingTaskListeners(task: CachingTask) {
+    onTaskProgress[task.id]?.apply {
+      task.removeEventListener(CachingTaskEventTypes.CACHING_TASK_PROGRESS, this)
+    }
+    onTaskProgress.remove(task.id)
+    onTaskError[task.id]?.apply {
+      task.removeEventListener(CachingTaskEventTypes.CACHING_TASK_ERROR, this)
+    }
+    onTaskError.remove(task.id)
+    onTaskStateChange[task.id]?.apply {
+      task.removeEventListener(CachingTaskEventTypes.CACHING_TASK_STATE_CHANGE, this)
+    }
+    onTaskStateChange.remove(task.id)
+  }
+
+  private fun emit(
+    eventName: String,
+    payload: WritableMap
+  ) {
+    // Make sure we are not emitting before React has been setup.
+    if (!context.hasActiveReactInstance()) {
+      return
+    }
+
+    context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, payload)
+  }
+
+  @ReactMethod
+  fun getInitialState(promise: Promise) {
+    handler.post {
+      cache?.apply {
+
+        // Add listeners to existing tasks
+        tasks.forEach { task ->
+          addCachingTaskListeners(task)
+        }
+
+        promise.resolve(Arguments.createMap().apply {
+          putString(PROP_STATUS, CacheAdapter.fromCacheStatus(status))
+          putArray(PROP_TASKS, CacheAdapter.fromCachingTaskList(tasks))
+        })
+      }
+    }
+  }
+
+  @ReactMethod
+  fun createTask(source: ReadableMap, parameters: ReadableMap) {
+    val sourceDescription = sourceAdapter.parseSourceFromJS(source)
+    if (sourceDescription != null) {
+      handler.post {
+        cache?.createTask(
+          sourceDescription,
+          CacheAdapter.parseCachingParameters(parameters)
+        )
+      }
+    }
+  }
+
+  @ReactMethod
+  fun pauseCachingTask(id: String) {
+    handler.post {
+      cache?.tasks?.getTaskById(id)?.pause()
+    }
+  }
+
+  @ReactMethod
+  fun removeCachingTask(id: String) {
+    handler.post {
+      cache?.tasks?.getTaskById(id)?.remove()
+    }
+  }
+
+  @ReactMethod
+  fun startCachingTask(id: String) {
+    handler.post {
+      cache?.tasks?.getTaskById(id)?.start()
+    }
+  }
+
+  @ReactMethod
+  fun renewLicense(id: String, drmConfiguration: ReadableMap?) {
+    handler.post {
+      if (drmConfiguration == null) {
+        taskById(id)?.license()?.renew()
+      } else {
+        try {
+          val drmConfigurationJson = JSONObject(Gson().toJson(drmConfiguration.toHashMap()))
+          taskById(id)?.license()
+            ?.renew(ContentProtectionAdapter.drmConfigurationFromJson(drmConfigurationJson))
+        } catch (e: JSONException) {
+          e.printStackTrace()
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  @Suppress("UNUSED_PARAMETER")
+  fun addListener(eventName: String?) {
+  }
+
+  @ReactMethod
+  @Suppress("UNUSED_PARAMETER")
+  fun removeListeners(count: Int?) {
+  }
+
+  private fun taskById(id: String): CachingTask? {
+    return cache?.tasks?.getTaskById(id) ?: run {
+      Log.w(TAG, "CachingTask with id $id not found")
+      return null
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/player/PlayerModule.kt

@@ -11,9 +11,7 @@ import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality
 import com.theoplayer.android.api.player.track.texttrack.TextTrackMode
 import com.theoplayer.audio.BackgroundAudioConfigAdapter
 import com.theoplayer.presentation.PipConfigAdapter
-import com.theoplayer.track.QualityListFilter
 import com.theoplayer.track.TextTrackStyleAdapter
-import com.theoplayer.track.emptyQualityList
 import com.theoplayer.util.ViewResolver
 
 private const val TAG = "PlayerModule"
@@ -120,22 +118,39 @@ class PlayerModule(context: ReactApplicationContext) : ReactContextBaseJavaModul
     }
   }
 
+  /**
+   * Check whether a uid is contained in an array of uids.
+   */
+  private fun containsUid(uid: Int, uids: ReadableArray): Boolean {
+    for (q in 0 until uids.size()) {
+      if (uids.getInt(q) == uid) {
+        return true
+      }
+    }
+    return false
+  }
+
   @ReactMethod
   fun setTargetVideoQuality(tag: Int, uids: ReadableArray) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
       view?.player?.let {
         // Apply the target quality to the current enabled video track
         for (track in it.videoTracks) {
-          if (track.isEnabled) {
-            val currentVideoTrack = track as MediaTrack<VideoQuality>
-            if (uids.size() == 0) {
-              // Reset target qualities when passing empty list.
-              currentVideoTrack.targetQualities = emptyQualityList()
-              currentVideoTrack.targetQuality = null
-            } else {
-              currentVideoTrack.qualities?.let { qualities ->
-                currentVideoTrack.targetQualities = QualityListFilter(qualities).filterQualityList(uids)
-              }
+          // Only consider enabled tracks
+          if (!track.isEnabled) {
+            continue
+          }
+          val currentVideoTrack = track as MediaTrack<VideoQuality>
+          if (uids.size() == 0) {
+            // Reset target qualities when passing empty list.
+            currentVideoTrack.setTargetQualities(listOf())
+            currentVideoTrack.targetQuality = null
+          } else {
+            // Filter qualities based on target uids
+            currentVideoTrack.qualities?.let { availableQualities ->
+              currentVideoTrack.setTargetQualities(availableQualities.filter { quality ->
+                containsUid(quality.uid, uids)
+              })
             }
           }
         }

package/android/src/main/java/com/theoplayer/source/SourceAdapter.kt

@@ -2,9 +2,12 @@ package com.theoplayer.source
 
 import android.text.TextUtils
 import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.google.gson.Gson
 import com.theoplayer.android.api.error.THEOplayerException
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 import com.theoplayer.android.api.source.SourceDescription
 import com.theoplayer.android.api.source.TypedSource
 import com.theoplayer.android.api.source.metadata.MetadataDescription
@@ -15,17 +18,16 @@ import com.theoplayer.android.api.source.ssai.SsaiIntegration
 import com.theoplayer.android.api.source.GoogleDaiTypedSource
 import com.theoplayer.android.api.source.ssai.dai.GoogleDaiVodConfiguration
 import com.theoplayer.android.api.source.ssai.dai.GoogleDaiLiveConfiguration
-import com.theoplayer.android.api.source.ssai.YoSpaceDescription
 import com.theoplayer.android.api.source.hls.HlsPlaybackConfiguration
 import com.theoplayer.android.api.event.ads.AdIntegrationKind
 import com.theoplayer.android.api.source.addescription.GoogleImaAdDescription
 import com.theoplayer.android.api.player.track.texttrack.TextTrackKind
 import com.theoplayer.android.api.source.metadata.ChromecastMetadataImage
-import com.facebook.react.bridge.ReadableArray
 import com.theoplayer.BuildConfig
 import com.theoplayer.android.api.error.ErrorCode
 import com.theoplayer.android.api.source.dash.DashPlaybackConfiguration
 import com.theoplayer.drm.ContentProtectionAdapter
+import com.theoplayer.util.BridgeUtils
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
@@ -38,6 +40,7 @@ private const val PROP_LIVE_OFFSET = "liveOffset"
 private const val PROP_HLS_DATERANGE = "hlsDateRange"
 private const val PROP_HLS_PLAYBACK_CONFIG = "hls"
 private const val PROP_TIME_SERVER = "timeServer"
+private const val PROP_DATA = "data"
 private const val PROP_METADATA = "metadata"
 private const val PROP_SSAI = "ssai"
 private const val PROP_TYPE = "type"
@@ -69,10 +72,8 @@ class SourceAdapter {
     if (source == null) {
       return null
     }
-    val hashmap = eliminateReadables(source)
     try {
-      val json = gson.toJson(hashmap)
-      val jsonSourceObject = JSONObject(json)
+      val jsonSourceObject = JSONObject(gson.toJson(source.toHashMap()))
 
       // typed sources
       val typedSources = ArrayList<TypedSource>()
@@ -174,9 +175,6 @@ class SourceAdapter {
                 tsBuilder.type(SourceType.DASH)
               }
             }
-            SsaiIntegration.YOSPACE -> tsBuilder.ssai(
-              gson.fromJson(ssaiJson.toString(), YoSpaceDescription::class.java)
-            )
             else -> throw THEOplayerException(
               ErrorCode.AD_ERROR,
               "$ERROR_UNSUPPORTED_SSAI_INTEGRATION: $ssaiIntegrationStr"
@@ -225,9 +223,8 @@ class SourceAdapter {
 
   @Throws(THEOplayerException::class)
   fun parseAdFromJS(map: ReadableMap): AdDescription? {
-    val hashmap = eliminateReadables(map)
     return try {
-      val jsonAdDescription = JSONObject(gson.toJson(hashmap))
+      val jsonAdDescription = JSONObject(gson.toJson(map.toHashMap()))
       parseAdFromJS(jsonAdDescription)
     } catch (e: JSONException) {
       e.printStackTrace()
@@ -283,7 +280,7 @@ class SourceAdapter {
         AdIntegrationKind.GOOGLE_IMA -> parseImaAdFromJS(
           jsonAdDescription
         )
-        AdIntegrationKind.DEFAULT, AdIntegrationKind.THEO, AdIntegrationKind.FREEWHEEL, AdIntegrationKind.SPOTX -> {
+        AdIntegrationKind.DEFAULT -> {
           throw THEOplayerException(
             ErrorCode.AD_ERROR,
             "$ERROR_UNSUPPORTED_CSAI_INTEGRATION: $integrationKindStr"
@@ -386,33 +383,15 @@ class SourceAdapter {
     return ChromecastMetadataImage(metadataImage.optString("src"), width, height)
   }
 
-  private fun eliminateReadables(readableMap: ReadableMap): HashMap<String, Any> {
-    val hashMap = readableMap.toHashMap()
-    val eliminatedHashMap = HashMap<String, Any>()
-    for (entry in hashMap.entries) {
-      var value = entry.value
-      if (value is ReadableMap) {
-        value = eliminateReadables(value)
-      } else if (value is ReadableArray) {
-        value = eliminateReadables(value)
-      }
-      eliminatedHashMap[entry.key] = value
-    }
-    return eliminatedHashMap
-  }
+  fun fromSourceDescription(source: SourceDescription): WritableMap {
+    val json = JSONObject(gson.toJson(source))
 
-  private fun eliminateReadables(readableArray: ReadableArray): ArrayList<Any> {
-    val arrayList = readableArray.toArrayList()
-    val eliminatedArrayList = ArrayList<Any>()
-    for (o in arrayList) {
-      var value = o
-      if (value is ReadableMap) {
-        value = eliminateReadables(value)
-      } else if (value is ReadableArray) {
-        value = eliminateReadables(value)
-      }
-      eliminatedArrayList.add(value)
+    // Normalize metadata
+    // The player SDK adds an extra 'data' level within metadata: flatten.
+    json.optJSONObject(PROP_METADATA)?.optJSONObject(PROP_DATA)?.let { newMetadata ->
+      json.put(PROP_METADATA, newMetadata)
     }
-    return eliminatedArrayList
+
+    return BridgeUtils.fromJSONObjectToBridge(json)
   }
 }

package/android/src/main/java/com/theoplayer/util/BridgeUtils.kt

@@ -0,0 +1,60 @@
+package com.theoplayer.util
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+object BridgeUtils {
+  /**
+   * Convert a JSONObject to bridge data.
+   */
+  fun fromJSONObjectToBridge(json: JSONObject): WritableMap {
+    return Arguments.createMap().apply {
+      try {
+        val iterator = json.keys()
+        while (iterator.hasNext()) {
+          val key = iterator.next()
+          when (val value = json.opt(key)) {
+//            null -> putNull(key)
+            is Boolean -> putBoolean(key, value)
+            is Int -> putInt(key, value)
+            is Double -> putDouble(key, value)
+            is String -> putString(key, value)
+            is JSONObject -> putMap(key, fromJSONObjectToBridge(value))
+            is JSONArray -> putArray(key, fromJSONArrayToBridge(value))
+            // Add other cases if needed for custom data types
+          }
+        }
+      } catch (e: JSONException) {
+        e.printStackTrace()
+      }
+    }
+  }
+
+  /**
+   * Convert a JSONArray to bridge data.
+   */
+  fun fromJSONArrayToBridge(jsonArray: JSONArray): WritableArray {
+    return Arguments.createArray().apply {
+      try {
+        for (i in 0 until jsonArray.length()) {
+          when (val value = jsonArray.opt(i)) {
+//        null -> writableArray.pushNull()
+            is Boolean -> pushBoolean(value)
+            is Int -> pushInt(value)
+            is Double -> pushDouble(value)
+            is String -> pushString(value)
+            is JSONObject -> pushMap(fromJSONObjectToBridge(value))
+            is JSONArray -> pushArray(fromJSONArrayToBridge(value))
+            // Add other cases if needed for custom data types
+          }
+        }
+      } catch (e: JSONException) {
+        e.printStackTrace()
+      }
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/util/PayloadBuilder.kt

@@ -226,18 +226,18 @@ class PayloadBuilder {
     payload.putMap(EVENT_PROP_QUALITIES, TrackListAdapter.fromQuality(quality))
   }
 
-  private fun fromTimeRanges(timeRanges: TimeRanges?): WritableArray {
-    val payload = Arguments.createArray()
-    timeRanges?.forEach { timeRange ->
-      val range = Arguments.createMap()
-      range.putDouble(EVENT_PROP_START, 1e03 * timeRange.start)
-      range.putDouble(EVENT_PROP_END, 1e03 * timeRange.end)
-      payload.pushMap(range)
-    }
+  fun build(): WritableMap {
     return payload
   }
+}
 
-  fun build(): WritableMap {
-    return payload
+fun fromTimeRanges(timeRanges: TimeRanges?): WritableArray {
+  val payload = Arguments.createArray()
+  timeRanges?.forEach { timeRange ->
+    val range = Arguments.createMap()
+    range.putDouble(EVENT_PROP_START, 1e03 * timeRange.start)
+    range.putDouble(EVENT_PROP_END, 1e03 * timeRange.end)
+    payload.pushMap(range)
   }
+  return payload
 }

package/ios/THEOplayerRCTBridge.m

@@ -217,3 +217,25 @@ RCT_EXTERN_METHOD(airplayStart:(nonnull NSNumber *)node)
 RCT_EXTERN_METHOD(airplayStop:(nonnull NSNumber *)node)
 
 @end
+
+// ----------------------------------------------------------------------------
+// Cache Module
+// ----------------------------------------------------------------------------
+@interface RCT_EXTERN_REMAP_MODULE(CacheModule, THEOplayerRCTCacheAPI, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(getInitialState:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createTask:(NSDictionary)src
+                  params:(NSDictionary)params)
+
+RCT_EXTERN_METHOD(startCachingTask:(nonnull NSString *)id)
+
+RCT_EXTERN_METHOD(pauseCachingTask:(nonnull NSString *)id)
+
+RCT_EXTERN_METHOD(removeCachingTask:(nonnull NSString *)id)
+
+RCT_EXTERN_METHOD(renewLicense:(nonnull NSString *)id
+                  drmConfig:(NSDictionary)drmConfig)
+
+@end

package/ios/THEOplayerRCTDebug.swift

@@ -4,7 +4,7 @@
 let DEBUG = true
 
 // Debug flag to monitor incoming Theoplayer events
-let DEBUG_THEOPLAYER_EVENTS = DEBUG && true
+let DEBUG_THEOPLAYER_EVENTS = DEBUG && false
 
 // Debug flag to monitor eventhandler setup and breakdown
 let DEBUG_EVENTHANDLER = DEBUG && false
@@ -38,3 +38,9 @@ let DEBUG_REMOTECOMMANDS = DEBUG && false
 
 // Debug flag to monitor PIP Controls updates
 let DEBUG_PIPCONTROLS = DEBUG && false
+
+// Debug flag to monitor incoming cache events
+let DEBUG_CACHE_EVENTS = DEBUG && true
+
+// Debug flag to monitor cache API usage
+let DEBUG_CACHE_API = DEBUG && true

package/ios/THEOplayerRCTMainEventHandler.swift

@@ -156,34 +156,32 @@ public class THEOplayerRCTMainEventHandler {
             //if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PROGRESS event from THEOplayer") }
             if let wplayer = player,
                let forwardedProgressEvent = self?.onNativeProgress {
-                wplayer.requestSeekable(completionHandler: { seekableTimeRanges, error in
-                    wplayer.requestBuffered(completionHandler: { bufferedTimeRanges, error in
-                        var seekable: [[String:Double]] = []
-                        seekableTimeRanges?.forEach({ timeRange in
-                            seekable.append(
-                                [
-                                    "start": timeRange.start * 1000,            // sec -> msec
-                                    "end": timeRange.end * 1000                 // sec -> msec
-                                ]
-                            )
-                        })
-                        var buffered: [[String:Double]] = []
-                        bufferedTimeRanges?.forEach({ timeRange in
-                            buffered.append(
-                                [
-                                    "start": timeRange.start * 1000,            // sec -> msec
-                                    "end": timeRange.end * 1000                 // sec -> msec
-                                ]
-                            )
-                        })
-                        forwardedProgressEvent(
-                            [
-                                "seekable":seekable,
-                                "buffered":buffered
-                            ]
-                        )
-                    })
+                let seekableTimeRanges = wplayer.seekable
+                let bufferedTimeRanges = wplayer.buffered
+                var seekable: [[String:Double]] = []
+                seekableTimeRanges.forEach({ timeRange in
+                    seekable.append(
+                        [
+                            "start": timeRange.start * 1000,            // sec -> msec
+                            "end": timeRange.end * 1000                 // sec -> msec
+                        ]
+                    )
+                })
+                var buffered: [[String:Double]] = []
+                bufferedTimeRanges.forEach({ timeRange in
+                    buffered.append(
+                        [
+                            "start": timeRange.start * 1000,            // sec -> msec
+                            "end": timeRange.end * 1000                 // sec -> msec
+                        ]
+                    )
                 })
+                forwardedProgressEvent(
+                    [
+                        "seekable":seekable,
+                        "buffered":buffered
+                    ]
+                )
             }
         }
         if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Progress listener attached to THEOplayer") }

package/ios/THEOplayerRCTSourceDescriptionAggregator.swift

@@ -0,0 +1,41 @@
+// THEOplayerRCTSourceDescriptionBuilder.swift
+
+import Foundation
+import THEOplayerSDK
+import UIKit
+
+class THEOplayerRCTSourceDescriptionAggregator {
+    class func aggregateCacheTaskSourceDescription(sourceDescription: SourceDescription) -> [String:Any]? {
+        do {
+            let jsonEncoder = JSONEncoder()
+            let data = try jsonEncoder.encode(sourceDescription)
+            if let result = try? JSONSerialization.jsonObject(with: data, options: []) as? [String:Any] {
+                return THEOplayerRCTSourceDescriptionAggregator.sanitiseSourceDescriptionMetadata(input: result)
+            }
+        } catch {
+            if DEBUG { PrintUtils.printLog(logText: "[NATIVE] Could not aggregate sourceDescription for caching task: \(error.localizedDescription)")}
+            return nil
+        }
+        return nil
+    }
+    
+    private class func sanitiseSourceDescriptionMetadata(input: [String:Any]) -> [String:Any] {
+        var output: [String:Any] = input
+        if let metadata = output[SD_PROP_METADATA] as? [String:Any],
+           let metadataKeys = metadata[SD_PROP_METADATAKEYS] as? [String:Any] {
+            var newMetadata: [String:Any] = [:]
+            // keep all but lower level metadataKeys
+            for (key, value) in metadata {
+                if (key != SD_PROP_METADATAKEYS) {
+                    newMetadata[key] = value
+                }
+            }
+            // now add metadataKeys at metadata level
+            for (key, value) in metadataKeys {
+                newMetadata[key] = value
+            }
+            output[SD_PROP_METADATA] = newMetadata
+        }
+        return output
+    }
+}