bitmovin-player-react-native 0.44.1-alpha.0 → 1.0.0-alpha.0

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

@@ -6,11 +6,10 @@ import android.content.Intent
 import android.content.ServiceConnection
 import android.os.IBinder
 import com.bitmovin.player.api.Player
-import com.bitmovin.player.reactnative.extensions.playerModule
 import com.bitmovin.player.reactnative.services.MediaSessionPlaybackService
-import com.facebook.react.bridge.*
+import expo.modules.kotlin.AppContext
 
-class MediaSessionPlaybackManager(val context: ReactApplicationContext) {
+class MediaSessionPlaybackManager(val appContext: AppContext) {
     private var serviceBinder: MediaSessionPlaybackService.ServiceBinder? = null
     private var playerId: NativeId? = null
     val player: Player?
@@ -33,6 +32,8 @@ class MediaSessionPlaybackManager(val context: ReactApplicationContext) {
     fun setupMediaSessionPlayback(playerId: NativeId) {
         this.playerId = playerId
 
+        val context = appContext.reactContext
+            ?: throw IllegalStateException("React context is not available")
         val intent = Intent(context, MediaSessionPlaybackService::class.java)
         intent.action = Intent.ACTION_MEDIA_BUTTON
         val connection: ServiceConnection = MediaSessionPlaybackServiceConnection()
@@ -49,7 +50,6 @@ class MediaSessionPlaybackManager(val context: ReactApplicationContext) {
 
     private fun getPlayer(
         nativeId: NativeId? = playerId,
-        playerModule: PlayerModule? = context.playerModule,
-    ): Player = nativeId?.let { playerModule?.getPlayerOrNull(nativeId) }
+    ): Player = playerId?.let { appContext.registry.getModule<PlayerModule>()?.getPlayerOrNull(it) }
         ?: throw IllegalArgumentException("Invalid PlayerId $nativeId")
 }

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

@@ -3,6 +3,7 @@ package com.bitmovin.player.reactnative
 import android.util.Log
 import androidx.concurrent.futures.CallbackToFutureAdapter
 import androidx.concurrent.futures.CallbackToFutureAdapter.Completer
+import androidx.core.os.bundleOf
 import com.bitmovin.player.api.network.HttpRequest
 import com.bitmovin.player.api.network.HttpRequestType
 import com.bitmovin.player.api.network.HttpResponse
@@ -13,16 +14,17 @@ import com.bitmovin.player.reactnative.converter.toHttpRequest
 import com.bitmovin.player.reactnative.converter.toHttpResponse
 import com.bitmovin.player.reactnative.converter.toJson
 import com.bitmovin.player.reactnative.converter.toNetworkConfig
-import com.facebook.react.bridge.*
-import com.facebook.react.module.annotations.ReactModule
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.Future
 
-private const val MODULE_NAME = "NetworkModule"
-
-@ReactModule(name = MODULE_NAME)
-class NetworkModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
-
+/**
+ * Expo module for NetworkConfig management with HTTP request/response preprocessing.
+ * Handles bidirectional communication between native code and JavaScript for network operations.
+ */
+class NetworkModule : Module() {
     /**
      * In-memory mapping from `nativeId`s to `NetworkConfig` instances.
      */
@@ -30,49 +32,84 @@ class NetworkModule(context: ReactApplicationContext) : BitmovinBaseModule(conte
     private val preprocessHttpRequestCompleters = ConcurrentHashMap<String, Completer<HttpRequest>>()
     private val preprocessHttpResponseCompleters = ConcurrentHashMap<String, Completer<HttpResponse>>()
 
-    override fun getName() = MODULE_NAME
+    override fun definition() = ModuleDefinition {
+        Name("NetworkModule")
 
-    fun getConfig(nativeId: NativeId?): NetworkConfig? = nativeId?.let { networkConfigs[it] }
+        OnDestroy {
+            networkConfigs.clear()
+            preprocessHttpRequestCompleters.clear()
+            preprocessHttpResponseCompleters.clear()
+        }
 
-    @ReactMethod
-    fun initWithConfig(nativeId: NativeId, config: ReadableMap, promise: Promise) {
-        promise.unit.resolveOnUiThread {
+        Events("onPreprocessHttpRequest", "onPreprocessHttpResponse")
+
+        AsyncFunction("initializeWithConfig") { nativeId: NativeId, config: Map<String, Any?>, promise: Promise ->
             if (networkConfigs.containsKey(nativeId)) {
-                return@resolveOnUiThread
+                promise.resolve(null)
+                return@AsyncFunction
+            }
+
+            try {
+                val networkConfig = config.toNetworkConfig()
+                networkConfigs[nativeId] = networkConfig
+                initConfigBlocks(nativeId, config)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("NetworkError", "Failed to initialize network config", e)
+            }
+        }
+
+        AsyncFunction("destroy") { nativeId: NativeId ->
+            networkConfigs.remove(nativeId)
+
+            // Clean up completion handlers
+            preprocessHttpRequestCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
+                preprocessHttpRequestCompleters.remove(it)
+            }
+            preprocessHttpResponseCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
+                preprocessHttpResponseCompleters.remove(it)
             }
-            val networkConfig = config.toNetworkConfig()
-            networkConfigs[nativeId] = networkConfig
-            initConfigBlocks(nativeId, config)
         }
-    }
 
-    @ReactMethod
-    fun destroy(nativeId: NativeId) {
-        networkConfigs.remove(nativeId)
-        preprocessHttpRequestCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
-            preprocessHttpRequestCompleters.remove(it)
+        AsyncFunction("setPreprocessedHttpRequest") { requestId: String, request: Map<String, Any?> ->
+            val completer = preprocessHttpRequestCompleters.remove(requestId)
+            if (completer == null) {
+                Log.e("NetworkModule", "Completer is null for requestId: $requestId, this can cause stuck network requests")
+                return@AsyncFunction
+            }
+            completer.set(request.toHttpRequest())
         }
-        preprocessHttpResponseCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
-            preprocessHttpResponseCompleters.remove(it)
+
+        AsyncFunction("setPreprocessedHttpResponse") { responseId: String, response: Map<String, Any?> ->
+            preprocessHttpResponseCompleters[responseId]?.set(response.toHttpResponse())
+            preprocessHttpResponseCompleters.remove(responseId)
         }
     }
 
-    private fun initConfigBlocks(nativeId: String, config: ReadableMap) {
-        initPreprocessHttpRequest(nativeId, networkConfigJson = config)
-        initPreprocessHttpResponse(nativeId, networkConfigJson = config)
+    /**
+     * Retrieves the NetworkConfig instance for the given nativeId.
+     * This method maintains the same static access pattern as the legacy module.
+     */
+    fun getConfig(nativeId: NativeId?): NetworkConfig? = nativeId?.let { networkConfigs[it] }
+
+    private fun initConfigBlocks(nativeId: NativeId, config: Map<String, Any?>) {
+        initPreprocessHttpRequest(nativeId, config)
+        initPreprocessHttpResponse(nativeId, config)
     }
 
-    private fun initPreprocessHttpRequest(nativeId: NativeId, networkConfigJson: ReadableMap) {
+    private fun initPreprocessHttpRequest(nativeId: NativeId, networkConfigJson: Map<String, Any?>) {
         val networkConfig = getConfig(nativeId) ?: return
-        if (!networkConfigJson.hasKey("preprocessHttpRequest")) return
+        if (!networkConfigJson.containsKey("preprocessHttpRequest")) return
+
         networkConfig.preprocessHttpRequestCallback = PreprocessHttpRequestCallback { type, request ->
             preprocessHttpRequestFromJS(nativeId, type, request)
         }
     }
 
-    private fun initPreprocessHttpResponse(nativeId: NativeId, networkConfigJson: ReadableMap) {
+    private fun initPreprocessHttpResponse(nativeId: NativeId, networkConfigJson: Map<String, Any?>) {
         val networkConfig = getConfig(nativeId) ?: return
-        if (!networkConfigJson.hasKey("preprocessHttpResponse")) return
+        if (!networkConfigJson.containsKey("preprocessHttpResponse")) return
+
         networkConfig.preprocessHttpResponseCallback = PreprocessHttpResponseCallback { type, response ->
             preprocessHttpResponseFromJS(nativeId, type, response)
         }
@@ -84,25 +121,28 @@ class NetworkModule(context: ReactApplicationContext) : BitmovinBaseModule(conte
         request: HttpRequest,
     ): Future<HttpRequest> {
         val requestId = "$nativeId@${System.identityHashCode(request)}"
-        val args = Arguments.createArray()
-        args.pushString(requestId)
-        args.pushString(type.toJson())
-        args.pushMap(request.toJson())
+        val args = mapOf(
+            "requestId" to requestId,
+            "type" to type.toJson(),
+            "request" to request.toJson(),
+        )
 
         return CallbackToFutureAdapter.getFuture { completer ->
             preprocessHttpRequestCompleters[requestId] = completer
-            context.catalystInstance.callFunction("Network-$nativeId", "onPreprocessHttpRequest", args as NativeArray)
-        }
-    }
 
-    @ReactMethod
-    fun setPreprocessedHttpRequest(requestId: String, request: ReadableMap) {
-        val completer = preprocessHttpRequestCompleters.remove(requestId)
-        if (completer == null) {
-            Log.e(MODULE_NAME, "Completer is null for requestId: $requestId, this can cause stuck network requests")
-            return
+            // Send event to TypeScript using Expo module event system
+            sendEvent(
+                "onPreprocessHttpRequest",
+                bundleOf(
+                    "nativeId" to nativeId,
+                    "requestId" to requestId,
+                    "type" to type.toJson(),
+                    "request" to request.toJson(),
+                ),
+            )
+
+            return@getFuture "NetworkModule-preprocessHttpRequest-$requestId"
         }
-        completer.set(request.toHttpRequest())
     }
 
     private fun preprocessHttpResponseFromJS(
@@ -111,20 +151,22 @@ class NetworkModule(context: ReactApplicationContext) : BitmovinBaseModule(conte
         response: HttpResponse,
     ): Future<HttpResponse> {
         val responseId = "$nativeId@${System.identityHashCode(response)}"
-        val args = Arguments.createArray()
-        args.pushString(responseId)
-        args.pushString(type.toJson())
-        args.pushMap(response.toJson())
 
         return CallbackToFutureAdapter.getFuture { completer ->
             preprocessHttpResponseCompleters[responseId] = completer
-            context.catalystInstance.callFunction("Network-$nativeId", "onPreprocessHttpResponse", args as NativeArray)
-        }
-    }
 
-    @ReactMethod
-    fun setPreprocessedHttpResponse(responseId: String, response: ReadableMap) {
-        preprocessHttpResponseCompleters[responseId]?.set(response.toHttpResponse())
-        preprocessHttpResponseCompleters.remove(responseId)
+            // Send event to TypeScript using Expo module event system
+            sendEvent(
+                "onPreprocessHttpResponse",
+                bundleOf(
+                    "nativeId" to nativeId,
+                    "responseId" to responseId,
+                    "type" to type.toJson(),
+                    "response" to response.toJson(),
+                ),
+            )
+
+            return@getFuture "NetworkModule-preprocessHttpResponse-$responseId"
+        }
     }
 }

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

@@ -2,247 +2,193 @@ package com.bitmovin.player.reactnative
 
 import com.bitmovin.player.api.offline.options.OfflineOptionEntryState
 import com.bitmovin.player.reactnative.converter.toSourceConfig
-import com.bitmovin.player.reactnative.extensions.drmModule
-import com.bitmovin.player.reactnative.extensions.getIntOrNull
-import com.bitmovin.player.reactnative.extensions.getStringArray
 import com.bitmovin.player.reactnative.offline.OfflineContentManagerBridge
 import com.bitmovin.player.reactnative.offline.OfflineDownloadRequest
-import com.facebook.react.bridge.*
-import com.facebook.react.module.annotations.ReactModule
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
 import java.security.InvalidParameterException
 
-private const val OFFLINE_MODULE = "BitmovinOfflineModule"
-
-@ReactModule(name = OFFLINE_MODULE)
-class OfflineModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
+class OfflineModule : Module() {
 
     /**
-     * In-memory mapping from `nativeId`s to `OfflineManager` instances.
+     * In-memory mapping from `nativeId`s to `OfflineContentManagerBridge` instances.
+     * This must match the Registry pattern from legacy OfflineModule
      */
     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.
-     */
-    fun getOfflineContentManagerBridgeOrNull(
-        nativeId: NativeId,
-    ): OfflineContentManagerBridge? = offlineContentManagerBridges[nativeId]
+    override fun definition() = ModuleDefinition {
+        Name("OfflineModule")
 
-    private fun RejectPromiseOnExceptionBlock.getOfflineContentManagerBridge(
-        nativeId: NativeId,
-    ): OfflineContentManagerBridge = offlineContentManagerBridges[nativeId]
-        ?: throw IllegalArgumentException("No offline content manager bridge for id $nativeId")
+        Events("onBitmovinOfflineEvent")
 
-    /**
-     * Callback when a new NativeEventEmitter is created from the Typescript layer.
-     */
-    @ReactMethod
-    fun addListener(eventName: String?) {
-        // NO-OP
-    }
+        OnCreate {
+            // Module initialization
+        }
 
-    /**
-     * Callback when a NativeEventEmitter is removed from the Typescript layer.
-     */
-    @ReactMethod
-    fun removeListeners(count: Int?) {
-        // NO-OP
-    }
+        OnDestroy {
+            // Clean up offline content managers
+            offlineContentManagerBridges.clear()
+        }
 
-    /**
-     * 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) {
-        promise.unit.resolveOnUiThread {
+        AsyncFunction("initializeWithConfig") { nativeId: NativeId, config: Map<String, Any?>?, drmNativeId: NativeId? ->
             if (offlineContentManagerBridges.containsKey(nativeId)) {
-                throw InvalidParameterException("content manager bridge id already exists: $nativeId")
+                throw OfflineException.ManagerAlreadyExists(nativeId)
             }
-            val identifier = config?.getString("identifier")
-                ?.takeIf { it.isNotEmpty() } ?: throw IllegalArgumentException("invalid identifier")
 
-            val sourceConfig = config.getMap("sourceConfig")?.toSourceConfig()
-                ?: throw IllegalArgumentException("Invalid source config")
+            val identifier = config?.get("identifier") as? String
+                ?: throw OfflineException.InvalidIdentifier()
+
+            val sourceConfig = (config["sourceConfig"] as? Map<String, Any?>)?.toSourceConfig()
+                ?: throw OfflineException.InvalidSourceConfig()
 
-            sourceConfig.drmConfig = context.drmModule?.getConfig(drmNativeId)
+            // Get DRM config from DrmModule if available
+            sourceConfig.drmConfig = appContext.registry.getModule<DrmModule>()?.getConfig(drmNativeId)
+
+            val context = appContext.reactContext
+                ?: throw InvalidParameterException("ReactApplicationContext is not available")
 
             offlineContentManagerBridges[nativeId] = OfflineContentManagerBridge(
                 nativeId,
                 context,
+                this@OfflineModule,
                 identifier,
                 sourceConfig,
-                context.cacheDir.path,
+                appContext.cacheDirectory.path,
             )
         }
-    }
 
-    @ReactMethod
-    fun getState(nativeId: NativeId, promise: Promise) {
-        promise.string.resolveWithBridge(nativeId) {
-            state.name
+        /**
+         * Gets the current state of the `OfflineContentManager`
+         */
+        AsyncFunction("getState") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            getOptions()
+        /**
+         * 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`.
+         */
+        AsyncFunction("getOptions") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).getOptions()
         }
-    }
 
-    /**
-     * 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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            when (state) {
-                OfflineOptionEntryState.Downloaded -> throw IllegalStateException("Download already completed")
-                OfflineOptionEntryState.Downloading, OfflineOptionEntryState.Failed -> throw IllegalStateException(
-                    "Download already in progress",
-                )
-                OfflineOptionEntryState.Suspended -> throw IllegalStateException("Download is suspended")
+        /**
+         * Enqueues downloads according to the `OfflineDownloadRequest`.
+         * The promise will reject in the event of null or invalid request parameters.
+         */
+        AsyncFunction("download") { nativeId: NativeId, request: Map<String, Any?> ->
+            val bridge = getOfflineContentManagerBridge(nativeId)
+
+            when (bridge.state) {
+                OfflineOptionEntryState.Downloaded -> throw OfflineException.DownloadAlreadyCompleted()
+                OfflineOptionEntryState.Downloading, OfflineOptionEntryState.Failed ->
+                    throw OfflineException.DownloadInProgress()
+                OfflineOptionEntryState.Suspended -> throw OfflineException.DownloadSuspended()
                 else -> {}
             }
-            val minimumBitRate = request.getIntOrNull("minimumBitrate")?.also {
-                if (it < 0) throw IllegalArgumentException("Invalid download request")
+
+            val minimumBitRate = request["minimumBitrate"] as? Int
+            if (minimumBitRate != null && minimumBitRate < 0) {
+                throw OfflineException.InvalidRequest()
             }
-            val audioOptionIds = request.getStringArray("audioOptionIds")?.filterNotNull()
-            val textOptionIds = request.getStringArray("textOptionIds")?.filterNotNull()
 
-            process(OfflineDownloadRequest(minimumBitRate, audioOptionIds, textOptionIds))
+            val audioOptionIds = (request["audioOptionIds"] as? List<*>)?.filterIsInstance<String>()
+            val textOptionIds = (request["textOptionIds"] as? List<*>)?.filterIsInstance<String>()
+
+            bridge.process(OfflineDownloadRequest(minimumBitRate, audioOptionIds, textOptionIds))
         }
-    }
 
-    /**
-     * Resumes all suspended actions.
-     * @param nativeId Target offline manager.
-     */
-    @ReactMethod
-    fun resume(nativeId: NativeId, promise: Promise) {
-        promise.unit.resolveWithBridge(nativeId) {
-            resume()
+        /**
+         * Resumes all suspended actions.
+         */
+        AsyncFunction("resume") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).resume()
         }
-    }
 
-    /**
-     * Suspends all active actions.
-     * @param nativeId Target offline manager.
-     */
-    @ReactMethod
-    fun suspend(nativeId: NativeId, promise: Promise) {
-        promise.unit.resolveWithBridge(nativeId) {
-            suspend()
+        /**
+         * Suspends all active actions.
+         */
+        AsyncFunction("suspend") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).suspend()
         }
-    }
 
-    /**
-     * Cancels and deletes the current download.
-     * @param nativeId Target offline manager.
-     */
-    @ReactMethod
-    fun cancelDownload(nativeId: NativeId, promise: Promise) {
-        promise.unit.resolveWithBridge(nativeId) {
-            cancelDownload()
+        /**
+         * Cancels and deletes the current download.
+         */
+        AsyncFunction("cancelDownload") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).cancelDownload()
         }
-    }
 
-    /**
-     * Resolve `nativeId`'s current `usedStorage`.
-     * @param nativeId Target offline manager.
-     */
-    @ReactMethod
-    fun usedStorage(nativeId: NativeId, promise: Promise) {
-        promise.double.resolveWithBridge(nativeId) {
-            offlineContentManager.usedStorage.toDouble()
+        /**
+         * Resolve `nativeId`'s current `usedStorage`.
+         */
+        AsyncFunction("usedStorage") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).offlineContentManager.usedStorage.toDouble()
         }
-    }
 
-    /**
-     * Deletes everything related to the related content ID.
-     * @param nativeId Target offline manager.
-     */
-    @ReactMethod
-    fun deleteAll(nativeId: NativeId, promise: Promise) {
-        promise.unit.resolveWithBridge(nativeId) {
-            deleteAll()
+        /**
+         * Deletes everything related to the related content ID.
+         */
+        AsyncFunction("deleteAll") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).deleteAll()
         }
-    }
 
-    /**
-     * 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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            downloadLicense()
+        /**
+         * 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`.
+         */
+        AsyncFunction("downloadLicense") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).downloadLicense()
         }
-    }
 
-    /**
-     * 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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            releaseLicense()
+        /**
+         * 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`.
+         */
+        AsyncFunction("releaseLicense") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).releaseLicense()
         }
-    }
 
-    /**
-     * 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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            renewOfflineLicense()
+        /**
+         * 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`.
+         */
+        AsyncFunction("renewOfflineLicense") { nativeId: NativeId ->
+            getOfflineContentManagerBridge(nativeId).renewOfflineLicense()
         }
-    }
 
-    /**
-     * 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) {
-        promise.unit.resolveWithBridge(nativeId) {
-            release()
+        /**
+         * 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.
+         */
+        AsyncFunction("release") { nativeId: NativeId ->
+            val bridge = getOfflineContentManagerBridge(nativeId)
+            bridge.release()
             offlineContentManagerBridges.remove(nativeId)
         }
     }
 
-    private inline fun <T> TPromise<T>.resolveWithBridge(
-        nativeId: NativeId,
-        crossinline block: OfflineContentManagerBridge.() -> T,
-    ) {
-        resolveOnCurrentThread {
-            getOfflineContentManagerBridge(nativeId).block()
-        }
+    /**
+     * Helper function to get OfflineContentManagerBridge with proper error handling
+     */
+    fun getOfflineContentManagerBridge(nativeId: NativeId): OfflineContentManagerBridge {
+        return offlineContentManagerBridges[nativeId] ?: throw OfflineException.ManagerNotFound(nativeId)
     }
 }
+
+// MARK: - Exception Definitions
+
+sealed class OfflineException(message: String) : CodedException(message) {
+    class ManagerAlreadyExists(nativeId: NativeId) : OfflineException(
+        "Content manager bridge id already exists: $nativeId",
+    )
+    class ManagerNotFound(nativeId: NativeId) : OfflineException("No offline content manager bridge for id $nativeId")
+    class InvalidIdentifier : OfflineException("Invalid identifier")
+    class InvalidSourceConfig : OfflineException("Invalid source config")
+    class InvalidRequest : OfflineException("Invalid download request")
+    class DownloadAlreadyCompleted : OfflineException("Download already completed")
+    class DownloadInProgress : OfflineException("Download already in progress")
+    class DownloadSuspended : OfflineException("Download is suspended")
+}