@pigeonmal/react-native-video 7.0.0-beta.10

package/ios/hybrids/VideoPlayerEmitter/HybridVideoPlayerEventEmitter.swift

@@ -0,0 +1,203 @@
+//
+//  HybridVideoPlayerEventEmitter.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 02/05/2025.
+//
+
+import Foundation
+import NitroModules
+
+struct ListenerPair {
+  let id: UUID
+  let eventName: String
+  let callback: Any
+}
+
+class HybridVideoPlayerEventEmitter: HybridVideoPlayerEventEmitterSpec {
+  var listeners: [ListenerPair] = []
+
+  // MARK: - Private helpers
+
+  private func addListener<T>(eventName: String, listener: T) -> ListenerSubscription {
+    let id = UUID()
+    listeners.append(ListenerPair(id: id, eventName: eventName, callback: listener))
+    return ListenerSubscription(remove: { [weak self] in
+      self?.listeners.removeAll { $0.id == id }
+    })
+  }
+
+  private func emitEvent<T>(eventName: String, invoke: (T) throws -> Void) {
+    for pair in listeners where pair.eventName == eventName {
+      if let callback = pair.callback as? T {
+        do {
+          try invoke(callback)
+        } catch {
+          print("[ReactNativeVideo] Error calling \(eventName) listener: \(error)")
+        }
+      } else {
+        print("[ReactNativeVideo] Invalid callback type for \(eventName)")
+      }
+    }
+  }
+
+  // MARK: - Listener registration methods
+
+  func addOnAudioBecomingNoisyListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onAudioBecomingNoisy", listener: listener)
+  }
+
+  func addOnAudioFocusChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onAudioFocusChange", listener: listener)
+  }
+
+  func addOnBandwidthUpdateListener(listener: @escaping (BandwidthData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onBandwidthUpdate", listener: listener)
+  }
+
+  func addOnBufferListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onBuffer", listener: listener)
+  }
+
+  func addOnControlsVisibleChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onControlsVisibleChange", listener: listener)
+  }
+
+  func addOnEndListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onEnd", listener: listener)
+  }
+
+  func addOnExternalPlaybackChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onExternalPlaybackChange", listener: listener)
+  }
+
+  func addOnLoadListener(listener: @escaping (onLoadData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onLoad", listener: listener)
+  }
+
+  func addOnLoadStartListener(listener: @escaping (onLoadStartData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onLoadStart", listener: listener)
+  }
+
+  func addOnPlaybackStateChangeListener(listener: @escaping (onPlaybackStateChangeData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onPlaybackStateChange", listener: listener)
+  }
+
+  func addOnPlaybackRateChangeListener(listener: @escaping (Double) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onPlaybackRateChange", listener: listener)
+  }
+
+  func addOnProgressListener(listener: @escaping (onProgressData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onProgress", listener: listener)
+  }
+
+  func addOnReadyToDisplayListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onReadyToDisplay", listener: listener)
+  }
+
+  func addOnSeekListener(listener: @escaping (Double) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onSeek", listener: listener)
+  }
+
+  func addOnStatusChangeListener(listener: @escaping (VideoPlayerStatus) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onStatusChange", listener: listener)
+  }
+
+  func addOnTimedMetadataListener(listener: @escaping (TimedMetadata) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onTimedMetadata", listener: listener)
+  }
+
+  func addOnTextTrackDataChangedListener(listener: @escaping ([String]) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onTextTrackDataChanged", listener: listener)
+  }
+
+  func addOnTrackChangeListener(listener: @escaping (Variant_NullType_TextTrack?) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onTrackChange", listener: listener)
+  }
+
+  func addOnVolumeChangeListener(listener: @escaping (onVolumeChangeData) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onVolumeChange", listener: listener)
+  }
+
+  func clearAllListeners() throws {
+    listeners.removeAll()
+  }
+
+  // MARK: - Event emission methods
+
+  func onAudioBecomingNoisy() {
+    emitEvent(eventName: "onAudioBecomingNoisy") { (callback: () throws -> Void) in try callback() }
+  }
+
+  func onAudioFocusChange(_ hasFocus: Bool) {
+    emitEvent(eventName: "onAudioFocusChange") { (callback: (Bool) throws -> Void) in try callback(hasFocus) }
+  }
+
+  func onBandwidthUpdate(_ data: BandwidthData) {
+    emitEvent(eventName: "onBandwidthUpdate") { (callback: (BandwidthData) throws -> Void) in try callback(data) }
+  }
+
+  func onBuffer(_ isBuffering: Bool) {
+    emitEvent(eventName: "onBuffer") { (callback: (Bool) throws -> Void) in try callback(isBuffering) }
+  }
+
+  func onControlsVisibleChange(_ isVisible: Bool) {
+    emitEvent(eventName: "onControlsVisibleChange") { (callback: (Bool) throws -> Void) in try callback(isVisible) }
+  }
+
+  func onEnd() {
+    emitEvent(eventName: "onEnd") { (callback: () throws -> Void) in try callback() }
+  }
+
+  func onExternalPlaybackChange(_ isExternalPlaybackActive: Bool) {
+    emitEvent(eventName: "onExternalPlaybackChange") { (callback: (Bool) throws -> Void) in try callback(isExternalPlaybackActive) }
+  }
+
+  func onLoad(_ data: onLoadData) {
+    emitEvent(eventName: "onLoad") { (callback: (onLoadData) throws -> Void) in try callback(data) }
+  }
+
+  func onLoadStart(_ data: onLoadStartData) {
+    emitEvent(eventName: "onLoadStart") { (callback: (onLoadStartData) throws -> Void) in try callback(data) }
+  }
+
+  func onPlaybackStateChange(_ data: onPlaybackStateChangeData) {
+    emitEvent(eventName: "onPlaybackStateChange") { (callback: (onPlaybackStateChangeData) throws -> Void) in try callback(data) }
+  }
+
+  func onPlaybackRateChange(_ rate: Double) {
+    emitEvent(eventName: "onPlaybackRateChange") { (callback: (Double) throws -> Void) in try callback(rate) }
+  }
+
+  func onProgress(_ data: onProgressData) {
+    emitEvent(eventName: "onProgress") { (callback: (onProgressData) throws -> Void) in try callback(data) }
+  }
+
+  func onReadyToDisplay() {
+    emitEvent(eventName: "onReadyToDisplay") { (callback: () throws -> Void) in try callback() }
+  }
+
+  func onSeek(_ position: Double) {
+    emitEvent(eventName: "onSeek") { (callback: (Double) throws -> Void) in try callback(position) }
+  }
+
+  func onStatusChange(_ status: VideoPlayerStatus) {
+    emitEvent(eventName: "onStatusChange") { (callback: (VideoPlayerStatus) throws -> Void) in try callback(status) }
+  }
+
+  func onTimedMetadata(_ metadata: TimedMetadata) {
+    emitEvent(eventName: "onTimedMetadata") { (callback: (TimedMetadata) throws -> Void) in try callback(metadata) }
+  }
+
+  func onTextTrackDataChanged(_ tracks: [String]) {
+    emitEvent(eventName: "onTextTrackDataChanged") { (callback: ([String]) throws -> Void) in try callback(tracks) }
+  }
+
+  func onTrackChange(_ track: Variant_NullType_TextTrack?) {
+    emitEvent(eventName: "onTrackChange") { (callback: (Variant_NullType_TextTrack?) throws -> Void) in try callback(track) }
+  }
+
+  func onVolumeChange(_ data: onVolumeChangeData) {
+    emitEvent(eventName: "onVolumeChange") { (callback: (onVolumeChangeData) throws -> Void) in try callback(data) }
+  }
+}

package/ios/hybrids/VideoPlayerSource/HybridVideoPlayerSource.swift

@@ -0,0 +1,166 @@
+//
+//  HybridVideoPlayerSource.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import AVFoundation
+import Foundation
+import NitroModules
+
+class HybridVideoPlayerSource: HybridVideoPlayerSourceSpec, NativeVideoPlayerSourceSpec {
+  var asset: AVURLAsset?
+  var uri: String
+  var config: NativeVideoConfig
+
+  var drmManager: DRMManagerSpec?
+
+  let url: URL
+  private let sourceLoader = SourceLoader()
+
+  init(config: NativeVideoConfig) throws {
+    self.uri = config.uri
+    self.config = config
+
+    guard let url = URL(string: uri) else {
+      throw SourceError.invalidUri(uri: uri).error()
+    }
+
+    self.url = url
+
+    super.init()
+
+    if config.drm != nil {
+      // Try to get the DRM manager
+      // If no DRM manager is found, it will throw an error
+      _ = try PluginsRegistry.shared.getDrmManager(source: self)
+    }
+  }
+
+  deinit {
+    releaseAsset()
+  }
+
+  func getAssetInformationAsync() -> Promise<VideoInformation> {
+    let promise = Promise<VideoInformation>()
+
+    Task.detached(priority: .utility) { [weak self] in
+      guard let self else {
+        promise.reject(
+          withError: LibraryError.deallocated(objectName: "HybridVideoPlayerSource").error())
+        return
+      }
+
+      do {
+        let videoInformation = try await self.sourceLoader.load(priority: .utility) {
+          if self.url.isFileURL {
+            try VideoFileHelper.validateReadPermission(for: self.url)
+          }
+
+          try await self.initializeAsset()
+
+          guard let asset = self.asset else {
+            throw PlayerError.assetNotInitialized.error()
+          }
+
+          return try await asset.getAssetInformation()
+        }
+
+        promise.resolve(withResult: videoInformation)
+      } catch {
+        if error is CancellationError {
+          promise.reject(withError: SourceError.cancelled.error())
+        } else {
+          promise.reject(withError: error)
+        }
+      }
+    }
+
+    return promise
+  }
+
+  func initializeAsset() async throws {
+    guard asset == nil else {
+      return
+    }
+
+    if let headers = config.headers {
+      let options = [
+        "AVURLAssetHTTPHeaderFieldsKey": headers
+      ]
+      asset = AVURLAsset(url: url, options: options)
+    } else {
+      asset = AVURLAsset(url: url)
+    }
+
+    guard let asset else {
+      throw SourceError.failedToInitializeAsset.error()
+    }
+
+    do {
+      if let drmParams = config.drm {
+        drmManager = try PluginsRegistry.shared.getDrmManager(source: self)
+
+        guard let drmManager else {
+          throw LibraryError.DRMPluginNotFound.error()
+        }
+
+        do {
+          try drmManager.createContentKeyRequest(for: asset, drmParams: drmParams)
+        } catch {
+          print("[ReactNativeVideo] Failed to create content key request for DRM: \(drmParams)")
+        }
+      }
+
+      // Code browned from expo-video https://github.com/expo/expo/blob/ea17c9b1ce5111e1454b089ba381f3feb93f33cc/packages/expo-video/ios/VideoPlayerItem.swift#L40C30-L40C73
+      // If we don't load those properties, they will be loaded on main thread causing lags
+      _ = try? await asset.load(.duration, .preferredTransform, .isPlayable) as Any
+
+      try Task.checkCancellation()
+    } catch {
+      self.asset = nil
+      if error is CancellationError {
+        throw SourceError.cancelled.error()
+      }
+      throw error
+    }
+  }
+
+  func getAsset() async throws -> AVURLAsset {
+    if let asset {
+      return asset
+    }
+
+    do {
+      try await sourceLoader.load {
+        try await self.initializeAsset()
+      }
+
+      guard let asset else {
+        throw SourceError.failedToInitializeAsset.error()
+      }
+
+      return asset
+    } catch {
+      if error is CancellationError {
+        self.asset = nil
+        throw SourceError.cancelled.error()
+      }
+      throw error
+    }
+  }
+
+  func releaseAsset() {
+    sourceLoader.cancelSync()
+    asset = nil
+  }
+
+  var memorySize: Int {
+    var size = 0
+
+    size += asset?.estimatedMemoryUsage ?? 0
+
+    return size
+  }
+}

package/ios/hybrids/VideoPlayerSource/HybridVideoPlayerSourceFactory.swift

@@ -0,0 +1,30 @@
+//
+//  HybridVideoPlayerSourceFactory.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+
+class HybridVideoPlayerSourceFactory: HybridVideoPlayerSourceFactorySpec {
+  func fromVideoConfig(config: NativeVideoConfig) throws
+    -> any HybridVideoPlayerSourceSpec
+  {
+    return try HybridVideoPlayerSource(config: config)
+  }
+
+  func fromUri(uri: String) throws -> HybridVideoPlayerSourceSpec {
+    let config = NativeVideoConfig(
+      uri: uri,
+      externalSubtitles: nil,
+      drm: nil,
+      headers: nil,
+      bufferConfig: nil,
+      metadata: nil,
+      initializeOnCreation: true,
+      forceType: nil
+    )
+    return try HybridVideoPlayerSource(config: config)
+  }
+}

package/ios/hybrids/VideoPlayerSource/SourceLoader.swift

@@ -0,0 +1,83 @@
+//
+//  SourceLoader.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 27/01/2025.
+//
+
+import Foundation
+
+private class AnyCancellable {
+  private let _cancel: () -> Void
+
+  init(_ cancel: @escaping () -> Void) {
+    self._cancel = cancel
+  }
+
+  func cancel() {
+    _cancel()
+  }
+}
+
+actor SourceLoaderActor {
+  private var currentCancellable: AnyCancellable?
+
+  func load<T>(priority: TaskPriority, operation: @escaping () async throws -> T) async throws -> T
+  {
+    await cancelCurrentTask()
+
+    let cancellableTask = Task(priority: priority) {
+      try await operation()
+    }
+
+    let cancellable = AnyCancellable {
+      cancellableTask.cancel()
+    }
+    currentCancellable = cancellable
+
+    do {
+      let result = try await cancellableTask.value
+      if currentCancellable === cancellable {
+        currentCancellable = nil
+      }
+      return result
+    } catch {
+      if currentCancellable === cancellable {
+        currentCancellable = nil
+      }
+      if error is CancellationError {
+        throw error
+      }
+      throw error
+    }
+  }
+
+  func cancel() async {
+    await cancelCurrentTask()
+  }
+
+  private func cancelCurrentTask() async {
+    currentCancellable?.cancel()
+    currentCancellable = nil
+  }
+}
+
+class SourceLoader {
+  private let actor = SourceLoaderActor()
+
+  func load<T>(priority: TaskPriority = .userInitiated, operation: @escaping () async throws -> T)
+    async throws -> T
+  {
+    return try await actor.load(priority: priority, operation: operation)
+  }
+
+  func cancel() async {
+    await actor.cancel()
+  }
+
+  func cancelSync() {
+    Task {
+      await actor.cancel()
+    }
+  }
+}