bitmovin-player-react-native 0.9.2 → 0.10.0

package/RNBitmovinPlayer.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "BitmovinPlayer", "3.43.1"
+  s.dependency "BitmovinPlayer", "3.44.1"
   s.ios.dependency "GoogleAds-IMA-iOS-SDK", "3.18.4"
   s.tvos.dependency "GoogleAds-IMA-tvOS-SDK", "4.8.2"
 end

package/android/build.gradle

@@ -53,8 +53,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
     implementation 'com.google.ads.interactivemedia.v3:interactivemedia:3.29.0'
     implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
-    implementation 'com.bitmovin.analytics:collector-bitmovin-player:2.12.1'
-    implementation 'com.bitmovin.player:player:3.40.0'
+    implementation 'com.bitmovin.player:player:3.42.0'
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+' // From node_modules
 }

package/android/src/main/java/com/bitmovin/player/reactnative/AnalyticsModule.kt

@@ -1,6 +1,7 @@
 package com.bitmovin.player.reactnative
 
-import com.bitmovin.analytics.bitmovin.player.BitmovinPlayerCollector
+import android.util.Log
+import com.bitmovin.analytics.bitmovin.player.api.IBitmovinPlayerCollector
 import com.bitmovin.player.reactnative.converter.JsonConverter
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
@@ -13,7 +14,7 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
     /**
      * In-memory mapping from `nativeId`s to `BitmovinPlayerCollector` instances.
      */
-    private val collectors: Registry<BitmovinPlayerCollector> = mutableMapOf()
+    private val collectors: Registry<IBitmovinPlayerCollector> = mutableMapOf()
 
     /**
      * JS exported module name.
@@ -25,7 +26,7 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
      * @param nativeId `BitmovinPlayerCollector` instance ID.
      * @return The associated `BitmovinPlayerCollector` instance or `null`.
      */
-    fun getCollector(nativeId: NativeId?): BitmovinPlayerCollector? {
+    fun getCollector(nativeId: NativeId?): IBitmovinPlayerCollector? {
         if (nativeId == null) {
             return null
         }
@@ -40,7 +41,7 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
     fun initWithConfig(nativeId: NativeId, config: ReadableMap?) {
         uiManager()?.addUIBlock { _ ->
             JsonConverter.toAnalyticsConfig(config)?.let {
-                collectors[nativeId] = BitmovinPlayerCollector(it, context)
+                collectors[nativeId] = IBitmovinPlayerCollector.create(it, context)
             }
         }
     }
@@ -106,8 +107,20 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
     @ReactMethod
     fun setCustomData(nativeId: NativeId, playerId: NativeId?, json: ReadableMap?) {
         uiManager()?.addUIBlock { _ ->
-            JsonConverter.toAnalyticsCustomData(json)?.let {
-                collectors[nativeId]?.customData = it
+            val source = playerModule()?.getPlayer(playerId)?.source
+            val collector = collectors[nativeId]
+            val customData = JsonConverter.toAnalyticsCustomData(json)
+            when {
+                source == null -> Log.d(
+                    "[AnalyticsModule]", "Could not find source for player ($playerId)"
+                )
+                collector == null -> Log.d(
+                    "[AnalyticsModule]", "Could not find analytics collector ($nativeId)"
+                )
+                customData == null -> Log.d(
+                    "[AnalyticsModule]", "Could not convert custom data, thus they are not applied to the active source for the player ($playerId) with the collector ($nativeId)"
+                )
+                else -> collector.setCustomData(source,  customData)
             }
         }
     }
@@ -120,8 +133,16 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
     @ReactMethod
     fun getCustomData(nativeId: NativeId, playerId: NativeId?, promise: Promise) {
         uiManager()?.addUIBlock { _ ->
-            collectors[nativeId]?.let {
-                promise.resolve(JsonConverter.fromAnalyticsCustomData(it.customData))
+            val source = playerModule()?.getPlayer(playerId)?.source
+            val collector = collectors[nativeId]
+            when {
+                source == null -> promise.reject(
+                    "[AnalyticsModule]", "Could not find source for player ($playerId)"
+                )
+                collector == null -> promise.reject(
+                    "[AnalyticsModule]", "Could not find analytics collector ($nativeId)"
+                )
+                else -> promise.resolve(JsonConverter.fromAnalyticsCustomData(collector.getCustomData(source)))
             }
         }
     }
@@ -129,9 +150,20 @@ class AnalyticsModule(private val context: ReactApplicationContext) : ReactConte
     @ReactMethod
     fun addSourceMetadata(nativeId: NativeId, playerId: NativeId?, json: ReadableMap?) {
         uiManager()?.addUIBlock { _ ->
-            val playerSource = playerModule()?.getPlayer(playerId)?.source ?: return@addUIBlock
-            JsonConverter.toAnalyticsSourceMetadata(json)?.let { sourceMetadata ->
-                collectors[nativeId]?.addSourceMetadata(playerSource, sourceMetadata)
+            val source = playerModule()?.getPlayer(playerId)?.source
+            val collector = collectors[nativeId]
+            val sourceMetadata = JsonConverter.toAnalyticsSourceMetadata(json)
+            when {
+                source == null -> Log.d(
+                    "[AnalyticsModule]", "Could not find source for player ($playerId)"
+                )
+                collector == null -> Log.d(
+                    "[AnalyticsModule]", "Could not find analytics collector ($nativeId)"
+                )
+                sourceMetadata == null -> Log.d(
+                    "[AnalyticsModule]", "Could not convert source metadata, thus they are not applied to the collector ($nativeId)"
+                )
+                else -> collector.addSourceMetadata(source,  sourceMetadata)
             }
         }
     }

package/android/src/main/java/com/bitmovin/player/reactnative/OfflineModule.kt

@@ -0,0 +1,279 @@
+package com.bitmovin.player.reactnative
+
+import com.bitmovin.player.api.offline.options.OfflineOptionEntryState
+import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.bitmovin.player.reactnative.extensions.toList
+import com.bitmovin.player.reactnative.offline.OfflineDownloadRequest
+import com.bitmovin.player.reactnative.offline.OfflineContentManagerBridge
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerModule
+
+private const val OFFLINE_MODULE = "BitmovinOfflineModule"
+
+@ReactModule(name = OFFLINE_MODULE)
+class OfflineModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+
+    /**
+     * In-memory mapping from `nativeId`s to `OfflineManager` instances.
+     */
+    private val offlineContentManagerBridges: Registry<OfflineContentManagerBridge> = mutableMapOf()
+
+    /**
+     * JS exported module name.
+     */
+    override fun getName() = OFFLINE_MODULE
+
+    /**
+     * Fetches the `OfflineManager` instance associated with `nativeId` from the internal offline managers.
+     * @param nativeId `OfflineManager` instance ID.
+     * @return The associated `OfflineManager` instance or `null`.
+     */
+    fun getOfflineContentManagerBridge(nativeId: NativeId?): OfflineContentManagerBridge? {
+        if (nativeId == null) {
+            return null
+        }
+        return offlineContentManagerBridges[nativeId]
+    }
+
+    /**
+     * Callback when a new NativeEventEmitter is created from the Typescript layer.
+     */
+    @ReactMethod
+    fun addListener(eventName: String?) {
+        // NO-OP
+    }
+
+    /**
+     * Callback when a NativeEventEmitter is removed from the Typescript layer.
+     */
+    @ReactMethod
+    fun removeListeners(count: Int?) {
+        // NO-OP
+    }
+
+    /**
+     * Creates a new `OfflineManager` instance inside the internal offline managers using the provided `config` object.
+     * @param config `ReadableMap` object received from JS.  Should contain a sourceConfig and location.
+     */
+    @ReactMethod
+    fun initWithConfig(nativeId: NativeId, config: ReadableMap?, drmNativeId: NativeId?, promise: Promise) {
+        uiManager()?.addUIBlock {
+            if (!offlineContentManagerBridges.containsKey(nativeId)) {
+                val identifier = config?.getString("identifier")
+                val sourceConfig = JsonConverter.toSourceConfig(config?.getMap("sourceConfig"))
+                sourceConfig?.drmConfig = drmModule()?.getConfig(drmNativeId)
+
+                if (identifier.isNullOrEmpty() || sourceConfig == null) {
+                    promise.reject(IllegalArgumentException("Identifier and SourceConfig may not be null"))
+                    return@addUIBlock
+                }
+
+                offlineContentManagerBridges[nativeId] = OfflineContentManagerBridge(nativeId, context, identifier, sourceConfig, context.cacheDir.path)
+            }
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun getState(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            promise.resolve(state.name)
+        }
+    }
+
+    /**
+     * Starts the `OfflineContentManager`'s asynchronous process of fetching the `OfflineContentOptions`.
+     * When the options are loaded a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onOptionsAvailable`.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun getOptions(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            getOptions()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Enqueues downloads according to the `OfflineDownloadRequest`.
+     * The promise will reject in the event of null or invalid request parameters.
+     * The promise will reject an `IllegalOperationException` when selecting an `OfflineOptionEntry` to download that is not compatible with the current state.
+     * @param nativeId Target offline manager.
+     * @param request `ReadableMap` that contains the `OfflineManager.OfflineOptionType`, id, and `OfflineOptionEntryAction` necessary to set the new action.
+     */
+    @ReactMethod
+    fun download(nativeId: NativeId, request: ReadableMap?, promise: Promise) {
+        if (request == null) {
+            promise.reject(IllegalArgumentException("Request may not be null"))
+            return
+        }
+
+        safeOfflineContentManager(nativeId, promise) {
+            try {
+                when (state) {
+                    OfflineOptionEntryState.Downloaded -> {
+                        promise.reject(IllegalStateException("Download already completed"))
+                        return@safeOfflineContentManager
+                    }
+                    OfflineOptionEntryState.Downloading,
+                    OfflineOptionEntryState.Failed -> {
+                        promise.reject(IllegalStateException("Download already in progress"))
+                        return@safeOfflineContentManager
+                    }
+                    OfflineOptionEntryState.Suspended -> {
+                        promise.reject(IllegalStateException("Download is suspended"))
+                        return@safeOfflineContentManager
+                    }
+                    else -> {}
+                }
+                val minimumBitRate = if(request.hasKey("minimumBitrate")) request.getInt("minimumBitrate") else null
+                if (minimumBitRate != null && minimumBitRate < 0) {
+                    promise.reject(IllegalArgumentException("Invalid download request"))
+                    return@safeOfflineContentManager
+                }
+
+                val audioOptionIds = request.getArray("audioOptionIds")?.toList<String>()?.filterNotNull()
+                val textOptionIds = request.getArray("textOptionIds")?.toList<String>()?.filterNotNull()
+
+                getOfflineContentManagerBridge(nativeId)?.process(OfflineDownloadRequest(minimumBitRate, audioOptionIds, textOptionIds))
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject(e)
+            }
+        }
+    }
+
+    /**
+     * Resumes all suspended actions.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun resume(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            resume()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Suspends all active actions.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun suspend(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            suspend()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Cancels and deletes the current download.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun cancelDownload(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            cancelDownload()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Resolve `nativeId`'s current `usedStorage`.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun usedStorage(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            promise.resolve(offlineContentManager.usedStorage.toDouble())
+        }
+    }
+
+    /**
+     * Deletes everything related to the related content ID.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun deleteAll(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            deleteAll()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Downloads the offline license.
+     * When finished successfully a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onDrmLicenseUpdated`.
+     * Errors are transmitted by a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onError`.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun downloadLicense(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            downloadLicense()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Releases the currently held offline license.
+     * When finished successfully a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onDrmLicenseUpdated`.
+     * Errors are transmitted by a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onError`.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun releaseLicense(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            releaseLicense()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Renews the already downloaded DRM license.
+     * When finished successfully a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onDrmLicenseUpdated`.
+     * Errors are transmitted by a device event will be fired where the event type is `BitmovinOfflineEvent` and the data has an event type of `onError`.
+     * @param nativeId Target offline manager.
+     */
+    @ReactMethod
+    fun renewOfflineLicense(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            renewOfflineLicense()
+            promise.resolve(null)
+        }
+    }
+
+    /**
+     * Call `.release()` on `nativeId`'s offline manager.
+     * IMPORTANT: Call this when the component, in which it was created, is destroyed.
+     * The `OfflineManager` should not be used after calling this method.
+     * @param nativeId Target player Id.
+     */
+    @ReactMethod
+    fun release(nativeId: NativeId, promise: Promise) {
+        safeOfflineContentManager(nativeId, promise) {
+            release()
+            offlineContentManagerBridges.remove(nativeId)
+            promise.resolve(null)
+        }
+    }
+
+    private fun safeOfflineContentManager(nativeId: NativeId, promise: Promise, runBlock: OfflineContentManagerBridge.() -> Unit) {
+        getOfflineContentManagerBridge(nativeId)?.let(runBlock)
+                ?: promise.reject(IllegalArgumentException("Could not find the offline module instance"))
+    }
+
+    /**
+     * Helper function that returns the initialized `DrmModule` instance.
+     */
+    private fun drmModule(): DrmModule? =
+            context.getNativeModule(DrmModule::class.java)
+
+    /**
+     * Helper function that returns the initialized `UIManager` instance.
+     */
+    private fun uiManager(): UIManagerModule? =
+            context.getNativeModule(UIManagerModule::class.java)
+}

package/android/src/main/java/com/bitmovin/player/reactnative/PlayerModule.kt

@@ -50,7 +50,7 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
     /**
      * Load the source of the given `nativeId` with `config` options from JS.
      * @param nativeId Target player.
-     * @param config Source configuration options from JS.
+     * @param sourceNativeId Target source.
      */
     @ReactMethod
     fun loadSource(nativeId: NativeId, sourceNativeId: String) {
@@ -61,6 +61,24 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
         }
     }
 
+    /**
+     * Load the `offlineSourceConfig` for the player with `nativeId` and offline source module with `offlineModuleNativeId`.
+     * @param nativeId Target player.
+     * @param offlineContentManagerBridgeId Target offline module.
+     * @param options Source configuration options from JS.
+     */
+    @ReactMethod
+    fun loadOfflineContent(nativeId: NativeId, offlineContentManagerBridgeId: String, options: ReadableMap?) {
+        uiManager()?.addUIBlock {
+            val offlineSourceConfig = offlineModule()?.getOfflineContentManagerBridge(offlineContentManagerBridgeId)
+                ?.offlineContentManager?.offlineSourceConfig
+
+            if (offlineSourceConfig != null) {
+                players[nativeId]?.load(offlineSourceConfig)
+            }
+        }
+    }
+
     /**
      * Call `.unload()` on `nativeId`'s player.
      * @param nativeId Target player Id.
@@ -398,6 +416,18 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
         }
     }
 
+    /**
+     * Sets the max selectable bitrate for the player.
+     * @param nativeId Target player id.
+     * @param maxSelectableBitrate The desired max bitrate limit.
+     */
+    @ReactMethod
+    fun setMaxSelectableBitrate(nativeId: NativeId, maxSelectableBitrate: Int) {
+        uiManager()?.addUIBlock {
+            players[nativeId]?.setMaxSelectableVideoBitrate(maxSelectableBitrate.takeUnless { it == -1 } ?: Integer.MAX_VALUE)
+        }
+    }
+
     /**
      * Helper function that returns the initialized `UIManager` instance.
      */
@@ -409,4 +439,10 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
      */
     private fun sourceModule(): SourceModule? =
         context.getNativeModule(SourceModule::class.java)
+
+    /**
+     * Helper function that returns the initialized `OfflineModule` instance.
+     */
+    private fun offlineModule(): OfflineModule? =
+        context.getNativeModule(OfflineModule::class.java)
 }

package/android/src/main/java/com/bitmovin/player/reactnative/RNPlayerViewPackage.kt

@@ -19,6 +19,7 @@ class RNPlayerViewPackage : ReactPackage {
      */
     override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
         return mutableListOf(
+            OfflineModule(reactContext),
             UuidModule(reactContext),
             PlayerModule(reactContext),
             SourceModule(reactContext),