react-native-theoplayer 2.16.1 → 3.0.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [3.0.0] - 23-10-06
+
+### Fixed
+
+- Fixed sourceDescription processing on iOS for offline playback.
+
+### Changed
+
+- Added support for THEOplayer 6.0. See [THEOplayer's changelog](https://docs.theoplayer.com/changelog.md) for details.
+- Bumped minimal version for SideloadedTextTracks connection on iOS to v6.1.1 which contains fix for iOS 17.0.
+
+### Added
+
+- Added `MediaCache` API, enabling download of media assets for offline playback.
+
 ## [2.16.1] - 23-09-27
 
 ### Added

package/README.md

@@ -101,6 +101,7 @@ and discussed in the next section. Finally, an overview of features, limitations
   - [Casting with Chromecast and Airplay](./doc/cast.md)
   - [Custom iOS framework](./doc/custom-ios-framework.md)
   - [Digital Rights Management (DRM)](./doc/drm.md)
+  - [Media Caching](./doc/media_caching.md)
   - [Migrating to `react-native-theoplayer` v2.x](./doc/migrating_v2.md)
   - [Picture-in-Picture (PiP)](./doc/pip.md)
   - [Styling subtitles and closed captions](./doc/texttrackstyles.md)

package/android/build.gradle

@@ -29,11 +29,11 @@ def enabledCast = safeExtGet("THEOplayer_extensionCast", 'false').toBoolean()
 def enabledMediaSession = safeExtGet("THEOplayer_extensionMediaSession", 'true').toBoolean()
 
 android {
-  compileSdkVersion safeExtGet('THEOplayer_compileSdkVersion', 31)
+  compileSdk safeExtGet('THEOplayer_compileSdkVersion', 33)
 
   defaultConfig {
     minSdkVersion safeExtGet('THEOplayer_minSdkVersion', 21)
-    targetSdkVersion safeExtGet('THEOplayer_targetSdkVersion', 31)
+    targetSdkVersion safeExtGet('THEOplayer_targetSdkVersion', 33)
     versionCode 1
     versionName "1.0"
 
@@ -67,7 +67,7 @@ android {
       minifyEnabled false
     }
   }
-  lintOptions {
+  lint {
     disable 'GradleCompatible'
   }
   compileOptions {
@@ -102,20 +102,18 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
-  implementation "com.theoplayer.theoplayer-sdk-android:ads-wrapper:4.8.0"
-  implementation "androidx.appcompat:appcompat:1.4.+"
+  implementation "androidx.appcompat:appcompat:1.6.1"
 
-  // The minimum supported version is 5.10.0
-  def theoplayer_sdk_version = safeExtGet('THEOplayer_sdk', '[5.10,6.0)')
+  // The minimum supported THEOplayer version is 6.0.0
+  def theoplayer_sdk_version = safeExtGet('THEOplayer_sdk', '[6.0.0,7.0)')
 
 //  def theoplayer_mediasession_version = safeExtGet('THEOplayer_mediasession', theoplayer_sdk_version)
   def theoplayer_mediasession_version = "5.11.0-local"
-  def enabledV4 = theoplayer_sdk_version.toString().startsWith("4.")
-  def core_prefix = enabledV4 ? 'unified' : 'core'
-  def integration_prefix = enabledV4 ? 'unified' : 'integration'
 
   println("Using THEOplayer (${versionString(theoplayer_sdk_version)})")
-  implementation "com.theoplayer.theoplayer-sdk-android:${core_prefix}:${theoplayer_sdk_version}"
+  implementation "com.theoplayer.theoplayer-sdk-android:core:${theoplayer_sdk_version}"
+
+  implementation "com.theoplayer.theoplayer-sdk-android:ads-wrapper:4.8.0"
 
   if (enabledMediaSession) {
     println("Enable THEOplayer MediaSession extension (${versionString(theoplayer_mediasession_version)})")
@@ -127,30 +125,29 @@ dependencies {
 
   if (enabledGoogleIMA) {
     println('Enable THEOplayer IMA extension.')
-    implementation "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads:${theoplayer_sdk_version}"
-    implementation "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads-ima:${theoplayer_sdk_version}"
+    implementation "com.theoplayer.theoplayer-sdk-android:integration-ads:${theoplayer_sdk_version}"
+    implementation "com.theoplayer.theoplayer-sdk-android:integration-ads-ima:${theoplayer_sdk_version}"
   } else {
     println('Disable THEOplayer IMA extension.')
-    compileOnly "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads:${theoplayer_sdk_version}"
-    compileOnly "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads-ima:${theoplayer_sdk_version}"
+    compileOnly "com.theoplayer.theoplayer-sdk-android:integration-ads:${theoplayer_sdk_version}"
+    compileOnly "com.theoplayer.theoplayer-sdk-android:integration-ads-ima:${theoplayer_sdk_version}"
   }
 
-  // NOTE: The DAI extension module is available on Maven as of SDK v4.3.0
   if (enabledGoogleDAI) {
     println('Enable THEOplayer DAI extension.')
-    implementation "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads:${theoplayer_sdk_version}"
-    implementation "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads-dai:${theoplayer_sdk_version}"
+    implementation "com.theoplayer.theoplayer-sdk-android:integration-ads:${theoplayer_sdk_version}"
+    implementation "com.theoplayer.theoplayer-sdk-android:integration-ads-dai:${theoplayer_sdk_version}"
   } else {
     println('Disable THEOplayer DAI extension.')
-    compileOnly "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads:${theoplayer_sdk_version}"
-    compileOnly "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-ads-dai:${theoplayer_sdk_version}"
+    compileOnly "com.theoplayer.theoplayer-sdk-android:integration-ads:${theoplayer_sdk_version}"
+    compileOnly "com.theoplayer.theoplayer-sdk-android:integration-ads-dai:${theoplayer_sdk_version}"
   }
 
   if (enabledCast) {
     println('Enable THEOplayer cast extension.')
-    implementation "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-cast:${theoplayer_sdk_version}"
+    implementation "com.theoplayer.theoplayer-sdk-android:integration-cast:${theoplayer_sdk_version}"
   } else {
     println('Disable THEOplayer cast extension.')
-    compileOnly "com.theoplayer.theoplayer-sdk-android:${integration_prefix}-cast:${theoplayer_sdk_version}"
+    compileOnly "com.theoplayer.theoplayer-sdk-android:integration-cast:${theoplayer_sdk_version}"
   }
 }

package/android/src/main/java/com/theoplayer/PlayerConfigAdapter.kt

@@ -1,127 +1,123 @@
 package com.theoplayer
 
 import android.text.TextUtils
-import android.util.Log
 import com.facebook.react.bridge.ReadableMap
+import com.google.ads.interactivemedia.v3.api.AdsRenderingSettings
+import com.google.ads.interactivemedia.v3.api.ImaSdkFactory
 import com.theoplayer.android.api.THEOplayerConfig
 import com.theoplayer.android.api.ads.AdsConfiguration
 import com.theoplayer.android.api.ads.AdPreloadType
-import com.theoplayer.android.api.ads.GoogleImaConfiguration
 import com.theoplayer.android.api.cast.CastStrategy
-import com.google.android.gms.cast.framework.CastContext
+import com.theoplayer.android.api.cast.CastConfiguration
 import com.theoplayer.android.api.pip.PipConfiguration
 import com.theoplayer.android.api.player.NetworkConfiguration
 
-private const val TAG = "PlayerConfigAdapter"
-private const val PROP_ADS_CONFIGURATION = "ads"
 private const val PROP_LICENSE = "license"
 private const val PROP_LICENSE_URL = "licenseUrl"
-private const val PROP_CHROMELESS = "chromeless"
 private const val PROP_PRELOAD = "preload"
 private const val PROP_UI_ENABLED = "uiEnabled"
-private const val PROP_GOOGLE_IMA_CONFIGURATION = "googleImaConfiguration"
-private const val PROP_USE_NATIVE_IMA = "useNativeIma"
-private const val PROP_CAST_CONFIGURATION = "cast"
 private const val PROP_CAST_STRATEGY = "strategy"
-private const val PROP_CHROMECAST_CONFIG = "chromecast"
-private const val PROP_CHROMECAST_APPID = "appID"
 private const val PROP_RETRY_CONFIG = "retryConfiguration"
 private const val PROP_RETRY_MAX_RETRIES = "maxRetries"
 private const val PROP_RETRY_MIN_BACKOFF = "minimumBackoff"
 private const val PROP_RETRY_MAX_BACKOFF = "maximumBackoff"
+private const val PROP_CAST_CONFIGURATION = "cast"
+private const val PROP_ADS_CONFIGURATION = "ads"
 
-object PlayerConfigAdapter {
+class PlayerConfigAdapter(private val configProps: ReadableMap?) {
 
-  fun theoConfigFromProps(configProps: ReadableMap?): THEOplayerConfig {
-    val configBuilder = THEOplayerConfig.Builder()
-    if (configProps != null) {
-      val adsConfig = adsConfigurationFromProps(configProps.getMap(PROP_ADS_CONFIGURATION))
-      if (adsConfig != null) {
-        configBuilder.ads(adsConfig)
-      }
-      val license = configProps.getString(PROP_LICENSE)
-      if (license != null) {
-        configBuilder.license(license)
-      }
-      val licenseUrl = configProps.getString(PROP_LICENSE_URL)
-      if (licenseUrl != null) {
-        configBuilder.licenseUrl(licenseUrl)
-      }
-      if (configProps.hasKey(PROP_CHROMELESS)) {
-        configBuilder.chromeless(configProps.getBoolean(PROP_CHROMELESS))
+  /**
+   * Get general THEOplayerConfig object; these properties apply:
+   * - license: The license for the player.
+   * - licenseUrl: The url to fetch the license for the player.
+   * - retryConfiguration: The retry configuration for the player.
+   */
+  fun playerConfig(): THEOplayerConfig {
+    return THEOplayerConfig.Builder().apply {
+      configProps?.run {
+        getString(PROP_LICENSE)?.let { license ->
+          license(license)
+        }
+        getString(PROP_LICENSE_URL)?.let { licenseUrl ->
+          licenseUrl(licenseUrl)
+        }
+        if (hasKey(PROP_RETRY_CONFIG)) {
+          networkConfiguration(networkConfig())
+        }
+        pipConfiguration(PipConfiguration.Builder().build())
       }
-      if (configProps.hasKey(PROP_RETRY_CONFIG)) {
-        val networkConfig = networkConfigurationFromProps(configProps.getMap(PROP_RETRY_CONFIG))
-        if (networkConfig != null) {
-          configBuilder.networkConfiguration(networkConfig)
+    }.build()
+  }
+
+  /**
+   * Get NetworkConfiguration object; there properties apply:
+   * - maxRetries: The maximum amount of retries before the player throws a fatal error.
+   * - minimumBackoff: The initial delay in milliseconds before a retry request occurs.
+   * - maximumBackoff: The maximum amount of delay in milliseconds between retry requests.
+   */
+  private fun networkConfig(): NetworkConfiguration {
+    return NetworkConfiguration.Builder().apply {
+      configProps?.getMap(PROP_RETRY_CONFIG)?.run {
+        if (hasKey(PROP_RETRY_MAX_RETRIES)) {
+          maxRetries(getInt(PROP_RETRY_MAX_RETRIES))
+        }
+        if (hasKey(PROP_RETRY_MIN_BACKOFF)) {
+          minimumBackOff(getDouble(PROP_RETRY_MIN_BACKOFF).toLong())
+        }
+        if (hasKey(PROP_RETRY_MAX_BACKOFF)) {
+          maximumBackOff(getDouble(PROP_RETRY_MAX_BACKOFF).toLong())
         }
       }
-      applyCastConfigurationFromProps(configBuilder, configProps.getMap(PROP_CAST_CONFIGURATION))
-      configBuilder.pipConfiguration(PipConfiguration.Builder().build())
-    }
-    return configBuilder.build()
+    }.build()
   }
 
-  private fun adsConfigurationFromProps(configProps: ReadableMap?): AdsConfiguration? {
-    if (configProps == null) {
-      return null
-    }
-    val builder = AdsConfiguration.Builder()
-    val preloadTypeString = configProps.getString(PROP_PRELOAD)
-    if (!TextUtils.isEmpty(preloadTypeString)) {
-      builder.preload(AdPreloadType.from(preloadTypeString))
-    }
-    builder.showCountdown(
-      !configProps.hasKey(PROP_UI_ENABLED) || configProps.getBoolean(PROP_UI_ENABLED)
-    )
-    val googleImaConfiguration = googleImaConfigurationFromProps(
-      configProps.getMap(PROP_GOOGLE_IMA_CONFIGURATION)
-    )
-    if (googleImaConfiguration != null) {
-      builder.googleIma(googleImaConfiguration)
-    }
-    return builder.build()
+  /**
+   * Get AdsConfiguration object; these properties apply:
+   * - preload: Whether media files of mid- and postrolls are preloaded.
+   * - uiEnabled: Whether an advertisement UI is shown.
+   */
+  fun adsConfig(): AdsConfiguration {
+    return AdsConfiguration.Builder().apply {
+      configProps?.getMap(PROP_ADS_CONFIGURATION)?.run {
+        if (hasKey(PROP_PRELOAD)) {
+          val preloadTypeString = getString(PROP_PRELOAD)
+          if (!TextUtils.isEmpty(preloadTypeString)) {
+            preload(AdPreloadType.from(preloadTypeString))
+          }
+        }
+        if (hasKey(PROP_UI_ENABLED)) {
+          showCountdown(getBoolean(PROP_UI_ENABLED))
+        }
+      }
+    }.build()
   }
 
-  private fun networkConfigurationFromProps(configProps: ReadableMap?): NetworkConfiguration? {
-    if (configProps == null) {
-      return null
-    }
-    val builder = NetworkConfiguration.Builder()
-    if (configProps.hasKey(PROP_RETRY_MAX_RETRIES)) {
-      builder.maxRetries(configProps.getInt(PROP_RETRY_MAX_RETRIES))
-    }
-    if (configProps.hasKey(PROP_RETRY_MIN_BACKOFF)) {
-      builder.minimumBackOff(configProps.getDouble(PROP_RETRY_MIN_BACKOFF).toLong())
-    }
-    if (configProps.hasKey(PROP_RETRY_MAX_BACKOFF)) {
-      builder.maximumBackOff(configProps.getDouble(PROP_RETRY_MAX_BACKOFF).toLong())
+  /**
+   * Create a AdsRenderingSettings object.
+   */
+  fun adsRenderSettings(): AdsRenderingSettings {
+    return ImaSdkFactory.getInstance().createAdsRenderingSettings().apply {
+      configProps?.getMap(PROP_ADS_CONFIGURATION)?.run {
+        if (hasKey(PROP_UI_ENABLED) && !getBoolean(PROP_UI_ENABLED)) {
+          setUiElements(emptySet())
+          disableUi = true
+        }
+      }
     }
-    return builder.build()
   }
 
-  private fun applyCastConfigurationFromProps(
-    configBuilder: THEOplayerConfig.Builder,
-    castConfig: ReadableMap?
-  ) {
-    if (castConfig == null) {
-      return
-    }
-    val strStrategy = castConfig.getString(PROP_CAST_STRATEGY)
-    val castStrategy = castStrategyFromString(strStrategy)
-    if (castStrategy != null) {
-      configBuilder.castStrategy(castStrategy)
-    } else {
-      Log.e(TAG, "Unknown cast strategy: $strStrategy")
-    }
-    val chromecastConfig = castConfig.getMap(PROP_CHROMECAST_CONFIG)
-    if (chromecastConfig != null) {
-      val appID = chromecastConfig.getString(PROP_CHROMECAST_APPID)
-      val castContext = CastContext.getSharedInstance()
-      if (appID != null && castContext != null) {
-        castContext.setReceiverApplicationId(appID)
+  /**
+   * Get CastConfiguration object; these properties apply:
+   * - strategy: The join strategy of the player.
+   */
+  fun castConfig(): CastConfiguration {
+    return CastConfiguration.Builder().apply {
+      configProps?.getMap(PROP_CAST_CONFIGURATION)?.run {
+        castStrategyFromString(getString(PROP_CAST_STRATEGY))?.let { strategy ->
+          castStrategy(strategy)
+        }
       }
-    }
+    }.build()
   }
 
   private fun castStrategyFromString(strStrategy: String?): CastStrategy? {
@@ -132,14 +128,4 @@ object PlayerConfigAdapter {
       else -> null
     }
   }
-
-  private fun googleImaConfigurationFromProps(configProps: ReadableMap?): GoogleImaConfiguration? {
-    return if (configProps == null) {
-      null
-    } else GoogleImaConfiguration.Builder()
-      .useNativeIma(
-        configProps.hasKey(PROP_USE_NATIVE_IMA) && configProps.getBoolean(PROP_USE_NATIVE_IMA)
-      )
-      .build()
-  }
 }

package/android/src/main/java/com/theoplayer/ReactTHEOplayerContext.kt

@@ -12,10 +12,8 @@ import android.os.IBinder
 import android.os.Looper
 import android.support.v4.media.session.MediaSessionCompat
 import android.support.v4.media.session.PlaybackStateCompat
+import android.util.Log
 import com.facebook.react.uimanager.ThemedReactContext
-import com.google.ads.interactivemedia.v3.api.AdsRenderingSettings
-import com.google.ads.interactivemedia.v3.api.ImaSdkFactory
-import com.theoplayer.android.api.THEOplayerConfig
 import com.theoplayer.android.api.THEOplayerView
 import com.theoplayer.android.api.ads.dai.GoogleDaiIntegration
 import com.theoplayer.android.api.ads.dai.GoogleDaiIntegrationFactory
@@ -86,10 +84,10 @@ class ReactTHEOplayerContext private constructor(
   companion object {
     fun create(
       reactContext: ThemedReactContext,
-      playerConfig: THEOplayerConfig
+      configAdapter: PlayerConfigAdapter
     ): ReactTHEOplayerContext {
       return ReactTHEOplayerContext(reactContext).apply {
-        initializePlayerView(playerConfig)
+        initializePlayerView(configAdapter)
       }
     }
   }
@@ -213,8 +211,8 @@ class ReactTHEOplayerContext private constructor(
     binder = null
   }
 
-  private fun initializePlayerView(playerConfig: THEOplayerConfig) {
-    playerView = object : THEOplayerView(reactContext.currentActivity!!, playerConfig) {
+  private fun initializePlayerView(configAdapter: PlayerConfigAdapter) {
+    playerView = object : THEOplayerView(reactContext.currentActivity!!, configAdapter.playerConfig()) {
       private fun measureAndLayout() {
         measure(
           MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
@@ -234,7 +232,7 @@ class ReactTHEOplayerContext private constructor(
     // By default, the screen should remain on.
     playerView.keepScreenOn = true
 
-    addIntegrations(playerConfig)
+    addIntegrations(configAdapter)
     addListeners()
 
     audioFocusManager = AudioFocusManager(reactContext, player)
@@ -268,34 +266,45 @@ class ReactTHEOplayerContext private constructor(
     }
   }
 
-  private fun addIntegrations(playerConfig: THEOplayerConfig) {
+  private fun addIntegrations(configAdapter: PlayerConfigAdapter) {
     try {
       if (BuildConfig.EXTENSION_GOOGLE_IMA) {
-        imaIntegration = GoogleImaIntegrationFactory.createGoogleImaIntegration(playerView).apply {
-          setAdsRenderingSettings(createRenderSettings(playerConfig))
-          playerView.player.addIntegration(this)
+        imaIntegration = GoogleImaIntegrationFactory.createGoogleImaIntegration(
+          playerView, configAdapter.adsConfig()
+        ).apply {
+          setAdsRenderingSettings(configAdapter.adsRenderSettings())
+        }.also {
+          playerView.player.addIntegration(it)
         }
       }
-    } catch (ignore: Exception) {
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to configure Google IMA integration ${e.message}")
     }
     try {
       if (BuildConfig.EXTENSION_GOOGLE_DAI) {
-        daiIntegration = GoogleDaiIntegrationFactory.createGoogleDaiIntegration(playerView).apply {
-          setAdsRenderingSettings(createRenderSettings(playerConfig))
-          playerView.player.addIntegration(this)
+        daiIntegration = GoogleDaiIntegrationFactory.createGoogleDaiIntegration(
+          playerView, configAdapter.adsConfig()
+        ).apply {
+          setAdsRenderingSettings(configAdapter.adsRenderSettings())
+        }.also {
+          playerView.player.addIntegration(it)
         }
       }
-    } catch (ignore: Exception) {
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to configure Google DAI integration ${e.message}")
     }
     try {
       if (BuildConfig.EXTENSION_CAST) {
-        castIntegration = CastIntegrationFactory.createCastIntegration(playerView).apply {
-          playerView.player.addIntegration(this)
+        castIntegration = CastIntegrationFactory.createCastIntegration(
+          playerView, configAdapter.castConfig()
+        ).also {
+          playerView.player.addIntegration(it)
         }
       }
-      // Add other future integrations here.
-    } catch (ignore: Exception) {
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to configure Cast integration ${e.message}")
     }
+    // Add other future integrations here.
   }
 
   private val onSourceChange = EventListener<SourceChangeEvent> {
@@ -343,15 +352,6 @@ class ReactTHEOplayerContext private constructor(
     }
   }
 
-  private fun createRenderSettings(playerConfig: THEOplayerConfig): AdsRenderingSettings {
-    val renderingSettings = ImaSdkFactory.getInstance().createAdsRenderingSettings()
-    if (playerConfig.ads != null && !playerConfig.ads!!.isShowCountdown) {
-      renderingSettings.setUiElements(emptySet())
-      renderingSettings.disableUi = true
-    }
-    return renderingSettings
-  }
-
   /**
    * The host activity is paused.
    */

package/android/src/main/java/com/theoplayer/ReactTHEOplayerPackage.kt

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.uimanager.ViewManager
 import com.theoplayer.ads.AdsModule
+import com.theoplayer.cache.CacheModule
 import com.theoplayer.drm.ContentProtectionModule
 import com.theoplayer.cast.CastModule
 import com.theoplayer.player.PlayerModule
@@ -15,7 +16,8 @@ class ReactTHEOplayerPackage : ReactPackage {
       PlayerModule(reactContext),
       AdsModule(reactContext),
       ContentProtectionModule(reactContext),
-      CastModule(reactContext)
+      CastModule(reactContext),
+      CacheModule(reactContext)
     )
   }
 

package/android/src/main/java/com/theoplayer/ReactTHEOplayerView.kt

@@ -51,7 +51,7 @@ class ReactTHEOplayerView(private val reactContext: ThemedReactContext) :
     isInitialized = true
     playerContext = ReactTHEOplayerContext.create(
       reactContext,
-      PlayerConfigAdapter.theoConfigFromProps(configProps)
+      PlayerConfigAdapter(configProps)
     )
     playerContext?.let {
       if (BuildConfig.EXTENSION_ADS) {

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

@@ -0,0 +1,127 @@
+package com.theoplayer.cache
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.cache.CacheStatus
+import com.theoplayer.android.api.cache.CachingParameters
+import com.theoplayer.android.api.cache.CachingPreferredTrackSelection
+import com.theoplayer.android.api.cache.CachingTask
+import com.theoplayer.android.api.cache.CachingTaskList
+import com.theoplayer.android.api.cache.CachingTaskProgress
+import com.theoplayer.android.api.cache.CachingTaskStatus
+import com.theoplayer.source.SourceAdapter
+import com.theoplayer.util.fromTimeRanges
+import java.util.Date
+
+private const val PROP_ID = "id"
+private const val PROP_STATUS = "status"
+private const val PROP_SOURCE = "source"
+private const val PROP_PARAMETERS = "parameters"
+private const val PROP_PARAMETERS_AMOUNT = "amount"
+private const val PROP_PARAMETERS_EXPIRATION_DATE = "expirationDate"
+private const val PROP_PARAMETERS_BANDWIDTH = "bandwidth"
+private const val PROP_PARAMETERS_PREFERRED_TRACK_SELECTION = "preferredTrackSelection"
+private const val PROP_PARAMETERS_AUDIO_TRACK_SELECTION = "audioTrackSelection"
+private const val PROP_PARAMETERS_TEXT_TRACK_SELECTION = "textTrackSelection"
+private const val PROP_DURATION = "duration"
+private const val PROP_CACHED = "cached"
+private const val PROP_SECONDS_CACHED = "secondsCached"
+private const val PROP_PERCENTAGE_CACHED = "percentageCached"
+private const val PROP_BYTES = "bytes"
+private const val PROP_BYTES_CACHED = "bytesCached"
+
+object CacheAdapter {
+
+  fun fromCachingTask(task: CachingTask?): WritableMap {
+    if (task == null) {
+      return Arguments.createMap()
+    }
+    return Arguments.createMap().apply {
+      putString(PROP_ID, task.id)
+      putString(PROP_STATUS, fromCacheTaskStatus(task.status))
+      putMap(PROP_SOURCE, SourceAdapter().fromSourceDescription(task.source))
+      putMap(PROP_PARAMETERS, fromCachingParameters(task.parameters))
+      putDouble(PROP_DURATION, task.duration)
+      putArray(PROP_CACHED, fromTimeRanges(task.cached))
+      putDouble(PROP_SECONDS_CACHED, task.secondsCached)
+      putDouble(PROP_PERCENTAGE_CACHED, task.percentageCached)
+      putDouble(PROP_BYTES, task.bytes.toDouble())
+      putDouble(PROP_BYTES_CACHED, task.bytesCached.toDouble())
+    }
+  }
+
+  fun fromCachingTaskList(taskList: CachingTaskList?): WritableArray {
+    return Arguments.createArray().apply {
+      taskList?.forEach { task ->
+        pushMap(fromCachingTask(task))
+      }
+    }
+  }
+
+  fun fromCacheStatus(status: CacheStatus): String {
+    return when (status) {
+      CacheStatus.INITIALISED -> "initialised"
+      else -> "uninitialised"
+    }
+  }
+
+  fun fromCachingTaskProgress(progress: CachingTaskProgress): WritableMap {
+    return Arguments.createMap().apply {
+      putDouble(PROP_DURATION, progress.duration)
+      putArray(PROP_CACHED, fromTimeRanges(progress.cached))
+      putDouble(PROP_SECONDS_CACHED, progress.secondsCached)
+      putDouble(PROP_PERCENTAGE_CACHED, progress.percentageCached)
+      putDouble(PROP_BYTES, progress.bytes.toDouble())
+      putDouble(PROP_BYTES_CACHED, progress.bytesCached.toDouble())
+    }
+  }
+
+  fun fromCacheTaskStatus(status: CachingTaskStatus): String {
+    return when (status) {
+      CachingTaskStatus.ERROR -> "error"
+      CachingTaskStatus.DONE -> "done"
+      CachingTaskStatus.EVICTED -> "evicted"
+      CachingTaskStatus.LOADING -> "loading"
+      else -> "idle"
+    }
+  }
+
+  fun parseCachingParameters(parameters: ReadableMap): CachingParameters {
+    return CachingParameters.Builder().apply {
+      amount(parameters.getString(PROP_PARAMETERS_AMOUNT))
+      if (parameters.hasKey(PROP_PARAMETERS_BANDWIDTH)) {
+        bandwidth(parameters.getDouble(PROP_PARAMETERS_BANDWIDTH).toLong())
+      }
+      if (parameters.hasKey(PROP_PARAMETERS_EXPIRATION_DATE)) {
+        expirationDate(Date(parameters.getDouble(PROP_PARAMETERS_EXPIRATION_DATE).toLong()))
+      }
+      if (parameters.hasKey(PROP_PARAMETERS_PREFERRED_TRACK_SELECTION)) {
+        preferredTrackSelection(parsePreferredTrackSelection(parameters.getMap(PROP_PARAMETERS_PREFERRED_TRACK_SELECTION)))
+      }
+    }.build()
+  }
+
+  private fun parsePreferredTrackSelection(parameters: ReadableMap?): CachingPreferredTrackSelection {
+    return CachingPreferredTrackSelection.Builder().apply {
+      audioTrackSelection(fromReadableStringArray(parameters?.getArray(PROP_PARAMETERS_AUDIO_TRACK_SELECTION)))
+      textTrackSelection(fromReadableStringArray(parameters?.getArray(PROP_PARAMETERS_TEXT_TRACK_SELECTION)))
+    }.build()
+  }
+
+  private fun fromReadableStringArray(array: ReadableArray?): Array<String>? {
+    return array?.toArrayList()?.map { it.toString() }?.toTypedArray()
+  }
+
+  private fun fromCachingParameters(parameters: CachingParameters?): WritableMap {
+    return Arguments.createMap().apply {
+      if (parameters != null) {
+        putString(PROP_PARAMETERS_AMOUNT, parameters.amount)
+        putDouble(PROP_PARAMETERS_BANDWIDTH, parameters.bandwidth.toDouble())
+        putDouble(PROP_PARAMETERS_EXPIRATION_DATE, parameters.expirationDate.time.toDouble())
+      }
+    }
+  }
+}