bitmovin-player-react-native 0.9.2 → 0.10.0

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

@@ -1,36 +1,52 @@
 package com.bitmovin.player.reactnative.converter
 
 import com.bitmovin.analytics.BitmovinAnalyticsConfig
-import com.bitmovin.analytics.config.SourceMetadata
-import com.bitmovin.analytics.data.CustomData
+import com.bitmovin.analytics.api.CustomData
+import com.bitmovin.analytics.api.SourceMetadata
 import com.bitmovin.player.api.DeviceDescription.DeviceName
 import com.bitmovin.player.api.DeviceDescription.ModelName
 import com.bitmovin.player.api.PlaybackConfig
 import com.bitmovin.player.api.PlayerConfig
 import com.bitmovin.player.api.TweaksConfig
-import com.bitmovin.player.api.advertising.*
+import com.bitmovin.player.api.advertising.Ad
+import com.bitmovin.player.api.advertising.AdBreak
+import com.bitmovin.player.api.advertising.AdConfig
+import com.bitmovin.player.api.advertising.AdData
+import com.bitmovin.player.api.advertising.AdItem
+import com.bitmovin.player.api.advertising.AdQuartile
+import com.bitmovin.player.api.advertising.AdSource
+import com.bitmovin.player.api.advertising.AdSourceType
+import com.bitmovin.player.api.advertising.AdvertisingConfig
 import com.bitmovin.player.api.drm.WidevineConfig
 import com.bitmovin.player.api.event.PlayerEvent
 import com.bitmovin.player.api.event.SourceEvent
 import com.bitmovin.player.api.event.data.SeekPosition
+import com.bitmovin.player.api.media.AdaptationConfig
 import com.bitmovin.player.api.media.audio.AudioTrack
 import com.bitmovin.player.api.media.subtitle.SubtitleTrack
 import com.bitmovin.player.api.media.thumbnail.ThumbnailTrack
 import com.bitmovin.player.api.media.video.quality.VideoQuality
+import com.bitmovin.player.api.offline.options.OfflineContentOptions
+import com.bitmovin.player.api.offline.options.OfflineOptionEntry
 import com.bitmovin.player.api.source.Source
 import com.bitmovin.player.api.source.SourceConfig
+import com.bitmovin.player.api.source.SourceOptions
 import com.bitmovin.player.api.source.SourceType
+import com.bitmovin.player.api.source.TimelineReferencePoint
 import com.bitmovin.player.api.ui.ScalingMode
 import com.bitmovin.player.api.ui.StyleConfig
 import com.bitmovin.player.reactnative.extensions.getName
-import com.bitmovin.player.reactnative.extensions.putInt
+import com.bitmovin.player.reactnative.extensions.getProperty
 import com.bitmovin.player.reactnative.extensions.putDouble
+import com.bitmovin.player.reactnative.extensions.putInt
+import com.bitmovin.player.reactnative.extensions.setProperty
 import com.bitmovin.player.reactnative.extensions.toList
 import com.bitmovin.player.reactnative.extensions.toReadableArray
-import com.bitmovin.player.reactnative.extensions.getProperty
-import com.bitmovin.player.reactnative.extensions.setProperty
-import com.facebook.react.bridge.*
 import com.bitmovin.player.reactnative.extensions.toReadableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
 import java.util.UUID
 
 /**
@@ -71,9 +87,53 @@ class JsonConverter {
                     playerConfig.advertisingConfig = it
                 }
             }
+            if (json.hasKey("adaptationConfig")) {
+                toAdaptationConfig(json.getMap("adaptationConfig"))?.let {
+                    playerConfig.adaptationConfig = it
+                }
+            }
             return playerConfig
         }
 
+        /**
+         * Converts an arbitrary `json` to `SourceOptions`.
+         * @param json JS object representing the `SourceOptions`.
+         * @return The generated `SourceOptions`.
+         */
+        @JvmStatic
+        fun toSourceOptions(json: ReadableMap?): SourceOptions {
+            if (json == null) return SourceOptions()
+            val startOffset = if(json.hasKey("startOffset")) json.getDouble("startOffset") else null
+            val timelineReferencePoint = toTimelineReferencePoint(json.getString("startOffsetTimelineReference"))
+            return SourceOptions(startOffset = startOffset, startOffsetTimelineReference = timelineReferencePoint)
+        }
+
+        /**
+         * Converts an arbitrary `json` to `TimelineReferencePoint`.
+         * @param json JS string representing the `TimelineReferencePoint`.
+         * @return The generated `TimelineReferencePoint`.
+         */
+        @JvmStatic
+        private fun toTimelineReferencePoint(json: String?): TimelineReferencePoint? = when (json) {
+            "start" -> TimelineReferencePoint.Start
+            "end" -> TimelineReferencePoint.End
+            else -> null
+        }
+        
+        /**
+         * Converts an arbitrary `json` to `AdaptationConfig`.
+         * @param json JS object representing the `AdaptationConfig`.
+         * @return The generated `AdaptationConfig` if successful, `null` otherwise.
+         */
+        private fun toAdaptationConfig(json: ReadableMap?): AdaptationConfig? {
+            if (json == null) return null
+            val adaptationConfig = AdaptationConfig()
+            if (json.hasKey("maxSelectableBitrate")) {
+                adaptationConfig.maxSelectableVideoBitrate = json.getInt("maxSelectableBitrate")
+            }
+            return adaptationConfig
+        }
+
         /**
          * Converts any JS object into a `PlaybackConfig` object.
          * @param json JS object representing the `PlaybackConfig`.
@@ -213,7 +273,7 @@ class JsonConverter {
                 ?.mapNotNull(::toAdSource)
                 ?.toTypedArray()
                 ?: return null
-            return AdItem(sources, json?.getString("position") ?: "pre")
+            return AdItem(sources, json.getString("position") ?: "pre")
         }
 
         /**
@@ -272,6 +332,9 @@ class JsonConverter {
                     ?.toHashMap()
                     ?.mapValues { entry -> entry.value as String }
             }
+            if (json.hasKey("options")) {
+                config.options = toSourceOptions(json.getMap("options"))
+            }
             return config
         }
 
@@ -545,7 +608,7 @@ class JsonConverter {
                 false
             }
             val format = json.getString("format")
-            if (format != null && format.isNotBlank()) {
+            if (!format.isNullOrBlank()) {
                 return SubtitleTrack(
                     url = url,
                     label = label,
@@ -778,17 +841,20 @@ class JsonConverter {
          * @return The produced `CustomData` or null.
          */
         @JvmStatic
-        fun toAnalyticsCustomData(json: ReadableMap?): CustomData? = json?.let {
-            val customData = CustomData()
-            for (n in 1..30) {
-                it.getString("customData${n}")?.let { customDataN ->
-                    customData.setProperty("customData${n}", customDataN)
+        fun toAnalyticsCustomData(json: ReadableMap?): CustomData? {
+            if (json == null) return null
+
+            return CustomData.Builder().apply {
+                for (n in 1..30) {
+                    setProperty(
+                        "customData${n}",
+                        json.getString("customData${n}") ?: continue
+                    )
                 }
-            }
-            it.getString("experimentName")?.let { experimentName ->
-                customData.experimentName = experimentName
-            }
-            customData
+                json.getString("experimentName")?.let {
+                    setExperimentName(it)
+                }
+            }.build()
         }
 
         /**
@@ -812,23 +878,15 @@ class JsonConverter {
 
         @JvmStatic
         fun toAnalyticsSourceMetadata(json: ReadableMap?): SourceMetadata? = json?.let {
-            val sourceMetadata = SourceMetadata(
-                    title = it.getString("title"),
-                    videoId = it.getString("videoId"),
-                    cdnProvider = it.getString("cdnProvider"),
-                    path = it.getString("path"),
-                    isLive = it.getBoolean("isLive")
+            val sourceCustomData = toAnalyticsCustomData(json) ?: CustomData()
+            SourceMetadata(
+                title = it.getString("title"),
+                videoId = it.getString("videoId"),
+                cdnProvider = it.getString("cdnProvider"),
+                path = it.getString("path"),
+                isLive = it.getBoolean("isLive"),
+                customData = sourceCustomData
             )
-
-            for (n in 1..30) {
-                it.getString("customData${n}")?.let { customDataN ->
-                    sourceMetadata.setProperty("customData${n}", customDataN)
-                }
-            }
-            it.getString("experimentName")?.let { experimentName ->
-                sourceMetadata.experimentName = experimentName
-            }
-            sourceMetadata
         }
 
         /**
@@ -848,5 +906,35 @@ class JsonConverter {
                 putInt("width", videoQuality.width)
             }
         }
+
+        /**
+         * Converts any `OfflineOptionEntry` into its json representation.
+         * @param offlineEntry `OfflineOptionEntry` object to be converted.
+         * @return The generated json map.
+         */
+        @JvmStatic
+        fun toJson(offlineEntry: OfflineOptionEntry): WritableMap {
+            return Arguments.createMap().apply {
+                putString("id", offlineEntry.id)
+                putString("language", offlineEntry.language)
+            }
+        }
+
+        /**
+         * Converts any `OfflineContentOptions` into its json representation.
+         * @param options `OfflineContentOptions` object to be converted.
+         * @return The generated json map.
+         */
+        @JvmStatic
+        fun toJson(options: OfflineContentOptions?): WritableMap? {
+            if (options == null) {
+                return null
+            }
+
+            return Arguments.createMap().apply {
+                putArray("audioOptions", options.audioOptions.map { toJson(it) }.toReadableArray())
+                putArray("textOptions", options.textOptions.map { toJson(it) }.toReadableArray())
+            }
+        }
     }
 }

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

@@ -0,0 +1,216 @@
+package com.bitmovin.player.reactnative.offline
+
+import com.bitmovin.player.api.deficiency.ErrorEvent
+import com.bitmovin.player.api.offline.OfflineContentManager
+import com.bitmovin.player.api.offline.OfflineContentManagerListener
+import com.bitmovin.player.api.offline.options.*
+import com.bitmovin.player.api.source.SourceConfig
+import com.bitmovin.player.reactnative.NativeId
+import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class OfflineContentManagerBridge(
+    private val nativeId: NativeId,
+    private val context: ReactApplicationContext,
+    private val identifier: String,
+    source: SourceConfig,
+    location: String
+) : OfflineContentManagerListener {
+
+    enum class OfflineEventType(val eventName: String) {
+        ON_COMPLETED("onCompleted"),
+        ON_ERROR("onError"),
+        ON_PROGRESS("onProgress"),
+        ON_OPTIONS_AVAILABLE("onOptionsAvailable"),
+        ON_DRM_LICENSE_UPDATED("onDrmLicenseUpdated"),
+        ON_SUSPENDED("onSuspended"),
+        ON_RESUMED("onResumed"),
+        ON_CANCELED("onCanceled")
+    }
+
+    val offlineContentManager: OfflineContentManager = OfflineContentManager.getOfflineContentManager(
+        source, location, identifier, this, context
+    )
+    private var contentOptions: OfflineContentOptions? = null
+
+    val state: OfflineOptionEntryState
+        get() = aggregateState(contentOptions)
+
+    fun getOptions() {
+        offlineContentManager.getOptions()
+    }
+
+    /**
+     * Process the `OfflineDownloadRequest`.
+     * The `OfflineContentOptions` are stored in memory in this class because they can not be constructed to pass to the process call.
+     * We're copying the iOS interface for the `minimumBitrate` so that react-native will have a consistent interface.
+     * When no `minimumBitrate` is provided, the highest bitrate will be downloaded.
+     */
+    fun process(request: OfflineDownloadRequest) {
+        if (contentOptions != null) {
+            val sortedVideoOptions = contentOptions!!.videoOptions
+                    .sortedBy { option -> option.bitrate }
+            if (request.minimumBitrate == null) {
+                sortedVideoOptions.lastOrNull()
+            } else {
+                sortedVideoOptions
+                        .firstOrNull { option -> option.bitrate >= request.minimumBitrate }
+            }?.apply {
+                action = OfflineOptionEntryAction.Download
+            }
+            appliesDownloadActions(request.audioOptionIds, contentOptions!!.audioOptions)
+            appliesDownloadActions(request.textOptionIds, contentOptions!!.textOptions)
+
+            offlineContentManager.process(contentOptions!!)
+        }
+    }
+
+    private fun appliesDownloadActions(
+        ids: List<String?>?,
+        potentialOptions: List<OfflineOptionEntry>
+    ) {
+        if (ids.isNullOrEmpty()) {
+            return
+        }
+
+        ids.forEach { idToDownload ->
+            potentialOptions.forEach { option ->
+                if (idToDownload == option.id && option.action !== OfflineOptionEntryAction.Download) {
+                    option.action = OfflineOptionEntryAction.Download
+                }
+            }
+        }
+    }
+
+    fun resume() {
+        offlineContentManager.resume()
+    }
+
+    fun suspend() {
+        offlineContentManager.suspend()
+    }
+
+    fun cancelDownload() {
+        suspend()
+        deleteAll()
+        sendEvent(OfflineEventType.ON_CANCELED)
+    }
+
+    fun deleteAll() {
+        offlineContentManager.deleteAll()
+    }
+
+    fun downloadLicense() {
+        offlineContentManager.downloadLicense()
+    }
+
+    fun releaseLicense() {
+        offlineContentManager.releaseLicense()
+    }
+
+    fun renewOfflineLicense() {
+        offlineContentManager.renewOfflineLicense()
+    }
+
+    fun release() {
+        offlineContentManager.release()
+    }
+
+    /**
+     * Produces an aggregate state of the `OfflineOptionEntryState` for the `OfflineContentOptions`
+     * iOS does not have granular data access to the states of each entry, but instead provides a single aggregate status.
+     * Adding this produces a consistent interface in the react-native layer.
+     */
+    private fun aggregateState(options: OfflineContentOptions?): OfflineOptionEntryState {
+        val allOptions = mutableListOf<OfflineOptionEntry>()
+        options?.videoOptions?.let { allOptions.addAll(it) }
+        options?.audioOptions?.let { allOptions.addAll(it) }
+        options?.textOptions?.let { allOptions.addAll(it) }
+        val trackableStates =
+            listOf(OfflineOptionEntryState.Suspended, OfflineOptionEntryState.Downloading)
+
+        var state = allOptions.firstOrNull { trackableStates.contains(it.state) }?.state
+
+        if (state == null && allOptions.any { it.state == OfflineOptionEntryState.Downloaded }) {
+            state = OfflineOptionEntryState.Downloaded
+        }
+
+
+        return state ?: OfflineOptionEntryState.NotDownloaded
+    }
+
+    /**
+     * Called when a process call has completed.
+     */
+    override fun onCompleted(source: SourceConfig?, options: OfflineContentOptions?) {
+        this.contentOptions = options
+        sendEvent(OfflineEventType.ON_COMPLETED, Arguments.createMap().apply {
+            putMap("options", JsonConverter.toJson(options))
+        })
+    }
+
+    /**
+     * Called when an error occurs.
+     */
+    override fun onError(source: SourceConfig?, event: ErrorEvent?) {
+        sendEvent(OfflineEventType.ON_ERROR, Arguments.createMap().apply {
+            event?.code?.value?.let { putInt("code", it) }
+            putString("message", event?.message)
+        })
+    }
+
+    /**
+     * Called when the progress for a process call changes.
+     */
+    override fun onProgress(source: SourceConfig?, progress: Float) {
+        sendEvent(OfflineEventType.ON_PROGRESS, Arguments.createMap().apply {
+            putDouble("progress", progress.toDouble())
+        })
+    }
+
+    /**
+     * Called after a getOptions or when am OfflineOptionEntry has been updated during a process call.
+     */
+    override fun onOptionsAvailable(source: SourceConfig?, options: OfflineContentOptions?) {
+        this.contentOptions = options
+        sendEvent(OfflineEventType.ON_OPTIONS_AVAILABLE, Arguments.createMap().apply {
+            putMap("options", JsonConverter.toJson(options))
+        })
+    }
+
+    /**
+     * Called when the DRM license was updated.
+     */
+    override fun onDrmLicenseUpdated(source: SourceConfig?) {
+        sendEvent(OfflineEventType.ON_DRM_LICENSE_UPDATED)
+    }
+
+    /**
+     * Called when all actions have been suspended.
+     */
+    override fun onSuspended(source: SourceConfig?) {
+        sendEvent(OfflineEventType.ON_SUSPENDED)
+    }
+
+    /**
+     * Called when all actions have been resumed.
+     */
+    override fun onResumed(source: SourceConfig?) {
+        sendEvent(OfflineEventType.ON_RESUMED)
+    }
+
+    private fun sendEvent(eventType: OfflineEventType, event: WritableMap? = null) {
+        val e = event ?: Arguments.createMap()
+        e.putString("nativeId", nativeId)
+        e.putString("identifier", identifier)
+        e.putString("eventType", eventType.eventName)
+        e.putString("state", aggregateState(contentOptions).name)
+
+        context
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("BitmovinOfflineEvent", e)
+    }
+}

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

@@ -0,0 +1,7 @@
+package com.bitmovin.player.reactnative.offline
+
+data class OfflineDownloadRequest(
+    val minimumBitrate: Int?,
+    val audioOptionIds: List<String>?,
+    val textOptionIds: List<String>?
+)

package/ios/DrmModule.swift

@@ -104,7 +104,7 @@ class DrmModule: NSObject, RCTBridgeModule {
      Note this function is **synchronous** and **blocks** the JS thread. It's important that it stays this way, otherwise we wouldn't be able to return
      the computed JS message from inside the `fairplayConfig.prepareMessage` Swift closure.
      
-     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's ncecessary to add a return type and a return
+     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's necessary to add a return type and a return
      value (even if it's a void method like in this case) or a crash happens. So the type `Any?` and return value `nil` were used here (it could be any value).
      */
     @objc(setPreparedMessage:message:)
@@ -119,7 +119,7 @@ class DrmModule: NSObject, RCTBridgeModule {
      Note this function is **synchronous** and **blocks** the JS thread. It's important that it stays this way, otherwise we wouldn't be able to return
      the computed JS message from inside the `fairplayConfig.prepareSyncMessage` Swift closure.
      
-     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's ncecessary to add a return type and a return
+     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's necessary to add a return type and a return
      value (even if it's a void method like in this case) or a crash happens. So the type `Any?` and return value `nil` were used here (it could be any value).
      */
     @objc(setPreparedSyncMessage:syncMessage:)
@@ -134,7 +134,7 @@ class DrmModule: NSObject, RCTBridgeModule {
      Note this function is **synchronous** and **blocks** the JS thread. It's important that it stays this way, otherwise we wouldn't be able to return
      the computed JS message from inside the `fairplayConfig.prepareLicense` Swift closure.
      
-     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's ncecessary to add a return type and a return value
+     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's necessary to add a return type and a return value
      (even if it's a void method like in this case) or a crash happens. So the type `Any?` and return value `nil` were used here (it could be any value).
      */
     @objc(setPreparedLicense:license:)
@@ -149,7 +149,7 @@ class DrmModule: NSObject, RCTBridgeModule {
      Note this function is **synchronous** and **blocks** the JS thread. It's important that it stays this way, otherwise we wouldn't be able to return
      the computed JS message from inside the `fairplayConfig.prepareLicenseServerUrl` Swift closure.
      
-     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's ncecessary to add a return type and a return value
+     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's necessary to add a return type and a return value
      (even if it's a void method like in this case) or a crash happens. So the type `Any?` and return value `nil` were used here (it could be any value).
      */
     @objc(setPreparedLicenseServerUrl:url:)
@@ -164,7 +164,7 @@ class DrmModule: NSObject, RCTBridgeModule {
      Note this function is **synchronous** and **blocks** the JS thread. It's important that it stays this way, otherwise we wouldn't be able to return
      the computed JS message from inside the `fairplayConfig.prepareContentId` Swift closure.
      
-     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's ncecessary to add a return type and a return value
+     Also, since RN has some limitations regarding the definition of sync JS methods from Swift, it's necessary to add a return type and a return value
      (even if it's a void method like in this case) or a crash happens. So the type `Any?` and return value `nil` were used here (it could be any value).
      */
     @objc(setPreparedContentId:contentId:)

package/ios/OfflineContentManagerBridge.swift

@@ -0,0 +1,141 @@
+#if os(iOS)
+import Foundation
+import BitmovinPlayer
+
+class OfflineContentManagerBridge: NSObject, OfflineContentManagerListener {
+    enum EventType: String {
+        case onCompleted = "onCompleted"
+        case onError = "onError"
+        case onProgress = "onProgress"
+        case onOptionsAvailable = "onOptionsAvailable"
+        case onDrmLicenseUpdated = "onDrmLicenseUpdated"
+        case onSuspended = "onSuspended"
+        case onResumed = "onResumed"
+        case onCanceled = "onCanceled"
+        case onDrmLicenseExpired = "onDrmLicenseExpired"
+    }
+
+    let offlineContentManager: OfflineContentManager
+    let eventEmitter: RCTEventEmitter?
+    let nativeId: NativeId
+    let identifier: String
+    var currentTrackSelection: OfflineTrackSelection? = nil
+
+    init(
+        forManager offlineContentManager: OfflineContentManager,
+        eventEmitter: RCTEventEmitter,
+        nativeId: NativeId,
+        identifier: String
+    ) {
+        self.offlineContentManager = offlineContentManager
+        self.eventEmitter = eventEmitter
+        self.nativeId = nativeId
+        self.identifier = identifier
+        super.init()
+
+        offlineContentManager.add(listener: self)
+    }
+
+    func release() {
+        offlineContentManager.remove(listener: self)
+        currentTrackSelection = nil
+    }
+
+    func fetchAvailableTracks() {
+        offlineContentManager.fetchAvailableTracks()
+
+        sendOfflineEvent(eventType: .onOptionsAvailable)
+    }
+
+    /**
+     Called when an error occurs.
+     */
+    func onOfflineError(_ event: OfflineErrorEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onError, body: [
+            "code": event.code,
+            "message": event.message
+        ])
+    }
+
+    /**
+     Called after a getOptions or when am OfflineOptionEntry has been updated during a process call.
+     */
+    func onAvailableTracksFetched(_ event: AvailableTracksFetchedEvent, offlineContentManager: OfflineContentManager) {
+        currentTrackSelection = event.tracks
+
+        sendOfflineEvent(eventType: .onOptionsAvailable, body: [
+            "options": RCTConvert.toJson(offlineTracks: event.tracks)
+        ])
+    }
+
+    /**
+     Called when a process call has completed.
+     */
+    func onContentDownloadFinished(_ event: ContentDownloadFinishedEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onCompleted, body: [
+            "options": RCTConvert.toJson(offlineTracks: currentTrackSelection)
+        ])
+    }
+
+    /**
+     Called when the progress for a process call changes.
+     */
+    func onContentDownloadProgressChanged(_ event: ContentDownloadProgressChangedEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onProgress, body: [
+            "progress": event.progress
+        ])
+    }
+
+    /**
+     Called when all actions have been suspended.
+     */
+    func onContentDownloadSuspended(_ event: ContentDownloadSuspendedEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onSuspended)
+    }
+
+    /**
+     Called when all actions have been resumed.
+     */
+    func onContentDownloadResumed(_ event: ContentDownloadResumedEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onResumed)
+    }
+
+    /**
+     Called when the download of the media content was canceled by the user and all partially downloaded content has been deleted from disk.
+     */
+    func onContentDownloadCanceled(_ event: ContentDownloadCanceledEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onCanceled)
+    }
+
+    /**
+     Called when the DRM license was renewed.
+     */
+    func onOfflineContentLicenseRenewed(_ event: OfflineContentLicenseRenewedEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onDrmLicenseUpdated)
+    }
+
+    /**
+     Called on every call to OfflineContentManager.createOfflineSourceConfig(restrictedToAssetCache:) if it is DRM protected and the offline DRM license has expired.
+     */
+    func onOfflineContentLicenseExpired(_ event: OfflineContentLicenseExpiredEvent, offlineContentManager: OfflineContentManager) {
+        sendOfflineEvent(eventType: .onDrmLicenseExpired)
+    }
+
+    private func sendOfflineEvent(eventType: EventType, body: [String: Any?] = [:]) {
+        var baseEvent: [String: Any?] = [
+            "nativeId": nativeId,
+            "identifier": identifier,
+            "eventType": eventType.rawValue,
+            "state": RCTConvert.toJson(offlineState: offlineContentManager.offlineState)
+        ]
+
+        var eventBody = baseEvent.merging(body) { (current, _) in current }
+
+        do {
+            try eventEmitter?.sendEvent(withName: "BitmovinOfflineEvent", body: eventBody)
+        } catch let error as NSError {
+            print(error)
+        }
+    }
+}
+#endif

package/ios/OfflineModule.m

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(BitmovinOfflineModule, OfflineModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initWithConfig:(NSString *)nativeId config:(nullable id)config drmNativeId:(nullable NSString *)drmNativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getState:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getOptions:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(download:(NSString *)nativeId request:(nullable id)request resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(resume:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(suspend:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(cancelDownload:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(usedStorage:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(deleteAll:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(downloadLicense:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(renewOfflineLicense:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(release:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(releaseLicense:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+@end