bitmovin-player-react-native 0.9.2 → 0.10.0

package/ios/OfflineModule.swift

@@ -0,0 +1,465 @@
+
+import Foundation
+import BitmovinPlayer
+
+@objc(OfflineModule)
+class OfflineModule: RCTEventEmitter {
+    /// JS module name.
+    override static func moduleName() -> String! {
+        "BitmovinOfflineModule"
+    }
+
+    /// Module requires main thread initialization.
+    override static func requiresMainQueueSetup() -> Bool {
+        true
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["BitmovinOfflineEvent"]
+    }
+
+    /// Since most `OfflineModule` operations are UI related and need to be executed on the main thread, they are scheduled with `UIManager.addBlock`.
+    override var methodQueue: DispatchQueue! {
+        bridge.uiManager.methodQueue
+    }
+
+#if os(iOS)
+    private var offlineContentManagerBridges: Registry<OfflineContentManagerBridge> = [:]
+
+    /**
+     Retrieves the `OfflineContentManager` instance associated with `nativeId` from the internal offline managers.
+     - Parameter nativeId `OfflineContentManager` instance ID.
+     - Returns: The associated `OfflineContentManager` instance or `nil`.
+     */
+    func retrieve(_ nativeId: NativeId) -> OfflineContentManagerBridge? {
+        offlineContentManagerBridges[nativeId]
+    }
+#endif
+
+    /**
+     Creates a new `OfflineContentManager` instance inside the internal offline managers using the provided config object.
+     - @param config Config object received from JS. Should contain `sourceConfig` and `identifier`.
+     */
+    @objc(initWithConfig:config:drmNativeId:resolver:rejecter:)
+    func initWithConfig(
+        _ nativeId: NativeId,
+        config: Any?,
+        drmNativeId: NativeId?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                self.offlineContentManagerBridges[nativeId] == nil,
+                let config = config as? [String: Any?],
+                let identifier = config["identifier"] as? String
+            else {
+                reject("BitmovinOfflineModule", "Could not create an offline content manager", nil)
+                return
+            }
+
+            let fairplayConfig = drmNativeId.flatMap { self.bridge[DrmModule.self]?.retrieve($0) }
+            guard let sourceConfig = RCTConvert.sourceConfig(config["sourceConfig"], drmConfig: fairplayConfig) else {
+                reject("BitmovinOfflineModule", "Invalid source config", nil)
+                return
+            }
+
+            do {
+                let offlineContentManager = try OfflineManager.sharedInstance()
+                    .offlineContentManager(for: sourceConfig, id: identifier)
+                let offlineContentManagerBridge = OfflineContentManagerBridge(
+                    forManager: offlineContentManager,
+                    eventEmitter: self,
+                    nativeId: nativeId,
+                    identifier: identifier
+                )
+
+                self.offlineContentManagerBridges[nativeId] = offlineContentManagerBridge
+                resolve(nil)
+            } catch let error as NSError {
+                reject("BitmovinOfflineModule", "Could not create an offline content manager", error)
+            }
+        }
+#endif
+    }
+
+    @objc(getState:resolver:rejecter:)
+    func getState(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            resolve(RCTConvert.toJson(offlineState: offlineContentManagerBridge.offlineContentManager.offlineState))
+        }
+#endif
+    }
+
+    /**
+     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`.
+     - Parameter nativeId: Target offline module Id.
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(getOptions:resolver:rejecter:)
+    func getOptions(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.fetchAvailableTracks()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Enqueues downloads according to the `OfflineDownloadRequest`.
+     * The promise will reject in the event of null or invalid request parameters.
+     - Parameter nativeId: Target offline module Id
+     - Parameter request: The download request js object containing the requested bitrate and track option ids to download.
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(download:request:resolver:rejecter:)
+    func download(
+        _ nativeId: NativeId,
+        request: Any?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            switch offlineContentManagerBridge.offlineContentManager.offlineState {
+            case .downloaded:
+                reject("BitmovinOfflineModule", "Download already completed", nil)
+                return
+            case .downloading:
+                reject("BitmovinOfflineModule", "Download already in progress", nil)
+                return
+            case .suspended:
+                reject("BitmovinOfflineModule", "Download is suspended", nil)
+                return
+            @unknown default:
+                break
+            }
+
+            guard let request = request as? [String: Any?] else {
+                reject("BitmovinOfflineModule", "Invalid download request", nil)
+                return
+            }
+
+            guard
+                let currentTrackSelection = offlineContentManagerBridge.currentTrackSelection
+            else {
+                reject("BitmovinOfflineModule", "Invalid download options", nil)
+                return
+            }
+
+            if let audioOptionIds = request["audioOptionIds"] as? [String],
+               !audioOptionIds.isEmpty {
+                currentTrackSelection.audioTracks.forEach {
+                    if audioOptionIds.contains($0.label) {
+                        $0.action = .download
+                    } else {
+                        $0.action = .none
+                    }
+                }
+            }
+
+            if let textOptionIds = request["textOptionIds"] as? [String],
+               !textOptionIds.isEmpty {
+                currentTrackSelection.textTracks.forEach {
+                    if textOptionIds.contains($0.label) {
+                        $0.action = .download
+                    } else {
+                        $0.action = .none
+                    }
+                }
+            }
+
+            let config = DownloadConfig()
+
+            if let minimumBitrate = request["minimumBitrate"] as? NSNumber {
+                config.minimumBitrate = minimumBitrate
+            }
+
+            offlineContentManagerBridge.offlineContentManager.download(tracks: currentTrackSelection, downloadConfig: config)
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Resumes all suspended actions.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(resume:resolver:rejecter:)
+    func resume(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.resumeDownload()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Suspends all active actions.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(suspend:resolver:rejecter:)
+    func suspend(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.suspendDownload()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Cancels all active downloads and removes the data.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(cancelDownload:resolver:rejecter:)
+    func cancelDownload(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.cancelDownload()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Resolve `nativeId`'s current `usedStorage`.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(usedStorage:resolver:rejecter:)
+    func usedStorage(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            resolve(offlineContentManagerBridge.offlineContentManager.usedStorage)
+        }
+#endif
+    }
+
+    /**
+     Deletes everything related to the related content ID.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(deleteAll:resolver:rejecter:)
+    func deleteAll(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.deleteOfflineData()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     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`.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(donwloadLicense:resolver:rejecter:)
+    func downloadLicense(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.syncOfflineDrmLicenseInformation()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     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`.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(renewOfflineLicense:resolver:rejecter:)
+    func renewOfflineLicense(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.offlineContentManager.renewOfflineLicense()
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     Removes the `OfflineContentManagerListener` for the `nativeId`'s offline content manager.
+     IMPORTANT: Call this when the component, in which it was created, is destroyed.
+     The `OfflineManager` should not be used after calling this method.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(release:resolver:rejecter:)
+    func release(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let self = self,
+                let offlineContentManagerBridge = self.offlineContentManagerBridges[nativeId]
+            else {
+                reject("BitmovinOfflineModule", "Could not find the offline module instance", nil)
+                return
+            }
+
+            offlineContentManagerBridge.release()
+            self.offlineContentManagerBridges[nativeId] = nil
+            resolve(nil)
+        }
+#endif
+    }
+
+    /**
+     This method is no-op on iOS.
+     - Parameter nativeId: Target offline module Id
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(releaseLicense:resolver:rejecter:)
+    func releaseLicense(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        resolve(nil)
+    }
+}

package/ios/PlayerModule.m

@@ -4,6 +4,7 @@
 
 RCT_EXTERN_METHOD(initWithConfig:(NSString *)nativeId config:(nullable id)config)
 RCT_EXTERN_METHOD(loadSource:(NSString *)nativeId sourceNativeId:(NSString *)sourceNativeId)
+RCT_EXTERN_METHOD(loadOfflineContent:(NSString *)nativeId offlineContentManagerBridgeId:(NSString *)offlineContentManagerBridgeId options:(nullable id)options)
 RCT_EXTERN_METHOD(unload:(NSString *)nativeId)
 RCT_EXTERN_METHOD(play:(NSString *)nativeId)
 RCT_EXTERN_METHOD(pause:(NSString *)nativeId)
@@ -82,5 +83,6 @@ RCT_EXTERN_METHOD(
     getMaxTimeShift:(NSString *)nativeId
     resolver:(RCTPromiseResolveBlock)resolve
     rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setMaxSelectableBitrate:(NSString *)nativeId maxSelectableBitrate:(nonnull NSNumber *)maxSelectableBitrate)
 
 @end

package/ios/PlayerModule.swift

@@ -59,7 +59,7 @@ class PlayerModule: NSObject, RCTBridgeModule {
         bridge.uiManager.addUIBlock { [weak self] _, _ in
             guard
                 let player = self?.players[nativeId],
-                let source = self?.getSourceModule()?.retrieve(sourceNativeId)
+                let source = self?.bridge[SourceModule.self]?.retrieve(sourceNativeId)
             else {
                 return
             }
@@ -67,9 +67,29 @@ class PlayerModule: NSObject, RCTBridgeModule {
         }
     }
 
-    /// Fetches the initialized `SourceModule` instance on RN's bridge object.
-    private func getSourceModule() -> SourceModule? {
-        bridge.module(for: SourceModule.self) as? SourceModule
+    /**
+     Loads the given offline source configuration into `nativeId`'s `Player` object.
+     - Parameter nativeId: Target player.
+     - Parameter offlineContentManagerBridgeId: The `nativeId` of the `OfflineModule` object.
+     */
+    @objc(loadOfflineContent:offlineContentManagerBridgeId:options:)
+    func loadOfflineContent(_ nativeId: NativeId, offlineContentManagerBridgeId: NativeId, options: Any?) {
+#if os(iOS)
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let player = self?.players[nativeId],
+                let offlineContentManagerBridge = self?.bridge[OfflineModule.self]?.retrieve(offlineContentManagerBridgeId)
+            else {
+                return
+            }
+            let optionsDictionary = options as? [String: Any?] ?? [:]
+            let restrictedToAssetCache = optionsDictionary["restrictedToAssetCache"] as? Bool ?? true
+            let offlineSourceConfig = offlineContentManagerBridge.offlineContentManager.createOfflineSourceConfig(restrictedToAssetCache: restrictedToAssetCache)
+
+            guard let offlineSourceConfig = offlineSourceConfig else { return }
+            player.load(sourceConfig: offlineSourceConfig)
+        }
+#endif
     }
 
     /**
@@ -116,7 +136,7 @@ class PlayerModule: NSObject, RCTBridgeModule {
             self?.players[nativeId]?.seek(time: time.doubleValue)
         }
     }
-    
+
     /**
      Sets `timeShift` on `nativeId`'s player.
      - Parameter nativeId: Target player Id.
@@ -462,7 +482,7 @@ class PlayerModule: NSObject, RCTBridgeModule {
             resolve(self?.players[nativeId]?.isAd)
         }
     }
-    
+
     /**
      The current time shift of the live stream in seconds. This value is always 0 if the active `source` is not a
      live stream or there are no sources loaded.
@@ -480,7 +500,7 @@ class PlayerModule: NSObject, RCTBridgeModule {
             resolve(self?.players[nativeId]?.timeShift)
         }
     }
-    
+
     /**
      Returns the limit in seconds for time shift. Is either negative or 0. Is applicable for live streams only.
      - Parameter nativeId: Target player id.
@@ -497,4 +517,17 @@ class PlayerModule: NSObject, RCTBridgeModule {
             resolve(self?.players[nativeId]?.maxTimeShift)
         }
     }
+
+    /**
+     Sets the max selectable bitrate for the player.
+     - Parameter nativeId: Target player id.
+     - Parameter maxBitrate: The desired max bitrate limit.
+     */
+    @objc(setMaxSelectableBitrate:maxSelectableBitrate:)
+    func setMaxSelectableBitrate(_ nativeId: NativeId, maxSelectableBitrate: NSNumber) {
+        let maxSelectableBitrateValue = maxSelectableBitrate.uintValue
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            self?.players[nativeId]?.maxSelectableBitrate = maxSelectableBitrateValue != -1 ? maxSelectableBitrateValue : 0
+        }
+    }
 }