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

package/ios/FullscreenHandlerModule.swift

@@ -1,79 +1,95 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
-@objc(FullscreenHandlerModule)
-public class FullscreenHandlerModule: NSObject, RCTBridgeModule {
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    @objc public var bridge: RCTBridge!
+/**
+ * Expo module for FullscreenHandler management with bidirectional communication.
+ * Handles synchronous fullscreen state changes between native code and JavaScript.
+ */
+public class FullscreenHandlerModule: Module {
+    /// In-memory mapping from `nativeId`s to `FullscreenHandlerBridge` instances.
+    private var fullscreenHandlers: Registry<FullscreenHandlerBridge> = [:]
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public static func moduleName() -> String! {
-        "FullscreenHandlerModule"
-    }
+    /// ResultWaiter used for blocking thread while waiting for fullscreen state change
+    private let waiter = ResultWaiter<Bool>()
 
-    public static func requiresMainQueueSetup() -> Bool {
-        true
-    }
+    public func definition() -> ModuleDefinition {
+        Name("FullscreenHandlerModule")
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public var methodQueue: DispatchQueue! {
-        bridge.uiManager.methodQueue
-    }
+        OnDestroy {
+            fullscreenHandlers.removeAll()
+            waiter.removeAll()
+        }
 
-    /// In-memory mapping from `nativeId`s to `FullscreenHandler` instances.
-    private var fullscreenHandlers: Registry<FullscreenHandlerBridge> = [:]
+        Events("onEnterFullscreen", "onExitFullscreen")
 
-    /// Dispatch group used for blocking thread while waiting for state change
-    private let fullscreenChangeDispatchGroup = DispatchGroup()
+        AsyncFunction("registerHandler") { (nativeId: NativeId) in
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.fullscreenHandlers[nativeId] == nil else {
+                    return
+                }
+                self.fullscreenHandlers[nativeId] = FullscreenHandlerBridge(
+                    nativeId,
+                    moduleRegistry: appContext?.moduleRegistry
+                )
+            }
+        }.runOnQueue(.main)
+
+        AsyncFunction("destroy") { [weak self] (nativeId: NativeId) in
+            self?.fullscreenHandlers.removeValue(forKey: nativeId)
+        }.runOnQueue(.main)
+
+        AsyncFunction("notifyFullscreenChanged") { [weak self] (id: Int, isFullscreenEnabled: Bool) in
+            self?.waiter.complete(id: id, with: isFullscreenEnabled)
+        }
+
+        AsyncFunction("setIsFullscreenActive") { [weak self] (nativeId: NativeId, isFullscreen: Bool) in
+            self?.fullscreenHandlers[nativeId]?.isFullscreenValueBox.update(isFullscreen)
+        }.runOnQueue(.main)
+    }
 
-    /**
-     Fetches the `FullscreenHandlerBridge` instance associated with `nativeId` from internal fullscreenHandlers.
-     - Parameter nativeId: `FullscreenHandlerBridge` instance ID.
-     - Returns: The associated `FullscreenHandlerBridge` instance or `nil`.
-     */
-    @objc
     func retrieve(_ nativeId: NativeId) -> FullscreenHandlerBridge? {
         fullscreenHandlers[nativeId]
     }
 
     /**
-     Removes the `FullscreenHandlerBridge` instance associated with `nativeId` from `fullscreenHandlers`.
-     - Parameter nativeId Instance to be disposed.
+     * Handles fullscreen enter request from native code.
+     * Called by FullscreenHandlerBridge when fullscreen should be entered.
      */
-    @objc(destroy:)
-    func destroy(_ nativeId: NativeId) {
-        fullscreenHandlers.removeValue(forKey: nativeId)
-    }
-
-    @MainActor
-    @objc(onFullscreenChanged:isFullscreenEnabled:)
-    func onFullscreenChanged(_ nativeId: NativeId, isFullscreenEnabled: Bool) -> Any? {
-        fullscreenHandlers[nativeId]?.isFullscreen = isFullscreenEnabled
-        fullscreenChangeDispatchGroup.leave()
-        return nil
-    }
+    func onFullscreenRequested(nativeId: NativeId) {
+        guard let handler = retrieve(nativeId) else {
+            return
+        }
 
-    @MainActor
-    @objc(registerHandler:)
-    func registerHandler(_ nativeId: NativeId) {
-        guard fullscreenHandlers[nativeId] == nil else { return }
-        fullscreenHandlers[nativeId] = FullscreenHandlerBridge(nativeId, bridge: bridge)
-    }
+        let (id, wait) = waiter.make(timeout: 0.25)
 
-    @MainActor
-    @objc(setIsFullscreenActive:isFullscreen:)
-    func setIsFullscreenActive(_ nativeId: NativeId, isFullscreen: Bool) {
-        fullscreenHandlers[nativeId]?.isFullscreen = isFullscreen
-    }
+        // Send event to JavaScript
+        sendEvent("onEnterFullscreen", [
+            "nativeId": nativeId,
+            "id": id
+        ])
 
-    func onFullscreenRequested(nativeId: NativeId) {
-        fullscreenChangeDispatchGroup.enter()
-        bridge.enqueueJSCall("FullscreenBridge-\(nativeId)", method: "enterFullscreen", args: []) {}
-        fullscreenChangeDispatchGroup.wait()
+        guard let result = wait() else {
+            return
+        }
+        handler.isFullscreenValueBox.update(result)
     }
 
     func onFullscreenExitRequested(nativeId: NativeId) {
-        fullscreenChangeDispatchGroup.enter()
-        bridge.enqueueJSCall("FullscreenBridge-\(nativeId)", method: "exitFullscreen", args: []) {}
-        fullscreenChangeDispatchGroup.wait()
+        guard let handler = retrieve(nativeId) else {
+            return
+        }
+
+        let (id, wait) = waiter.make(timeout: 0.25)
+
+        // Send event to JavaScript
+        sendEvent("onExitFullscreen", [
+            "nativeId": nativeId,
+            "id": id
+        ])
+
+        guard let result = wait() else {
+            return
+        }
+        handler.isFullscreenValueBox.update(result)
     }
 }

package/ios/LockedBox.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+internal class LockedBox<T> {
+    private let lock = NSRecursiveLock()
+    var value: T {
+        lock.withLock {
+            _value
+        }
+    }
+    private var _value: T
+
+    init(value: T) {
+        self._value = value
+    }
+
+    func update(_ value: T) {
+        lock.withLock {
+            self._value = value
+        }
+    }
+}

package/ios/ModuleRegistry+Generics.swift

@@ -0,0 +1,11 @@
+import ExpoModulesCore
+
+extension ModuleRegistry {
+    func get<T: Module>(_ type: T.Type = T.self) -> T? {
+        guard let name = String(describing: type)
+            .split(separator: ".", maxSplits: 1, omittingEmptySubsequences: true).last else {
+            return nil
+        }
+        return self.get(moduleWithName: String(name)) as? T
+    }
+}

package/ios/NetworkModule.swift

@@ -1,38 +1,31 @@
 import BitmovinPlayer
+import ExpoModulesCore
 
-@objc(NetworkModule)
-public class NetworkModule: NSObject, RCTBridgeModule {
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    @objc public var bridge: RCTBridge!
-
+/**
+ * Expo module for NetworkConfig management with HTTP request/response preprocessing.
+ * Handles bidirectional communication between native code and JavaScript for network operations.
+ */
+public class NetworkModule: Module {
     /// In-memory mapping from `nativeId`s to `NetworkConfig` instances.
     private var networkConfigs: Registry<NetworkConfig> = [:]
-    private var preprocessHttpRequestDelegateBridges: Registry<PreprocessHttpRequestDelegate> = [:]
     private var preprocessHttpRequestCompletionHandlers: Registry<(_ request: HttpRequest) -> Void> = [:]
     private var preprocessHttpResponseCompletionHandlers: Registry<(_ response: HttpResponse) -> Void> = [:]
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public static func moduleName() -> String! {
-        "NetworkModule"
-    }
-
-    public static func requiresMainQueueSetup() -> Bool {
-        true
-    }
+    public func definition() -> ModuleDefinition {
+        Name("NetworkModule")
 
-    // swiftlint:disable:next implicitly_unwrapped_optional
-    public var methodQueue: DispatchQueue! {
-        bridge.uiManager.methodQueue
-    }
+        OnDestroy {
+            networkConfigs.removeAll()
+            preprocessHttpRequestCompletionHandlers.removeAll()
+            preprocessHttpResponseCompletionHandlers.removeAll()
+        }
 
-    @objc
-    func retrieve(_ nativeId: NativeId) -> NetworkConfig? {
-        networkConfigs[nativeId]
-    }
+        Events(
+            "onPreprocessHttpRequest",
+            "onPreprocessHttpResponse"
+        )
 
-    @objc(initWithConfig:config:)
-    func initWithConfig(_ nativeId: NativeId, config: Any?) {
-        bridge.uiManager.addUIBlock { [weak self] _, _ in
+        AsyncFunction("initializeWithConfig") { [weak self] (nativeId: NativeId, config: [String: Any]) in
             guard
                 self?.retrieve(nativeId) == nil,
                 let networkConfig = RCTConvert.networkConfig(config)
@@ -41,26 +34,47 @@ public class NetworkModule: NSObject, RCTBridgeModule {
             }
             self?.networkConfigs[nativeId] = networkConfig
             self?.initConfigBlocks(nativeId, config)
-        }
-    }
+        }.runOnQueue(.main)
 
-    @objc(destroy:)
-    func destroy(_ nativeId: NativeId) {
-        networkConfigs.removeValue(forKey: nativeId)
+        AsyncFunction("destroy") { [weak self] (nativeId: NativeId) in
+            self?.networkConfigs.removeValue(forKey: nativeId)
 
-        preprocessHttpRequestCompletionHandlers.keys.filter { $0.starts(with: nativeId) }.forEach {
-            preprocessHttpRequestCompletionHandlers.removeValue(forKey: $0)
-        }
-        preprocessHttpRequestDelegateBridges.removeValue(forKey: nativeId)
-        preprocessHttpResponseCompletionHandlers.keys.filter { $0.starts(with: nativeId) }.forEach {
-            preprocessHttpResponseCompletionHandlers.removeValue(forKey: $0)
-        }
+            // Clean up completion handlers
+            self?.preprocessHttpRequestCompletionHandlers.keys.filter { $0.starts(with: nativeId) }.forEach {
+                self?.preprocessHttpRequestCompletionHandlers.removeValue(forKey: $0)
+            }
+            self?.preprocessHttpResponseCompletionHandlers.keys.filter { $0.starts(with: nativeId) }.forEach {
+                self?.preprocessHttpResponseCompletionHandlers.removeValue(forKey: $0)
+            }
+        }.runOnQueue(.main)
+
+        AsyncFunction("setPreprocessedHttpRequest") { [weak self] (requestId: String, request: [String: Any]) in
+            guard let completionHandler = self?.preprocessHttpRequestCompletionHandlers[requestId],
+                  let httpRequest = RCTConvert.httpRequest(request) else {
+                return
+            }
+
+            self?.preprocessHttpRequestCompletionHandlers.removeValue(forKey: requestId)
+            completionHandler(httpRequest)
+        }.runOnQueue(.main)
+
+        AsyncFunction("setPreprocessedHttpResponse") { [weak self] (responseId: String, response: [String: Any]) in
+            guard let completionHandler = self?.preprocessHttpResponseCompletionHandlers[responseId],
+                  let httpResponse = RCTConvert.httpResponse(response) else {
+                return
+            }
+            self?.preprocessHttpResponseCompletionHandlers.removeValue(forKey: responseId)
+            completionHandler(httpResponse)
+        }.runOnQueue(.main)
+    }
+
+    func retrieve(_ nativeId: NativeId) -> NetworkConfig? {
+        networkConfigs[nativeId]
     }
 
-    private func initConfigBlocks(_ nativeId: NativeId, _ config: Any?) {
-        guard let json = config as? [String: Any] else { return }
-        initPreprocessHttpRequest(nativeId, networkConfigJson: json)
-        initPreprocessHttpResponse(nativeId, networkConfigJson: json)
+    private func initConfigBlocks(_ nativeId: NativeId, _ config: [String: Any]) {
+        initPreprocessHttpRequest(nativeId, networkConfigJson: config)
+        initPreprocessHttpResponse(nativeId, networkConfigJson: config)
     }
 
     private func initPreprocessHttpRequest(_ nativeId: NativeId, networkConfigJson: [String: Any]) {
@@ -68,11 +82,14 @@ public class NetworkModule: NSObject, RCTBridgeModule {
               networkConfigJson["preprocessHttpRequest"] != nil else {
             return
         }
-        preprocessHttpRequestDelegateBridges[nativeId] = PreprocessHttpRequestDelegateBridge(
-            nativeId,
-            bridge: bridge
-        )
-        networkConfig.preprocessHttpRequestDelegate = preprocessHttpRequestDelegateBridges[nativeId]
+        networkConfig.preprocessHttpRequest = { [weak self] type, request, completionHandler in
+            self?.preprocessHttpRequestFromJS(
+                nativeId: nativeId,
+                type: type,
+                request: request,
+                completionHandler: completionHandler
+            )
+        }
     }
 
     private func initPreprocessHttpResponse(_ nativeId: NativeId, networkConfigJson: [String: Any]) {
@@ -93,31 +110,20 @@ public class NetworkModule: NSObject, RCTBridgeModule {
 
     internal func preprocessHttpRequestFromJS(
         nativeId: NativeId,
-        type: String,
+        type: HttpRequestType,
         request: HttpRequest,
         completionHandler: @escaping (
             _ request: HttpRequest
         ) -> Void
     ) {
-        let requestId = "\(nativeId)@\(ObjectIdentifier(request).hashValue)"
-        let args: [Any] = [
-            requestId,
-            type,
-            RCTConvert.toJson(httpRequest: request),
-        ]
+        let requestId = "\(nativeId)-\(UUID().uuidString)"
         preprocessHttpRequestCompletionHandlers[requestId] = completionHandler
-        bridge.enqueueJSCall("Network-\(nativeId)", method: "onPreprocessHttpRequest", args: args) {}
-    }
-
-    @objc(setPreprocessedHttpRequest:request:)
-    func setPreprocessedHttpRequest(_ requestId: String, _ request: [String: Any]) {
-        guard let completionHandler = preprocessHttpRequestCompletionHandlers[requestId],
-              let httpRequest = RCTConvert.httpRequest(request) else {
-            return
-        }
-
-        preprocessHttpRequestCompletionHandlers.removeValue(forKey: requestId)
-        completionHandler(httpRequest)
+        sendEvent("onPreprocessHttpRequest", [
+            "nativeId": nativeId,
+            "requestId": requestId,
+            "type": RCTConvert.toJson(httpRequestType: type),
+            "request": RCTConvert.toJson(httpRequest: request)
+        ])
     }
 
     private func preprocessHttpResponseFromJS(
@@ -128,23 +134,13 @@ public class NetworkModule: NSObject, RCTBridgeModule {
             _ response: HttpResponse
         ) -> Void
     ) {
-        let responseId = "\(nativeId)@\(ObjectIdentifier(response).hashValue)"
-        let args: [Any] = [
-            responseId,
-            RCTConvert.toJson(httpRequestType: type),
-            RCTConvert.toJson(httpResponse: response),
-        ]
+        let responseId = "\(nativeId)-\(UUID().uuidString)"
         preprocessHttpResponseCompletionHandlers[responseId] = completionHandler
-        bridge.enqueueJSCall("Network-\(nativeId)", method: "onPreprocessHttpResponse", args: args) {}
-    }
-
-    @objc(setPreprocessedHttpResponse:response:)
-    func setPreprocessedHttpResponse(_ responseId: String, _ response: [String: Any]) {
-        guard let completionHandler = preprocessHttpResponseCompletionHandlers[responseId],
-              let httpResponse = RCTConvert.httpResponse(response) else {
-            return
-        }
-        preprocessHttpResponseCompletionHandlers.removeValue(forKey: responseId)
-        completionHandler(httpResponse)
+        sendEvent("onPreprocessHttpResponse", [
+            "nativeId": nativeId,
+            "responseId": responseId,
+            "type": RCTConvert.toJson(httpRequestType: type),
+            "response": RCTConvert.toJson(httpResponse: response)
+        ])
     }
 }

package/ios/OfflineContentManagerBridge.swift

@@ -1,6 +1,8 @@
 #if os(iOS)
 import BitmovinPlayer
+import ExpoModulesCore
 import Foundation
+import React
 
 internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListener {
     enum EventType: String {
@@ -16,19 +18,19 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
     }
 
     let offlineContentManager: OfflineContentManager
-    let eventEmitter: RCTEventEmitter?
+    private weak var module: OfflineModule?
     let nativeId: NativeId
     let identifier: String
     var currentTrackSelection: OfflineTrackSelection?
 
     init(
         forManager offlineContentManager: OfflineContentManager,
-        eventEmitter: RCTEventEmitter,
+        module: OfflineModule,
         nativeId: NativeId,
         identifier: String
     ) {
         self.offlineContentManager = offlineContentManager
-        self.eventEmitter = eventEmitter
+        self.module = module
         self.nativeId = nativeId
         self.identifier = identifier
         super.init()
@@ -47,22 +49,16 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         sendOfflineEvent(eventType: .onOptionsAvailable)
     }
 
-    /**
-     Called when an error occurs.
-     */
     func onOfflineError(
         _ event: OfflineErrorEvent,
         offlineContentManager: OfflineContentManager
     ) {
         sendOfflineEvent(eventType: .onError, body: [
-            "code": event.code,
+            "code": event.errorCode,
             "message": event.message
         ])
     }
 
-    /**
-     Called after a getOptions or when am OfflineOptionEntry has been updated during a process call.
-     */
     func onAvailableTracksFetched(
         _ event: AvailableTracksFetchedEvent,
         offlineContentManager: OfflineContentManager
@@ -70,25 +66,19 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         currentTrackSelection = event.tracks
 
         sendOfflineEvent(eventType: .onOptionsAvailable, body: [
-            "options": RCTConvert.toJson(offlineTracks: event.tracks)
+            "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)
+            "options": RCTConvert.toJson(offlineTracks: currentTrackSelection) ?? [:]
         ])
     }
 
-    /**
-     Called when the progress for a process call changes.
-     */
     func onContentDownloadProgressChanged(
         _ event: ContentDownloadProgressChangedEvent,
         offlineContentManager: OfflineContentManager
@@ -98,9 +88,6 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         ])
     }
 
-    /**
-     Called when all actions have been suspended.
-     */
     func onContentDownloadSuspended(
         _ event: ContentDownloadSuspendedEvent,
         offlineContentManager: OfflineContentManager
@@ -108,9 +95,6 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         sendOfflineEvent(eventType: .onSuspended)
     }
 
-    /**
-     Called when all actions have been resumed.
-     */
     func onContentDownloadResumed(
         _ event: ContentDownloadResumedEvent,
         offlineContentManager: OfflineContentManager
@@ -118,10 +102,6 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         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
@@ -129,9 +109,6 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         sendOfflineEvent(eventType: .onCanceled)
     }
 
-    /**
-     Called when the DRM license was renewed.
-     */
     func onOfflineContentLicenseRenewed(
         _ event: OfflineContentLicenseRenewedEvent,
         offlineContentManager: OfflineContentManager
@@ -150,8 +127,8 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
         sendOfflineEvent(eventType: .onDrmLicenseExpired)
     }
 
-    private func sendOfflineEvent(eventType: EventType, body: [String: Any?] = [:]) {
-        var baseEvent: [String: Any?] = [
+    private func sendOfflineEvent(eventType: EventType, body: [String: Any] = [:]) {
+        let baseEvent: [String: Any] = [
             "nativeId": nativeId,
             "identifier": identifier,
             "eventType": eventType.rawValue,
@@ -160,11 +137,7 @@ internal class OfflineContentManagerBridge: NSObject, OfflineContentManagerListe
 
         let eventBody = baseEvent.merging(body) { current, _ in current }
 
-        do {
-            try eventEmitter?.sendEvent(withName: "BitmovinOfflineEvent", body: eventBody)
-        } catch let error as NSError {
-            print(error)
-        }
+        module?.sendEvent("onBitmovinOfflineEvent", eventBody)
     }
 }
 #endif