react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

package/ios/HybridDownloadManager.swift

@@ -0,0 +1,226 @@
+//
+//  HybridDownloadManager.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 2026-01-23..
+//
+
+import Foundation
+import NitroModules
+
+/// Hybrid implementation of DownloadManagerSpec for iOS
+/// Bridges Nitro modules with the native DownloadManagerCore implementation
+final class HybridDownloadManager: HybridDownloadManagerSpec {
+
+  // MARK: - Properties
+
+  private let core: DownloadManagerCore
+
+  // MARK: - Initialization
+
+  override init() {
+    core = DownloadManagerCore.shared
+    super.init()
+  }
+
+  // MARK: - Configuration
+
+  func configure(config: DownloadConfig) throws {
+    core.configure(config)
+  }
+
+  func getConfig() throws -> DownloadConfig {
+    return core.getConfig()
+  }
+
+  // MARK: - Download Operations
+
+  func downloadTrack(track: TrackItem, playlistId: String?) throws -> Promise<String> {
+    return Promise.async {
+      return self.core.downloadTrack(track: track, playlistId: playlistId)
+    }
+  }
+
+  func downloadPlaylist(playlistId: String, tracks: [TrackItem]) throws -> Promise<[String]> {
+    return Promise.async {
+      return self.core.downloadPlaylist(playlistId: playlistId, tracks: tracks)
+    }
+  }
+
+  // MARK: - Download Control
+
+  func pauseDownload(downloadId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.pauseDownload(downloadId: downloadId)
+    }
+  }
+
+  func resumeDownload(downloadId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.resumeDownload(downloadId: downloadId)
+    }
+  }
+
+  func cancelDownload(downloadId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.cancelDownload(downloadId: downloadId)
+    }
+  }
+
+  func retryDownload(downloadId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.retryDownload(downloadId: downloadId)
+    }
+  }
+
+  func pauseAllDownloads() throws -> Promise<Void> {
+    return Promise.async {
+      self.core.pauseAllDownloads()
+    }
+  }
+
+  func resumeAllDownloads() throws -> Promise<Void> {
+    return Promise.async {
+      self.core.resumeAllDownloads()
+    }
+  }
+
+  func cancelAllDownloads() throws -> Promise<Void> {
+    return Promise.async {
+      self.core.cancelAllDownloads()
+    }
+  }
+
+  // MARK: - Download Status
+
+  func getDownloadTask(downloadId: String) throws -> Variant_NullType_DownloadTask {
+    if let task = core.getDownloadTask(downloadId: downloadId) {
+      return Variant_NullType_DownloadTask.second(task)
+    }
+    return Variant_NullType_DownloadTask.first(NullType.null)
+  }
+
+  func getActiveDownloads() throws -> [DownloadTask] {
+    return core.getActiveDownloads()
+  }
+
+  func getQueueStatus() throws -> DownloadQueueStatus {
+    return core.getQueueStatus()
+  }
+
+  func isDownloading(trackId: String) throws -> Bool {
+    return core.isDownloading(trackId: trackId)
+  }
+
+  func getDownloadState(trackId: String) throws -> DownloadState {
+    return core.getDownloadState(trackId: trackId) ?? .pending
+  }
+
+  // MARK: - Downloaded Content Queries
+
+  func isTrackDownloaded(trackId: String) throws -> Bool {
+    return core.isTrackDownloaded(trackId: trackId)
+  }
+
+  func isPlaylistDownloaded(playlistId: String) throws -> Bool {
+    return core.isPlaylistDownloaded(playlistId: playlistId)
+  }
+
+  func isPlaylistPartiallyDownloaded(playlistId: String) throws -> Bool {
+    return core.isPlaylistPartiallyDownloaded(playlistId: playlistId)
+  }
+
+  func getDownloadedTrack(trackId: String) throws -> Variant_NullType_DownloadedTrack {
+    if let track = core.getDownloadedTrack(trackId: trackId) {
+      return Variant_NullType_DownloadedTrack.second(track)
+    }
+    return Variant_NullType_DownloadedTrack.first(NullType.null)
+  }
+
+  func getAllDownloadedTracks() throws -> [DownloadedTrack] {
+    return core.getAllDownloadedTracks()
+  }
+
+  func getDownloadedPlaylist(playlistId: String) throws -> Variant_NullType_DownloadedPlaylist {
+    if let playlist = core.getDownloadedPlaylist(playlistId: playlistId) {
+      return Variant_NullType_DownloadedPlaylist.second(playlist)
+    }
+    return Variant_NullType_DownloadedPlaylist.first(NullType.null)
+  }
+
+  func getAllDownloadedPlaylists() throws -> [DownloadedPlaylist] {
+    return core.getAllDownloadedPlaylists()
+  }
+
+  func getLocalPath(trackId: String) throws -> Variant_NullType_String {
+    if let path = core.getLocalPath(trackId: trackId) {
+      return Variant_NullType_String.second(path)
+    }
+    return Variant_NullType_String.first(NullType.null)
+  }
+
+  // MARK: - Deletion
+
+  func deleteDownloadedTrack(trackId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.deleteDownloadedTrack(trackId: trackId)
+    }
+  }
+
+  func deleteDownloadedPlaylist(playlistId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.deleteDownloadedPlaylist(playlistId: playlistId)
+    }
+  }
+
+  func deleteAllDownloads() throws -> Promise<Void> {
+    return Promise.async {
+      self.core.deleteAllDownloads()
+    }
+  }
+
+  // MARK: - Storage Management
+
+  func getStorageInfo() throws -> Promise<DownloadStorageInfo> {
+    return Promise.async {
+      return self.core.getStorageInfo()
+    }
+  }
+
+  func syncDownloads() throws -> Double {
+    return Double(core.syncDownloads())
+  }
+
+  // MARK: - Playback Source Preference
+
+  func setPlaybackSourcePreference(preference: PlaybackSource) throws {
+    core.setPlaybackSourcePreference(preference)
+  }
+
+  func getPlaybackSourcePreference() throws -> PlaybackSource {
+    return core.getPlaybackSourcePreference()
+  }
+
+  func getEffectiveUrl(track: TrackItem) throws -> String {
+    return core.getEffectiveUrl(track: track)
+  }
+
+  // MARK: - Event Callbacks
+
+  func onDownloadProgress(callback: @escaping (DownloadProgress) -> Void) throws {
+    print("🎯 HybridDownloadManager: onDownloadProgress callback registered")
+    core.addProgressCallback(callback)
+  }
+
+  func onDownloadStateChange(
+    callback: @escaping (String, String, DownloadState, DownloadError?) -> Void
+  ) throws {
+    print("🎯 HybridDownloadManager: onDownloadStateChange callback registered")
+    core.addStateChangeCallback(callback)
+  }
+
+  func onDownloadComplete(callback: @escaping (DownloadedTrack) -> Void) throws {
+    print("🎯 HybridDownloadManager: onDownloadComplete callback registered")
+    core.addCompleteCallback(callback)
+  }
+}

package/ios/HybridEqualizer.swift

@@ -0,0 +1,111 @@
+//
+//  HybridEqualizer.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 04/02/26.
+//
+
+import Foundation
+import NitroModules
+
+final class HybridEqualizer: HybridEqualizerSpec {
+  // MARK: - Properties
+
+  private let core: EqualizerCore
+
+  // MARK: - Initialization
+
+  override init() {
+    core = EqualizerCore.shared
+    super.init()
+  }
+
+  // MARK: - Enable/Disable
+
+  func setEnabled(enabled: Bool) throws -> Bool {
+    return core.setEnabled(enabled)
+  }
+
+  func isEnabled() throws -> Bool {
+    return core.isEnabled()
+  }
+
+  // MARK: - Band Control
+
+  func getBands() throws -> [EqualizerBand] {
+    return core.getBands()
+  }
+
+  func setBandGain(bandIndex: Double, gainDb: Double) throws -> Bool {
+    return core.setBandGain(bandIndex: Int(bandIndex), gainDb: gainDb)
+  }
+
+  func setAllBandGains(gains: [Double]) throws -> Bool {
+    return core.setAllBandGains(gains)
+  }
+
+  func getBandRange() throws -> GainRange {
+    return core.getBandRange()
+  }
+
+  // MARK: - Presets
+
+  func getPresets() throws -> [EqualizerPreset] {
+    return core.getPresets()
+  }
+
+  func getBuiltInPresets() throws -> [EqualizerPreset] {
+    return core.getBuiltInPresets()
+  }
+
+  func getCustomPresets() throws -> [EqualizerPreset] {
+    return core.getCustomPresets()
+  }
+
+  func applyPreset(presetName: String) throws -> Bool {
+    return core.applyPreset(presetName)
+  }
+
+  func getCurrentPresetName() throws -> Variant_NullType_String {
+    if let name = core.getCurrentPresetName() {
+      return .second(name)
+    } else {
+      return .first(NullType.null)
+    }
+  }
+
+  func saveCustomPreset(name: String) throws -> Bool {
+    return core.saveCustomPreset(name)
+  }
+
+  func deleteCustomPreset(name: String) throws -> Bool {
+    return core.deleteCustomPreset(name)
+  }
+
+  // MARK: - State
+
+  func getState() throws -> EqualizerState {
+    return core.getState()
+  }
+
+  func reset() throws {
+    core.reset()
+  }
+
+  // MARK: - Event Callbacks
+
+  func onEnabledChange(callback: @escaping (Bool) -> Void) throws {
+    print("🎯 HybridEqualizer: onEnabledChange callback registered")
+    core.addOnEnabledChangeListener(owner: self, callback)
+  }
+
+  func onBandChange(callback: @escaping ([EqualizerBand]) -> Void) throws {
+    print("🎯 HybridEqualizer: onBandChange callback registered")
+    core.addOnBandChangeListener(owner: self, callback)
+  }
+
+  func onPresetChange(callback: @escaping (Variant_NullType_String?) -> Void) throws {
+    print("🎯 HybridEqualizer: onPresetChange callback registered")
+    core.addOnPresetChangeListener(owner: self, callback)
+  }
+}

package/ios/HybridTrackPlayer.swift

@@ -32,8 +32,10 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     core.pause()
   }
 
-  func playSong(songId: String, fromPlaylist: String?) throws {
-    core.playSong(songId: songId, fromPlaylist: fromPlaylist)
+  func playSong(songId: String, fromPlaylist: String?) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.playSong(songId: songId, fromPlaylist: fromPlaylist)
+    }
   }
 
   func skipToNext() throws {
@@ -48,8 +50,28 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     core.seek(position: position)
   }
 
-  func getState() throws -> PlayerState {
-    return core.getState()
+  func addToUpNext(trackId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.addToUpNext(trackId: trackId)
+    }
+  }
+
+  func playNext(trackId: String) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.playNext(trackId: trackId)
+    }
+  }
+
+  func getActualQueue() throws -> Promise<[TrackItem]> {
+    return Promise.async {
+      return self.core.getActualQueue()
+    }
+  }
+
+  func getState() throws -> Promise<PlayerState> {
+    return Promise.async {
+      return self.core.getState()
+    }
   }
 
   func setRepeatMode(mode: RepeatMode) throws -> Bool {
@@ -70,22 +92,22 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
 
   func onChangeTrack(callback: @escaping (TrackItem, Reason?) -> Void) throws {
     print("🎯 HybridTrackPlayer: onChangeTrack callback registered")
-    core.onChangeTrack = callback
+    core.addOnChangeTrackListener(owner: self, callback)
   }
 
   func onPlaybackStateChange(callback: @escaping (TrackPlayerState, Reason?) -> Void) throws {
     print("🎯 HybridTrackPlayer: onPlaybackStateChange callback registered")
-    core.onPlaybackStateChange = callback
+    core.addOnPlaybackStateChangeListener(owner: self, callback)
   }
 
   func onSeek(callback: @escaping (Double, Double) -> Void) throws {
     print("🎯 HybridTrackPlayer: onSeek callback registered")
-    core.onSeek = callback
+    core.addOnSeekListener(owner: self, callback)
   }
 
   func onPlaybackProgressChange(callback: @escaping (Double, Double, Bool?) -> Void) throws {
     print("🎯 HybridTrackPlayer: onPlaybackProgressChange callback registered")
-    core.onPlaybackProgressChange = callback
+    core.addOnPlaybackProgressChangeListener(owner: self, callback)
   }
 
   // MARK: - Android Auto (iOS No-op)
@@ -102,6 +124,12 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     return false
   }
 
+  func skipToIndex(index: Double) throws -> Promise<Bool> {
+    return Promise.async {
+      return self.core.skipToIndex(index: Int(index))
+    }
+  }
+
   // MARK: - Volume Control
 
   func setVolume(volume: Double) throws -> Bool {