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

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

@@ -0,0 +1,84 @@
+package com.bitmovin.player.reactnative
+
+import androidx.core.os.bundleOf
+import com.bitmovin.player.reactnative.ui.CustomMessageHandlerBridge
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Expo module for CustomMessageHandler management with bidirectional communication.
+ * Handles synchronous and asynchronous message handling between native code and JavaScript.
+ */
+class CustomMessageHandlerModule : Module() {
+    /**
+     * In-memory mapping from `nativeId`s to `CustomMessageHandlerBridge` instances.
+     */
+    private val customMessageHandlers: Registry<CustomMessageHandlerBridge> = mutableMapOf()
+
+    /**
+     * ResultWaiter for synchronous message handling
+     */
+    private val synchronousMessageWaiter = ResultWaiter<String?>()
+
+    override fun definition() = ModuleDefinition {
+        Name("CustomMessageHandlerModule")
+
+        OnDestroy {
+            customMessageHandlers.clear()
+            synchronousMessageWaiter.clear()
+        }
+
+        Events("onReceivedSynchronousMessage", "onReceivedAsynchronousMessage")
+
+        AsyncFunction("registerHandler") { nativeId: NativeId ->
+            val customMessageHandler = customMessageHandlers[nativeId] ?: CustomMessageHandlerBridge(
+                nativeId,
+                this@CustomMessageHandlerModule,
+            )
+            customMessageHandlers[nativeId] = customMessageHandler
+        }
+
+        AsyncFunction("destroy") { nativeId: NativeId ->
+            customMessageHandlers.remove(nativeId)
+        }
+
+        AsyncFunction("onReceivedSynchronousMessageResult") { id: Int, result: String? ->
+            synchronousMessageWaiter.complete(id, result)
+        }
+
+        AsyncFunction("sendMessage") { nativeId: NativeId, message: String, data: String? ->
+            customMessageHandlers[nativeId]?.sendMessage(message, data)
+        }
+    }
+
+    fun getInstance(nativeId: NativeId?): CustomMessageHandlerBridge? = customMessageHandlers[nativeId]
+
+    fun receivedSynchronousMessage(nativeId: NativeId, message: String, data: String?): String? {
+        val (id, wait) = synchronousMessageWaiter.make(5000) // 5 second timeout
+        
+        // Send event to TypeScript using Expo module event system
+        sendEvent(
+            "onReceivedSynchronousMessage",
+            bundleOf(
+                "nativeId" to nativeId,
+                "id" to id,
+                "message" to message,
+                "data" to data,
+            ),
+        )
+
+        return wait()
+    }
+
+    fun receivedAsynchronousMessage(nativeId: NativeId, message: String, data: String?) {
+        // Send event to TypeScript using Expo module event system
+        sendEvent(
+            "onReceivedAsynchronousMessage",
+            bundleOf(
+                "nativeId" to nativeId,
+                "message" to message,
+                "data" to data,
+            ),
+        )
+    }
+}

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

@@ -1,22 +1,14 @@
 package com.bitmovin.player.reactnative
 
 import com.bitmovin.player.api.DebugConfig
-import com.facebook.react.bridge.*
-import com.facebook.react.module.annotations.ReactModule
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
 
-private const val MODULE_NAME = "DebugModule"
+class DebugModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("DebugModule")
 
-@ReactModule(name = MODULE_NAME)
-class DebugModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
-    override fun getName() = MODULE_NAME
-
-    /**
-     * Enable/disable verbose logging for the console logger.
-     * @param enabled Whether to set verbose logging as enabled or disabled.
-     */
-    @ReactMethod
-    fun setDebugLoggingEnabled(enabled: Boolean, promise: Promise) {
-        promise.unit.resolveOnUiThread {
+        AsyncFunction("setDebugLoggingEnabled") { enabled: Boolean ->
             DebugConfig.isLoggingEnabled = enabled
         }
     }

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

@@ -1,60 +1,95 @@
 package com.bitmovin.player.reactnative
 
 import androidx.concurrent.futures.CallbackToFutureAdapter
+import androidx.core.os.bundleOf
 import com.bitmovin.player.api.decoder.DecoderConfig
 import com.bitmovin.player.api.decoder.DecoderPriorityProvider
 import com.bitmovin.player.api.decoder.MediaCodecInfo
 import com.bitmovin.player.reactnative.converter.toJson
 import com.bitmovin.player.reactnative.converter.toMediaCodecInfoList
-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.util.concurrent.ConcurrentHashMap
 
-private const val MODULE_NAME = "DecoderConfigModule"
-
-@ReactModule(name = MODULE_NAME)
-class DecoderConfigModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
-    override fun getName() = MODULE_NAME
+class DecoderConfigModule : Module() {
 
     /**
      * In-memory mapping from `nativeId`s to `DecoderConfig` instances.
+     * This must match the Registry pattern from legacy DecoderConfigModule
      */
     private val decoderConfigs: Registry<DecoderConfig> = mutableMapOf()
     private val overrideDecoderPriorityProviderCompleters =
-        ConcurrentHashMap<NativeId, CallbackToFutureAdapter.Completer<List<MediaCodecInfo>>>()
+        ConcurrentHashMap<String, CallbackToFutureAdapter.Completer<List<MediaCodecInfo>>>()
+
+    override fun definition() = ModuleDefinition {
+        Name("DecoderConfigModule")
 
-    fun getConfig(nativeId: NativeId?): DecoderConfig? = nativeId?.let { decoderConfigs[it] }
+        Events("onOverrideDecodersPriority")
 
-    @ReactMethod
-    fun initWithConfig(nativeId: NativeId, config: ReadableMap, promise: Promise) {
-        if (decoderConfigs.containsKey(nativeId)) {
-            return
+        OnCreate {
+            // Module initialization
         }
-        if (config.getMap("playbackConfig")?.hasKey("decoderConfig") == false) {
-            return
+
+        OnDestroy {
+            decoderConfigs.clear()
+            overrideDecoderPriorityProviderCompleters.clear()
         }
 
-        val decoderConfig = DecoderConfig(
-            decoderPriorityProvider = object : DecoderPriorityProvider {
-                override fun overrideDecodersPriority(
-                    context: DecoderPriorityProvider.DecoderContext,
-                    preferredDecoders: List<MediaCodecInfo>,
-                ): List<MediaCodecInfo> {
-                    return overrideDecoderPriorityProvider(nativeId, context, preferredDecoders)
-                }
-            },
-        )
-        decoderConfigs[nativeId] = decoderConfig
-    }
+        /**
+         * Creates a new `DecoderConfig` instance inside the internal decoder configs using the provided `config` object.
+         */
+        AsyncFunction("initializeWithConfig") { nativeId: NativeId, config: Map<String, Any?> ->
+            if (decoderConfigs.containsKey(nativeId)) {
+                return@AsyncFunction
+            }
+
+            val playbackConfig = config["playbackConfig"] as? Map<String, Any?>
+            if (playbackConfig?.containsKey("decoderConfig") != true) {
+                return@AsyncFunction
+            }
 
-    @ReactMethod
-    fun destroy(nativeId: NativeId) {
-        decoderConfigs.remove(nativeId)
-        overrideDecoderPriorityProviderCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
-            overrideDecoderPriorityProviderCompleters.remove(it)
+            val decoderConfig = DecoderConfig(
+                decoderPriorityProvider = object : DecoderPriorityProvider {
+                    override fun overrideDecodersPriority(
+                        context: DecoderPriorityProvider.DecoderContext,
+                        preferredDecoders: List<MediaCodecInfo>,
+                    ): List<MediaCodecInfo> {
+                        return overrideDecoderPriorityProvider(nativeId, context, preferredDecoders)
+                    }
+                },
+            )
+            decoderConfigs[nativeId] = decoderConfig
+        }
+
+        /**
+         * Completes the decoder priority provider override process
+         */
+        AsyncFunction("overrideDecoderPriorityProviderComplete") { nativeId: NativeId,
+            response: List<Map<String, Any?>>, ->
+            val completer = overrideDecoderPriorityProviderCompleters[nativeId]
+                ?: throw DecoderConfigException.NoCompleterFound(nativeId)
+
+            val mediaCodecInfoList = response.toMediaCodecInfoList()
+            completer.set(mediaCodecInfoList)
+            overrideDecoderPriorityProviderCompleters.remove(nativeId)
+        }
+
+        /**
+         * Destroys the `DecoderConfig` instance referenced by `nativeId`
+         */
+        AsyncFunction("destroy") { nativeId: NativeId ->
+            decoderConfigs.remove(nativeId)
+            // Remove all completers that start with this nativeId
+            overrideDecoderPriorityProviderCompleters.keys.filter { it.startsWith(nativeId) }.forEach {
+                overrideDecoderPriorityProviderCompleters.remove(it)
+            }
         }
     }
 
+    /**
+     * Helper function to handle decoder priority provider override
+     */
     private fun overrideDecoderPriorityProvider(
         nativeId: NativeId,
         context: DecoderPriorityProvider.DecoderContext,
@@ -62,20 +97,30 @@ class DecoderConfigModule(context: ReactApplicationContext) : BitmovinBaseModule
     ): List<MediaCodecInfo> {
         return CallbackToFutureAdapter.getFuture { completer ->
             overrideDecoderPriorityProviderCompleters[nativeId] = completer
-            val args = Arguments.createArray()
-            args.pushMap(context.toJson())
-            args.pushArray(preferredDecoders.toJson())
-            this@DecoderConfigModule.context.catalystInstance.callFunction(
-                "DecoderConfigBridge-$nativeId",
-                "overrideDecodersPriority",
-                args as NativeArray,
+            // Send event to TypeScript with decoder context and preferred decoders
+            sendEvent(
+                "onOverrideDecodersPriority",
+                bundleOf(
+                    "nativeId" to nativeId,
+                    "context" to context.toJson(),
+                    "preferredDecoders" to preferredDecoders.map { it.toJson() },
+                ),
             )
+
+            "overrideDecoderPriorityProvider"
         }.get()
     }
 
-    @ReactMethod
-    fun overrideDecoderPriorityProviderComplete(nativeId: NativeId, response: ReadableArray) {
-        overrideDecoderPriorityProviderCompleters[nativeId]?.set(response.toMediaCodecInfoList())
-        overrideDecoderPriorityProviderCompleters.remove(nativeId)
-    }
+    val decoderConfig: DecoderConfig?
+        get() = decoderConfigs.values.firstOrNull()
+
+    fun getDecoderConfig(nativeId: NativeId): DecoderConfig? = decoderConfigs[nativeId]
+}
+
+// MARK: - Exception Definitions
+
+sealed class DecoderConfigException(message: String) : CodedException(message) {
+    class NoCompleterFound(nativeId: NativeId) : DecoderConfigException(
+        "No completer found for decoder config: $nativeId",
+    )
 }

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

@@ -1,136 +1,113 @@
 package com.bitmovin.player.reactnative
 
 import android.util.Base64
+import androidx.core.os.bundleOf
 import com.bitmovin.player.api.drm.PrepareLicenseCallback
 import com.bitmovin.player.api.drm.PrepareMessageCallback
 import com.bitmovin.player.api.drm.WidevineConfig
 import com.bitmovin.player.reactnative.converter.toWidevineConfig
-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.security.InvalidParameterException
-import java.util.concurrent.locks.Condition
-import java.util.concurrent.locks.ReentrantLock
-import kotlin.concurrent.withLock
 
 /**
  * Represents some operation that transforms data as bytes.
  */
 typealias PrepareCallback = (ByteArray) -> ByteArray
 
-private const val MODULE_NAME = "DrmModule"
-
-@ReactModule(name = MODULE_NAME)
-class DrmModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
+/**
+ * Expo module for DRM configuration management with Widevine DRM support.
+ * Handles bidirectional communication for DRM preparation callbacks.
+ */
+class DrmModule : Module() {
     /**
      * In-memory mapping from `nativeId`s to `WidevineConfig` instances.
      */
     private val drmConfigs: Registry<WidevineConfig> = mutableMapOf()
 
     /**
-     * Module's local lock object used to sync calls between Kotlin and JS.
+     * Shared ResultWaiter for all DRM callbacks
      */
-    private val lock = ReentrantLock()
+    private val waiter = ResultWaiter<String>()
 
-    /**
-     * Mapping between an object's `nativeId` and the value that'll be returned by its `prepareMessage` callback.
-     */
-    private val preparedMessages: Registry<String> = mutableMapOf()
+    override fun definition() = ModuleDefinition {
+        Name("DrmModule")
 
-    /**
-     *  Lock condition used to sync read/write operations on `preparedMessages`.
-     */
-    private val preparedMessagesCondition = lock.newCondition()
+        OnDestroy {
+            drmConfigs.clear()
+            waiter.clear()
+        }
 
-    /**
-     * Mapping between an object's `nativeId` and the value that'll be returned by its `prepareLicense` callback.
-     */
-    private val preparedLicenses: Registry<String> = mutableMapOf()
+        Events("onPrepareMessage", "onPrepareLicense")
 
-    /**
-     *  Lock condition used to sync read/write operations on `preparedMessages`.
-     */
-    private val preparedLicensesCondition = lock.newCondition()
+        AsyncFunction("initializeWithConfig") { nativeId: NativeId, config: Map<String, Any?>, promise: Promise ->
+            if (drmConfigs.containsKey(nativeId)) {
+                promise.reject("DrmError", "NativeId already exists $nativeId", null)
+                return@AsyncFunction
+            }
 
-    /**
-     * JS exported module name.
-     */
-    override fun getName() = MODULE_NAME
+            try {
+                val widevineConfig = config.toWidevineConfig() ?: throw InvalidParameterException(
+                    "Invalid widevine config",
+                )
+                widevineConfig.prepareMessageCallback = buildPrepareMessageCallback(nativeId, config)
+                widevineConfig.prepareLicenseCallback = buildPrepareLicense(nativeId, config)
+                drmConfigs[nativeId] = widevineConfig
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("DrmError", "Failed to initialize DRM config", e)
+            }
+        }
 
-    /**
-     * Fetches the `WidevineConfig` instance associated with `nativeId` from internal drmConfigs.
-     * @param nativeId `WidevineConfig` instance ID.
-     * @return The associated `WidevineConfig` instance or `null`.
-     */
-    fun getConfig(nativeId: NativeId?): WidevineConfig? {
-        if (nativeId == null) {
-            return null
+        AsyncFunction("destroy") { nativeId: NativeId ->
+            drmConfigs.remove(nativeId)
         }
-        return drmConfigs[nativeId]
-    }
 
-    /**
-     * Creates a new `WidevineConfig` instance inside the internal drmConfigs using the provided `config` object.
-     * @param nativeId ID to associate with the `WidevineConfig` instance.
-     * @param config `DrmConfig` object received from JS.
-     */
-    @ReactMethod
-    fun initWithConfig(nativeId: NativeId, config: ReadableMap, promise: Promise) {
-        promise.unit.resolveOnUiThread {
-            if (drmConfigs.containsKey(nativeId)) {
-                throw InvalidParameterException("NativeId already exists $nativeId")
-            }
-            val widevineConfig = config.toWidevineConfig() ?: throw InvalidParameterException("Invalid widevine config")
-            widevineConfig.prepareMessageCallback = buildPrepareMessageCallback(nativeId, config)
-            widevineConfig.prepareLicenseCallback = buildPrepareLicense(nativeId, config)
-            drmConfigs[nativeId] = widevineConfig
+        Function("setPreparedMessage") { id: Int, message: String ->
+            waiter.complete(id, message)
         }
-    }
 
-    /**
-     * Removes the `WidevineConfig` instance associated with `nativeId` from the internal drmConfigs.
-     * @param nativeId `WidevineConfig` to be disposed.
-     */
-    @ReactMethod
-    fun destroy(nativeId: NativeId) {
-        drmConfigs.remove(nativeId)
-    }
+        Function("setPreparedLicense") { id: Int, license: String ->
+            waiter.complete(id, license)
+        }
 
-    /**
-     * Function called from JS to store the computed `prepareMessage` return value for `nativeId`.
-     */
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun setPreparedMessage(nativeId: NativeId, message: String) {
-        lock.withLock {
-            preparedMessages[nativeId] = message
-            preparedMessagesCondition.signal()
+        // iOS-specific methods that return null on Android for compatibility
+        AsyncFunction("setPreparedCertificate") { _: String, _: String -> // No-op on Android
+        }
+        AsyncFunction("setPreparedSyncMessage") { _: String, _: String -> // No-op on Android
+        }
+        AsyncFunction("setPreparedLicenseServerUrl") { _: String, _: String -> // No-op on Android
+        }
+        AsyncFunction("setPreparedContentId") { _: String, _: String -> // No-op on Android
         }
     }
 
     /**
-     * Function called from JS to store the computed `prepareLicense` return value for `nativeId`.
+     * Fetches the `WidevineConfig` instance associated with `nativeId` from internal drmConfigs.
+     * @param nativeId `WidevineConfig` instance ID.
+     * @return The associated `WidevineConfig` instance or `null`.
      */
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun setPreparedLicense(nativeId: NativeId, license: String) {
-        lock.withLock {
-            preparedLicenses[nativeId] = license
-            preparedLicensesCondition.signal()
+    fun getConfig(nativeId: NativeId?): WidevineConfig? {
+        if (nativeId == null) {
+            return null
         }
+        return drmConfigs[nativeId]
     }
 
     /**
      * Initialize the `prepareMessage` block in the [widevineConfig]
-     * @param widevineConfig Instance ID.
+     * @param nativeId Instance ID.
      * @param config `DrmConfig` config object sent from JS.
      */
-    private fun buildPrepareMessageCallback(nativeId: NativeId, config: ReadableMap): PrepareMessageCallback? {
-        if (config.getMap("widevine")?.hasKey("prepareMessage") != true) {
+    private fun buildPrepareMessageCallback(nativeId: NativeId, config: Map<String, Any?>): PrepareMessageCallback? {
+        if ((config["widevine"] as? Map<*, *>)?.containsKey("prepareMessage") != true) {
             return null
         }
         val prepareMessageCallback = createPrepareCallback(
             nativeId,
             "onPrepareMessage",
-            preparedMessages,
-            preparedMessagesCondition,
+            waiter,
         )
         return PrepareMessageCallback(prepareMessageCallback)
     }
@@ -140,15 +117,14 @@ class DrmModule(context: ReactApplicationContext) : BitmovinBaseModule(context)
      * @param nativeId Instance ID.
      * @param config `DrmConfig` config object sent from JS.
      */
-    private fun buildPrepareLicense(nativeId: NativeId, config: ReadableMap): PrepareLicenseCallback? {
-        if (config.getMap("widevine")?.hasKey("prepareLicense") != true) {
+    private fun buildPrepareLicense(nativeId: NativeId, config: Map<String, Any?>): PrepareLicenseCallback? {
+        if ((config["widevine"] as? Map<*, *>)?.containsKey("prepareLicense") != true) {
             return null
         }
         val prepareLicense = createPrepareCallback(
             nativeId,
             "onPrepareLicense",
-            preparedLicenses,
-            preparedLicensesCondition,
+            waiter,
         )
         return PrepareLicenseCallback(prepareLicense)
     }
@@ -157,22 +133,27 @@ class DrmModule(context: ReactApplicationContext) : BitmovinBaseModule(context)
      * Creates the body of a preparation callback e.g. `prepareMessage`, `prepareLicense`, etc.
      * @param nativeId Instance ID.
      * @param method JS prepare callback name.
-     * @param registry Registry where JS preparation result will be stored.
+     * @param waiter ResultWaiter for handling async response.
      * @return The preparation callback function.
      */
     private fun createPrepareCallback(
         nativeId: NativeId,
         method: String,
-        registry: Registry<String>,
-        registryCondition: Condition,
+        waiter: ResultWaiter<String>,
     ): PrepareCallback = {
-        val args = Arguments.createArray()
-        args.pushString(Base64.encodeToString(it, Base64.NO_WRAP))
-        context.catalystInstance.callFunction("DRM-$nativeId", method, args as NativeArray)
-        lock.withLock {
-            registryCondition.await()
-            val result = registry[nativeId]
-            Base64.decode(result, Base64.NO_WRAP)
-        }
+        val (id, wait) = waiter.make(5000) // 5 second timeout
+        
+        // Send event to TypeScript using Expo module event system
+        sendEvent(
+            method,
+            bundleOf(
+                "nativeId" to nativeId,
+                "id" to id,
+                "data" to Base64.encodeToString(it, Base64.NO_WRAP),
+            ),
+        )
+
+        val result = wait() ?: ""
+        Base64.decode(result, Base64.NO_WRAP)
     }
 }

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

@@ -0,0 +1,22 @@
+package com.bitmovin.player.reactnative
+
+import com.bitmovin.player.api.event.Event
+import com.bitmovin.player.api.event.EventListener
+import kotlin.reflect.KClass
+
+/**
+ * Data class representing an event subscription for Bitmovin Player events.
+ * This class encapsulates the event class type and the corresponding action to be executed
+ * when the event is triggered.
+ *
+ * @param eventClass The KClass of the event to subscribe to
+ * @param action The function to execute when the event is triggered
+ */
+data class EventSubscription<E : Event> (
+    val eventClass: KClass<out E>,
+    val action: (E) -> Unit,
+) : EventListener<E> {
+    override fun onEvent(event: E) {
+        action(event)
+    }
+}

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

@@ -0,0 +1,100 @@
+package com.bitmovin.player.reactnative
+
+import com.bitmovin.player.reactnative.ui.FullscreenHandlerBridge
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Expo module for FullscreenHandler management with bidirectional communication.
+ * Handles synchronous fullscreen state changes between native code and JavaScript.
+ */
+class FullscreenHandlerModule : Module() {
+    /**
+     * In-memory mapping from `nativeId`s to `FullscreenHandlerBridge` instances.
+     */
+    private val fullscreenHandlers: Registry<FullscreenHandlerBridge> = mutableMapOf()
+
+    /**
+     * ResultWaiter used for blocking thread while waiting for fullscreen state change
+     */
+    private val waiter = ResultWaiter<Boolean>()
+
+    override fun definition() = ModuleDefinition {
+        Name("FullscreenHandlerModule")
+
+        OnDestroy {
+            fullscreenHandlers.clear()
+            waiter.clear()
+        }
+
+        Events("onEnterFullscreen", "onExitFullscreen")
+
+        AsyncFunction("registerHandler") { nativeId: NativeId ->
+            if (fullscreenHandlers[nativeId] == null) {
+                fullscreenHandlers[nativeId] = FullscreenHandlerBridge(nativeId, this@FullscreenHandlerModule)
+            }
+        }
+
+        AsyncFunction("destroy") { nativeId: NativeId ->
+            fullscreenHandlers.remove(nativeId)
+        }
+
+        AsyncFunction("notifyFullscreenChanged") { id: Int, isFullscreenEnabled: Boolean ->
+            waiter.complete(id, isFullscreenEnabled)
+        }
+
+        AsyncFunction("setIsFullscreenActive") { nativeId: NativeId, isFullscreenActive: Boolean ->
+            fullscreenHandlers[nativeId]?.isFullscreen = isFullscreenActive
+        }
+    }
+
+    /**
+     * Retrieves the FullscreenHandlerBridge instance for the given nativeId.
+     * This method maintains the same static access pattern as the legacy module.
+     */
+    fun getInstance(nativeId: NativeId?): FullscreenHandlerBridge? = fullscreenHandlers[nativeId]
+
+    /**
+     * Handles fullscreen enter request from native code.
+     * Called by FullscreenHandlerBridge when fullscreen should be entered.
+     */
+    fun requestEnterFullscreen(nativeId: NativeId) {
+        val handler = getInstance(nativeId) ?: return
+
+        val (id, wait) = waiter.make(250) // 250ms timeout
+
+        // Send event to JavaScript
+        sendEvent(
+            "onEnterFullscreen",
+            mapOf(
+                "nativeId" to nativeId,
+                "id" to id,
+            ),
+        )
+
+        val result = wait() ?: return
+        handler.isFullscreen = result
+    }
+
+    /**
+     * Handles fullscreen exit request from native code.
+     * Called by FullscreenHandlerBridge when fullscreen should be exited.
+     */
+    fun requestExitFullscreen(nativeId: NativeId) {
+        val handler = getInstance(nativeId) ?: return
+
+        val (id, wait) = waiter.make(250) // 250ms timeout
+
+        // Send event to JavaScript
+        sendEvent(
+            "onExitFullscreen",
+            mapOf(
+                "nativeId" to nativeId,
+                "id" to id,
+            ),
+        )
+
+        val result = wait() ?: return
+        handler.isFullscreen = result
+    }
+}