spactureai-mobile-player 1.0.30

package/ios/hybrids/VideoPlayer/VLCPlaybackDelegates.swift

@@ -0,0 +1,58 @@
+//
+//  VLCPlaybackDelegates.swift
+//  UnifiedPlayer
+//
+//  NSObject bridge for VLCMediaPlayerDelegate + VLCMediaDelegate. The
+//  HybridVideoPlayer type cannot inherit NSObject, so we keep a dedicated
+//  proxy with a weak back-reference to avoid retain cycles with VLCMedia /
+//  VLCMediaPlayer.
+//
+
+import Foundation
+import MobileVLCKit
+
+protocol VLCPlaybackDelegateOwner: AnyObject {
+  func vlcMediaPlayerStateDidChange()
+  func vlcMediaPlayerTimeDidChange()
+  func vlcMediaMetaDataDidChange(_ media: VLCMedia)
+  func vlcMediaDidFinishParsing(_ media: VLCMedia)
+}
+
+/// Single delegate object hung off the player + media to satisfy VLC's
+/// Obj-C delegate protocols without creating cycles (media → delegate →
+/// owner is weak).
+final class VLCPlaybackDelegates: NSObject, VLCMediaPlayerDelegate, VLCMediaDelegate {
+  private weak var owner: VLCPlaybackDelegateOwner?
+
+  init(owner: VLCPlaybackDelegateOwner) {
+    self.owner = owner
+    super.init()
+  }
+
+  func mediaPlayerStateChanged(_ aNotification: Notification) {
+    dispatchToOwner { $0.vlcMediaPlayerStateDidChange() }
+  }
+
+  func mediaPlayerTimeChanged(_ aNotification: Notification) {
+    dispatchToOwner { $0.vlcMediaPlayerTimeDidChange() }
+  }
+
+  func mediaMetaDataDidChange(_ aMedia: VLCMedia) {
+    dispatchToOwner { $0.vlcMediaMetaDataDidChange(aMedia) }
+  }
+
+  func mediaDidFinishParsing(_ aMedia: VLCMedia) {
+    dispatchToOwner { $0.vlcMediaDidFinishParsing(aMedia) }
+  }
+
+  private func dispatchToOwner(_ work: @escaping (VLCPlaybackDelegateOwner) -> Void) {
+    if Thread.isMainThread {
+      if let owner { work(owner) }
+    } else {
+      DispatchQueue.main.async { [weak self] in
+        guard let owner = self?.owner else { return }
+        work(owner)
+      }
+    }
+  }
+}

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("[UnifiedPlayer] Error calling \(eventName) listener: \(error)")
+        }
+      } else {
+        print("[UnifiedPlayer] 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,55 @@
+//
+//  HybridVideoPlayerSource.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+import NitroModules
+
+class HybridVideoPlayerSource: HybridVideoPlayerSourceSpec {
+  var uri: String
+  var config: NativeVideoConfig
+
+  let url: URL
+
+  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()
+  }
+
+  func getAssetInformationAsync() -> Promise<VideoInformation> {
+    let promise = Promise<VideoInformation>()
+    // VLC does not expose pre-load asset metadata cheaply; surface defaults
+    // so the JS API contract still resolves. Real values land via onLoad.
+    promise.resolve(
+      withResult: VideoInformation(
+        bitrate: 0,
+        width: 0,
+        height: 0,
+        duration: 0,
+        fileSize: 0,
+        isHDR: false,
+        isLive: false,
+        orientation: .unknown
+      )
+    )
+    return promise
+  }
+
+  func releaseAsset() {
+    // No persistent asset to release with VLC; lifecycle is owned by the
+    // VLCMedia attached to VLCMediaPlayer in HybridVideoPlayer.
+  }
+
+  var memorySize: Int { 0 }
+}

package/ios/hybrids/VideoPlayerSource/HybridVideoPlayerSourceFactory.swift

@@ -0,0 +1,29 @@
+//
+//  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
+    )
+    return try HybridVideoPlayerSource(config: config)
+  }
+}

package/ios/hybrids/VideoViewViewManager/HybridVideoViewViewManager.swift

@@ -0,0 +1,266 @@
+//
+//  HybridVideoViewViewManager.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+import NitroModules
+
+struct ViewListenerPair {
+  let id: UUID
+  let eventName: String
+  let callback: Any
+}
+
+class HybridVideoViewViewManager: HybridVideoViewViewManagerSpec {
+  weak var view: VideoComponentView?
+  var listeners: [ViewListenerPair] = []
+  
+  let DEALOCATED_WARNING = "UnifiedPlayer: VideoComponentView is no longer available. It is likely that the view was deallocated."
+  
+  init(nitroId: Double) throws {
+    guard let view = VideoComponentView.globalViewsMap.object(forKey: NSNumber(value: nitroId)) else {
+      throw VideoViewError.viewNotFound(nitroId: nitroId).error()
+    }
+    
+    self.view = view
+    super.init()
+    view.delegate = VideoViewDelegate(viewManager: self)
+  }
+  
+  // MARK: - Private helpers
+  
+  private func addListener<T>(eventName: String, listener: T) -> ListenerSubscription {
+    let id = UUID()
+    listeners.append(ViewListenerPair(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("[UnifiedPlayer] Error calling \(eventName) listener: \(error)")
+        }
+      } else {
+        print("[UnifiedPlayer] Invalid callback type for \(eventName)")
+      }
+    }
+  }
+  
+  // MARK: - Properties
+  
+  weak var player: (any HybridVideoPlayerSpec)? {
+    get {
+      guard let view = view else {
+        print(DEALOCATED_WARNING)
+        return nil
+      }
+      return view.player
+    }
+    set {
+      guard let view = view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      view.player = newValue
+    }
+  }
+  
+  var controls: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.controls
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.controls = newValue
+    }
+  }
+  
+  var pictureInPicture: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.allowsPictureInPicturePlayback
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.allowsPictureInPicturePlayback = newValue
+    }
+  }
+  
+  var autoEnterPictureInPicture: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.autoEnterPictureInPicture
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.autoEnterPictureInPicture = newValue
+    }
+  }
+  
+  var resizeMode: ResizeMode {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return .none
+      }
+      
+      return view.resizeMode
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.resizeMode = newValue
+    }
+  }
+  
+  var keepScreenAwake: Bool {
+    get {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return false
+      }
+      
+      return view.keepScreenAwake
+    }
+    set {
+      guard let view else {
+        print(DEALOCATED_WARNING)
+        return
+      }
+      
+      view.keepScreenAwake = newValue
+    }
+  }
+  
+  // Android only - no-op on iOS
+  var surfaceType: SurfaceType = .surface
+  
+  func enterFullscreen() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.enterFullscreen()
+  }
+  
+  func exitFullscreen() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.exitFullscreen()
+  }
+  
+  func enterPictureInPicture() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.startPictureInPicture()
+  }
+  
+  func exitPictureInPicture() throws {
+    guard let view else {
+      throw VideoViewError.viewIsDeallocated.error()
+    }
+    
+    try view.stopPictureInPicture()
+  }
+  
+  func canEnterPictureInPicture() -> Bool {
+    // PiP is not supported on the VLC backend.
+    return false
+  }
+  
+  // MARK: - Listener registration methods
+  
+  func addOnPictureInPictureChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onPictureInPictureChange", listener: listener)
+  }
+  
+  func addOnFullscreenChangeListener(listener: @escaping (Bool) -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "onFullscreenChange", listener: listener)
+  }
+  
+  func addWillEnterFullscreenListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willEnterFullscreen", listener: listener)
+  }
+  
+  func addWillExitFullscreenListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willExitFullscreen", listener: listener)
+  }
+  
+  func addWillEnterPictureInPictureListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willEnterPictureInPicture", listener: listener)
+  }
+  
+  func addWillExitPictureInPictureListener(listener: @escaping () -> Void) throws -> ListenerSubscription {
+    addListener(eventName: "willExitPictureInPicture", listener: listener)
+  }
+  
+  func clearAllListeners() throws {
+    listeners.removeAll()
+  }
+  
+  // MARK: - Event emission methods
+  
+  func onPictureInPictureChange(_ isActive: Bool) {
+    emitEvent(eventName: "onPictureInPictureChange") { (callback: (Bool) throws -> Void) in try callback(isActive) }
+  }
+  
+  func onFullscreenChange(_ isActive: Bool) {
+    emitEvent(eventName: "onFullscreenChange") { (callback: (Bool) throws -> Void) in try callback(isActive) }
+  }
+  
+  func willEnterFullscreen() {
+    emitEvent(eventName: "willEnterFullscreen") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willExitFullscreen() {
+    emitEvent(eventName: "willExitFullscreen") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willEnterPictureInPicture() {
+    emitEvent(eventName: "willEnterPictureInPicture") { (callback: () throws -> Void) in try callback() }
+  }
+  
+  func willExitPictureInPicture() {
+    emitEvent(eventName: "willExitPictureInPicture") { (callback: () throws -> Void) in try callback() }
+  }
+}

package/ios/hybrids/VideoViewViewManager/HybridVideoViewViewManagerFactory.swift

@@ -0,0 +1,14 @@
+//
+//  HybridVideoViewViewManagerFactory.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/09/2024.
+//
+
+import Foundation
+
+class HybridVideoViewViewManagerFactory: HybridVideoViewViewManagerFactorySpec {
+  func createViewManager(nitroId: Double) throws -> any HybridVideoViewViewManagerSpec {
+    return try HybridVideoViewViewManager(nitroId: nitroId)
+  }
+}