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

package/ios/BufferModule.swift

@@ -1,78 +1,42 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
-@objc(BufferModule)
-public class BufferModule: NSObject, RCTBridgeModule {
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    @objc public var bridge: RCTBridge!
+public class BufferModule: Module {
+    public func definition() -> ModuleDefinition {
+        Name("BufferModule")
 
-    /// PlayerModule instance fetched from the bridge's registry
-    @objc var playerModule: PlayerModule? {
-        bridge.module(for: PlayerModule.self) as? PlayerModule
-    }
+        OnCreate {
+            // Module initialization
+        }
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public static func moduleName() -> String! {
-        "BufferModule"
-    }
+        AsyncFunction("getLevel") { (playerId: String, type: String) -> [String: Any]? in
+            guard let playerModule = appContext?.moduleRegistry.get(PlayerModule.self),
+                  let player = playerModule.retrieve(playerId) else {
+                return nil
+            }
 
-    /// Module requires main thread initialization.
-    public static func requiresMainQueueSetup() -> Bool {
-        true
-    }
+            guard let bufferType = RCTConvert.bufferType(type) else {
+                return nil
+            }
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public var methodQueue: DispatchQueue! {
-        bridge.uiManager.methodQueue
-    }
+            let level = player.buffer.getLevel(bufferType)
+            let bufferLevels = RNBufferLevels(audio: level, video: level)
+            return RCTConvert.toJson(bufferLevels: bufferLevels)
+        }.runOnQueue(.main)
 
-    /**
-     - Gets the `BufferLevel` from the Player
-     - Parameter nativeId: Native Id of the the player instance.
-     - Parameter type: The type of buffer to return the level for.
-     - Parameter resolver: JS promise resolver.
-     - Parameter rejecter: JS promise rejecter.
-     */
-    @objc(getLevel:type:resolver:rejecter:)
-    func getLevel(
-        _ playerId: NativeId,
-        type: String,
-        resolver resolve: @escaping RCTPromiseResolveBlock,
-        rejecter reject: @escaping RCTPromiseRejectBlock
-    ) {
-        bridge.uiManager.addUIBlock { [weak self] _, _ in
-            guard let bufferApi = self?.playerModule?.retrieve(playerId)?.buffer else {
-                reject("[BufferModule]", "Could not find player with ID (\(playerId))", nil)
+        AsyncFunction("setTargetLevel") { (playerId: String, type: String, value: Double) in
+            guard let playerModule = appContext?.moduleRegistry.get(PlayerModule.self),
+                  let player = playerModule.retrieve(playerId) else {
                 return
             }
-            guard let bufferType = RCTConvert.bufferType(type) else {
-                reject("[BufferModule]", "Invalid buffer type: (\(type))", nil)
-                return
-            }
-            let level = bufferApi.getLevel(bufferType)
-            let bufferLevels = RNBufferLevels(audio: level, video: level)
-            resolve(RCTConvert.toJson(bufferLevels: bufferLevels))
-        }
-    }
 
-    /**
-     * Sets the target level in seconds for the forward buffer.
-     - Parameter nativeId: Target player id.
-     - Parameter type: The type of the buffer to set the target level for.
-     - Parameter value: The value to set.
-     */
-    @objc(setTargetLevel:type:value:)
-    func setTargetLevel(_ playerId: NativeId, type: String, value: NSNumber) {
-        let targetLevel = value.doubleValue
-        bridge.uiManager.addUIBlock { [weak self] _, _ in
             let bufferType = RCTConvert.bufferType(type)
-            guard
-                bufferType == .forwardDuration,
-                let bufferApi = self?.playerModule?.retrieve(playerId)?.buffer
-            else {
+
+            guard bufferType == .forwardDuration else {
                 return
             }
 
-            bufferApi.setTargetLevel(targetLevel)
-        }
+            player.buffer.setTargetLevel(value)
+        }.runOnQueue(.main)
     }
 }

package/ios/CustomMessageHandlerBridge.swift

@@ -1,4 +1,5 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
 internal class CustomMessageHandlerBridge: NSObject {
 #if os(iOS)
@@ -10,18 +11,15 @@ internal class CustomMessageHandlerBridge: NSObject {
 #endif
 
     private let nativeId: NativeId
-    private let bridge: RCTBridge
+    private weak var delegate: CustomMessageHandlerBridgeDelegate?
 
-    private var currentSynchronousResult: String?
-
-    init(_ nativeId: NativeId, bridge: RCTBridge) {
+    init(_ nativeId: NativeId, delegate: CustomMessageHandlerBridgeDelegate?) {
         self.nativeId = nativeId
-        self.bridge = bridge
-        super.init()
+        self.delegate = delegate
     }
 
     func receivedSynchronousMessage(_ message: String, withData data: String?) -> String? {
-        bridge[CustomMessageHandlerModule.self]?.receivedSynchronousMessage(
+        delegate?.receivedSynchronousMessage(
             nativeId: nativeId,
             message: message,
             withData: data
@@ -29,7 +27,7 @@ internal class CustomMessageHandlerBridge: NSObject {
     }
 
     func receivedAsynchronousMessage(_ message: String, withData data: String?) {
-        bridge[CustomMessageHandlerModule.self]?.receivedAsynchronousMessage(
+        delegate?.receivedAsynchronousMessage(
             nativeId: nativeId,
             message: message,
             withData: data
@@ -41,18 +39,13 @@ internal class CustomMessageHandlerBridge: NSObject {
         customMessageHandler.sendMessage(message, withData: data)
 #endif
     }
-
-    func pushSynchronousResult(_ result: String?) {
-        currentSynchronousResult = result
-    }
-
-    func popSynchronousResult() -> String? {
-        let result = currentSynchronousResult
-        currentSynchronousResult = nil
-        return result
-    }
 }
 
 #if os(iOS)
 extension CustomMessageHandlerBridge: CustomMessageHandlerDelegate {}
 #endif
+
+internal protocol CustomMessageHandlerBridgeDelegate: AnyObject {
+    func receivedSynchronousMessage(nativeId: NativeId, message: String, withData data: String?) -> String?
+    func receivedAsynchronousMessage(nativeId: NativeId, message: String, withData data: String?)
+}

package/ios/CustomMessageHandlerModule.swift

@@ -1,80 +1,77 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
-@objc(CustomMessageHandlerModule)
-public class CustomMessageHandlerModule: NSObject, RCTBridgeModule {
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    @objc public var bridge: RCTBridge!
+/**
+ * Expo module for CustomMessageHandler management with bidirectional communication.
+ * Handles synchronous and asynchronous message handling between native code and JavaScript.
+ */
+public class CustomMessageHandlerModule: Module {
+    /// In-memory mapping from `nativeId`s to `CustomMessageHandlerBridge` instances.
+    private var customMessageHandlers: Registry<CustomMessageHandlerBridge> = [:]
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public static func moduleName() -> String! {
-        "CustomMessageHandlerModule"
-    }
+    /// ResultWaiter used for blocking thread while waiting for synchronous message results
+    private let waiter = ResultWaiter<String?>()
 
-    public static func requiresMainQueueSetup() -> Bool {
-        true
-    }
+    public func definition() -> ModuleDefinition {
+        Name("CustomMessageHandlerModule")
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public var methodQueue: DispatchQueue! {
-        bridge.uiManager.methodQueue
-    }
+        OnDestroy {
+            customMessageHandlers.removeAll()
+            waiter.removeAll()
+        }
 
-    /// In-memory mapping from `nativeId`s to `CustomMessageHandlerBridge` instances.
-    private var customMessageHandlers: Registry<CustomMessageHandlerBridge> = [:]
+        Events("onReceivedSynchronousMessage", "onReceivedAsynchronousMessage")
 
-    /// Dispatch group used for blocking thread while waiting for state change
-    private let customMessageHandlerDispatchGroup = DispatchGroup()
+        AsyncFunction("registerHandler") { [weak self] (nativeId: NativeId) in
+            guard self?.customMessageHandlers[nativeId] == nil else {
+                return
+            }
+            self?.customMessageHandlers[nativeId] = CustomMessageHandlerBridge(nativeId, delegate: self)
+        }.runOnQueue(.main)
 
-    /**
-     Fetches the `CustomMessageHandlerBridge` instance associated with `nativeId` from internal customMessageHandlers.
-     - Parameter nativeId: `CustomMessageHandlerBridge` instance ID.
-     - Returns: The associated `CustomMessageHandlerBridge` instance or `nil`.
-     */
-    @objc
-    func retrieve(_ nativeId: NativeId) -> CustomMessageHandlerBridge? {
-        customMessageHandlers[nativeId]
-    }
+        AsyncFunction("destroy") { [weak self] (nativeId: NativeId) in
+            self?.customMessageHandlers.removeValue(forKey: nativeId)
+        }.runOnQueue(.main)
 
-    /**
-     Removes the `CustomMessageHandlerBridge` instance associated with `nativeId` from `customMessageHandlers`.
-     - Parameter nativeId Instance to be disposed.
-     */
-    @objc(destroy:)
-    func destroy(_ nativeId: NativeId) {
-        customMessageHandlers.removeValue(forKey: nativeId)
-    }
-
-    @objc(registerHandler:)
-    func registerHandler(_ nativeId: NativeId) {
-        guard customMessageHandlers[nativeId] == nil else { return }
-        customMessageHandlers[nativeId] = CustomMessageHandlerBridge(nativeId, bridge: bridge)
-    }
+        AsyncFunction("onReceivedSynchronousMessageResult") { [weak self] (id: Int, result: String?) in
+            self?.waiter.complete(id: id, with: result)
+        }
 
-    @objc(onReceivedSynchronousMessageResult:result:)
-    func onReceivedSynchronousMessageResult(_ nativeId: NativeId, result: String?) -> Any? {
-        customMessageHandlers[nativeId]?.pushSynchronousResult(result)
-        customMessageHandlerDispatchGroup.leave()
-        return nil
+        AsyncFunction("sendMessage") { [weak self] (nativeId: NativeId, message: String, data: String?) in
+            self?.customMessageHandlers[nativeId]?.sendMessage(message, withData: data)
+        }.runOnQueue(.main)
     }
 
-    @objc(sendMessage:message:data:)
-    func sendMessage(nativeId: NativeId, message: String, data: String?) {
-        customMessageHandlers[nativeId]?.sendMessage(message, withData: data)
+    func retrieve(_ nativeId: NativeId) -> CustomMessageHandlerBridge? {
+        customMessageHandlers[nativeId]
     }
+}
 
+extension CustomMessageHandlerModule: CustomMessageHandlerBridgeDelegate {
+    /**
+     * Handles synchronous message received from native code.
+     * Called by CustomMessageHandlerBridge when a synchronous message is received.
+     */
     func receivedSynchronousMessage(
         nativeId: NativeId,
         message: String,
         withData data: String?
     ) -> String? {
-        customMessageHandlerDispatchGroup.enter()
-        bridge.enqueueJSCall(
-            "CustomMessageBridge-\(nativeId)",
-            method: "receivedSynchronousMessage",
-            args: [message, data]
-        ) {}
-        customMessageHandlerDispatchGroup.wait()
-        return customMessageHandlers[nativeId]?.popSynchronousResult()
+        guard customMessageHandlers[nativeId] != nil else {
+            return nil
+        }
+
+        let (id, wait) = waiter.make(timeout: 0.25)
+
+        // Send event to JavaScript
+        sendEvent("onReceivedSynchronousMessage", [
+            "nativeId": nativeId,
+            "id": id,
+            "message": message,
+            "data": data
+        ])
+
+        return wait() ?? ""
     }
 
     func receivedAsynchronousMessage(
@@ -82,10 +79,11 @@ public class CustomMessageHandlerModule: NSObject, RCTBridgeModule {
         message: String,
         withData data: String?
     ) {
-        bridge.enqueueJSCall(
-            "CustomMessageBridge-\(nativeId)",
-            method: "receivedAsynchronousMessage",
-            args: [message, data]
-        ) {}
+        // Send event to JavaScript
+        sendEvent("onReceivedAsynchronousMessage", [
+            "nativeId": nativeId,
+            "message": message,
+            "data": data
+        ])
     }
 }

package/ios/DebugModule.swift

@@ -1,33 +1,12 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
-@objc(DebugModule)
-public class DebugModule: NSObject, RCTBridgeModule {
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    @objc public var bridge: RCTBridge!
+public class DebugModule: Module {
+    public func definition() -> ModuleDefinition {
+        Name("DebugModule")
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public static func moduleName() -> String! {
-        "DebugModule"
-    }
-
-    /// Module requires main thread initialization.
-    public static func requiresMainQueueSetup() -> Bool {
-        true
-    }
-
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public var methodQueue: DispatchQueue! {
-        bridge.uiManager.methodQueue
-    }
-}
-
-extension DebugModule {
-    /// Enable/disable verbose logging for the console logger.
-    /// - Parameter enabled: Whether to set verbose logging as enabled or disabled.
-    @objc(setDebugLoggingEnabled:)
-    func setDebugLoggingEnabled(enabled: Bool) {
-        bridge.uiManager.addUIBlock { [weak self] _, _ in
+        AsyncFunction("setDebugLoggingEnabled") { (enabled: Bool) in
             DebugConfig.logging.logger?.level = enabled ? .verbose : .warning
-        }
+        }.runOnQueue(.main)
     }
 }