react-native-nitro-player 0.7.0 → 0.7.1-alpha.0

package/ios/HybridEqualizer.swift

@@ -12,6 +12,7 @@ final class HybridEqualizer: HybridEqualizerSpec {
   // MARK: - Properties
 
   private let core: EqualizerCore
+  private var listenerIds: [(String, Int64)] = []
 
   // MARK: - Initialization
 
@@ -22,90 +23,102 @@ final class HybridEqualizer: HybridEqualizerSpec {
 
   // MARK: - Enable/Disable
 
-  func setEnabled(enabled: Bool) throws -> Bool {
-    return core.setEnabled(enabled)
+  func setEnabled(enabled: Bool) throws -> Promise<Void> {
+    Promise.async { _ = self.core.setEnabled(enabled) }
   }
 
   func isEnabled() throws -> Bool {
-    return core.isEnabled()
+    core.isEnabled()
   }
 
   // MARK: - Band Control
 
-  func getBands() throws -> [EqualizerBand] {
-    return core.getBands()
+  func getBands() throws -> Promise<[EqualizerBand]> {
+    Promise.async { self.core.getBands() }
   }
 
-  func setBandGain(bandIndex: Double, gainDb: Double) throws -> Bool {
-    return core.setBandGain(bandIndex: Int(bandIndex), gainDb: gainDb)
+  func setBandGain(bandIndex: Double, gainDb: Double) throws -> Promise<Void> {
+    Promise.async { _ = self.core.setBandGain(bandIndex: Int(bandIndex), gainDb: gainDb) }
   }
 
-  func setAllBandGains(gains: [Double]) throws -> Bool {
-    return core.setAllBandGains(gains)
+  func setAllBandGains(gains: [Double]) throws -> Promise<Void> {
+    Promise.async { _ = self.core.setAllBandGains(gains) }
   }
 
   func getBandRange() throws -> GainRange {
-    return core.getBandRange()
+    core.getBandRange()
   }
 
   // MARK: - Presets
 
   func getPresets() throws -> [EqualizerPreset] {
-    return core.getPresets()
+    core.getPresets()
   }
 
   func getBuiltInPresets() throws -> [EqualizerPreset] {
-    return core.getBuiltInPresets()
+    core.getBuiltInPresets()
   }
 
   func getCustomPresets() throws -> [EqualizerPreset] {
-    return core.getCustomPresets()
+    core.getCustomPresets()
   }
 
-  func applyPreset(presetName: String) throws -> Bool {
-    return core.applyPreset(presetName)
+  func applyPreset(presetName: String) throws -> Promise<Void> {
+    Promise.async { _ = self.core.applyPreset(presetName) }
   }
 
   func getCurrentPresetName() throws -> Variant_NullType_String {
     if let name = core.getCurrentPresetName() {
       return .second(name)
-    } else {
-      return .first(NullType.null)
     }
+    return .first(NullType.null)
   }
 
-  func saveCustomPreset(name: String) throws -> Bool {
-    return core.saveCustomPreset(name)
+  func saveCustomPreset(name: String) throws -> Promise<Void> {
+    Promise.async { _ = self.core.saveCustomPreset(name) }
   }
 
-  func deleteCustomPreset(name: String) throws -> Bool {
-    return core.deleteCustomPreset(name)
+  func deleteCustomPreset(name: String) throws -> Promise<Void> {
+    Promise.async { _ = self.core.deleteCustomPreset(name) }
   }
 
   // MARK: - State
 
-  func getState() throws -> EqualizerState {
-    return core.getState()
+  func getState() throws -> Promise<EqualizerState> {
+    Promise.async { self.core.getState() }
   }
 
-  func reset() throws {
-    core.reset()
+  func reset() throws -> Promise<Void> {
+    Promise.async { self.core.reset() }
   }
 
-  // MARK: - Event Callbacks
+  // MARK: - Event listeners (v2 — store IDs for cleanup)
 
-  func onEnabledChange(callback: @escaping (Bool) -> Void) throws {
-    NitroPlayerLogger.log("HybridEqualizer", "onEnabledChange callback registered")
-    core.addOnEnabledChangeListener(owner: self, callback)
+  func onEnabledChange(callback: @escaping (_ enabled: Bool) -> Void) throws {
+    let id = core.addOnEnabledChangeListener(callback)
+    listenerIds.append(("onEnabledChange", id))
   }
 
-  func onBandChange(callback: @escaping ([EqualizerBand]) -> Void) throws {
-    NitroPlayerLogger.log("HybridEqualizer", "onBandChange callback registered")
-    core.addOnBandChangeListener(owner: self, callback)
+  func onBandChange(callback: @escaping (_ bands: [EqualizerBand]) -> Void) throws {
+    let id = core.addOnBandChangeListener(callback)
+    listenerIds.append(("onBandChange", id))
   }
 
-  func onPresetChange(callback: @escaping (Variant_NullType_String?) -> Void) throws {
-    NitroPlayerLogger.log("HybridEqualizer", "onPresetChange callback registered")
-    core.addOnPresetChangeListener(owner: self, callback)
+  func onPresetChange(callback: @escaping (_ presetName: Variant_NullType_String?) -> Void) throws {
+    let id = core.addOnPresetChangeListener(callback)
+    listenerIds.append(("onPresetChange", id))
+  }
+
+  // MARK: - Cleanup
+
+  deinit {
+    for (type, id) in listenerIds {
+      switch type {
+      case "onEnabledChange": _ = core.removeOnEnabledChangeListener(id: id)
+      case "onBandChange":    _ = core.removeOnBandChangeListener(id: id)
+      case "onPresetChange":  _ = core.removeOnPresetChangeListener(id: id)
+      default: break
+      }
+    }
   }
 }

package/ios/HybridTrackPlayer.swift

@@ -15,6 +15,9 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
 
   private let core: TrackPlayerCore
 
+  /// Stable listener IDs for cleanup on deinit
+  private var listenerIds: [(String, Int64)] = []
+
   // MARK: - Initialization
 
   override init() {
@@ -22,174 +25,196 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     super.init()
   }
 
-  // MARK: - Playback Control
+  // MARK: - Playback Control (async Promise<Void>)
+
+  func play() throws -> Promise<Void> {
+    Promise.async { await self.core.play() }
+  }
+
+  func pause() throws -> Promise<Void> {
+    Promise.async { await self.core.pause() }
+  }
+
+  func seek(position: Double) throws -> Promise<Void> {
+    Promise.async { await self.core.seek(position: position) }
+  }
 
-  func play() throws {
-    core.play()
+  func skipToNext() throws -> Promise<Void> {
+    Promise.async { await self.core.skipToNext() }
   }
 
-  func pause() throws {
-    core.pause()
+  func skipToPrevious() throws -> Promise<Void> {
+    Promise.async { await self.core.skipToPrevious() }
   }
 
   func playSong(songId: String, fromPlaylist: String?) throws -> Promise<Void> {
-    return Promise.async {
-      self.core.playSong(songId: songId, fromPlaylist: fromPlaylist)
-    }
+    Promise.async { await self.core.playSong(songId: songId, fromPlaylist: fromPlaylist) }
   }
 
-  func skipToNext() throws {
-    core.skipToNext()
+  func skipToIndex(index: Double) throws -> Promise<Bool> {
+    Promise.async { await self.core.skipToIndex(index: Int(index)) }
   }
 
-  func skipToPrevious() throws {
-    core.skipToPrevious()
+  // MARK: - Repeat / Volume / Config
+
+  func setRepeatMode(mode: RepeatMode) throws -> Promise<Void> {
+    Promise.async { await self.core.setRepeatMode(mode: mode) }
   }
 
-  func seek(position: Double) throws {
-    core.seek(position: position)
+  func getRepeatMode() throws -> RepeatMode {
+    core.getRepeatMode()
   }
 
-  func addToUpNext(trackId: String) throws -> Promise<Void> {
-    return Promise.async {
-      self.core.addToUpNext(trackId: trackId)
-    }
+  func setVolume(volume: Double) throws -> Promise<Void> {
+    Promise.async { await self.core.setVolume(volume: volume) }
   }
 
-  func playNext(trackId: String) throws -> Promise<Void> {
-    return Promise.async {
-      self.core.playNext(trackId: trackId)
+  func configure(config: PlayerConfig) throws -> Promise<Void> {
+    Promise.async {
+      await self.core.configure(
+        androidAutoEnabled: config.androidAutoEnabled,
+        carPlayEnabled: config.carPlayEnabled,
+        showInNotification: config.showInNotification,
+        lookaheadCount: config.lookaheadCount.map { Int($0) }
+      )
     }
   }
 
+  // MARK: - Queue / State reads
+
   func getActualQueue() throws -> Promise<[TrackItem]> {
-    return Promise.async {
-      return self.core.getActualQueue()
-    }
+    Promise.async { await self.core.getActualQueue() }
   }
 
   func getState() throws -> Promise<PlayerState> {
-    return Promise.async {
-      return self.core.getState()
-    }
+    Promise.async { await self.core.getState() }
   }
 
-  func setRepeatMode(mode: RepeatMode) throws -> Bool {
-    return core.setRepeatMode(mode: mode)
+  func getCurrentTrackIndex() throws -> Promise<Double> {
+    Promise.async { Double(await self.core.getCurrentTrackIndex()) }
   }
 
-  func getRepeatMode() throws -> RepeatMode {
-    return core.getRepeatMode()
+  // MARK: - URL updates / lazy loading
+
+  func updateTracks(tracks: [TrackItem]) throws -> Promise<Void> {
+    Promise.async { await self.core.updateTracks(tracks: tracks) }
+  }
+
+  func getTracksById(trackIds: [String]) throws -> Promise<[TrackItem]> {
+    Promise.async { await self.core.getTracksById(trackIds: trackIds) }
   }
 
-  // MARK: - Configuration
+  func getTracksNeedingUrls() throws -> Promise<[TrackItem]> {
+    Promise.async { await self.core.getTracksNeedingUrls() }
+  }
 
-  func configure(config: PlayerConfig) throws {
-    core.configure(
-      androidAutoEnabled: config.androidAutoEnabled,
-      carPlayEnabled: config.carPlayEnabled,
-      showInNotification: config.showInNotification,
-      lookaheadCount: config.lookaheadCount.map { Int($0) }
-    )
+  func getNextTracks(count: Double) throws -> Promise<[TrackItem]> {
+    Promise.async { await self.core.getNextTracks(count: Int(count)) }
   }
 
-  // MARK: - Event Callbacks
+  // MARK: - Playback speed
+
+  func setPlaybackSpeed(speed: Double) throws -> Promise<Void> {
+    Promise.async { await self.core.setPlaybackSpeed(speed) }
+  }
 
-  func onChangeTrack(callback: @escaping (TrackItem, Reason?) -> Void) throws {
-    NitroPlayerLogger.log("HybridTrackPlayer", "onChangeTrack callback registered")
-    core.addOnChangeTrackListener(owner: self, callback)
+  func getPlaybackSpeed() throws -> Promise<Double> {
+    Promise.async { await self.core.getPlaybackSpeed() }
   }
 
-  func onPlaybackStateChange(callback: @escaping (TrackPlayerState, Reason?) -> Void) throws {
-    NitroPlayerLogger.log("HybridTrackPlayer", "onPlaybackStateChange callback registered")
-    core.addOnPlaybackStateChangeListener(owner: self, callback)
+  // MARK: - Temporary queue v2
+
+  func addToUpNext(trackId: String) throws -> Promise<Void> {
+    Promise.async { try await self.core.addToUpNext(trackId: trackId) }
   }
 
-  func onSeek(callback: @escaping (Double, Double) -> Void) throws {
-    NitroPlayerLogger.log("HybridTrackPlayer", "onSeek callback registered")
-    core.addOnSeekListener(owner: self, callback)
+  func playNext(trackId: String) throws -> Promise<Void> {
+    Promise.async { try await self.core.playNext(trackId: trackId) }
   }
 
-  func onPlaybackProgressChange(callback: @escaping (Double, Double, Bool?) -> Void) throws {
-    NitroPlayerLogger.log("HybridTrackPlayer", "onPlaybackProgressChange callback registered")
-    core.addOnPlaybackProgressChangeListener(owner: self, callback)
+  func removeFromPlayNext(trackId: String) throws -> Promise<Bool> {
+    Promise.async { await self.core.removeFromPlayNext(trackId: trackId) }
   }
 
-  // MARK: - Android Auto (iOS No-op)
+  func removeFromUpNext(trackId: String) throws -> Promise<Bool> {
+    Promise.async { await self.core.removeFromUpNext(trackId: trackId) }
+  }
 
-  /// iOS doesn't support Android Auto, so this is a no-op
-  /// - Parameter callback: Callback that will never be invoked
-  func onAndroidAutoConnectionChange(callback: @escaping (Bool) -> Void) throws {
-    // iOS doesn't have Android Auto, so this is a no-op
+  func clearPlayNext() throws -> Promise<Void> {
+    Promise.async { await self.core.clearPlayNext() }
   }
 
-  /// iOS doesn't support Android Auto, always returns false
-  /// - Returns: Always returns false on iOS
-  func isAndroidAutoConnected() throws -> Bool {
-    return false
+  func clearUpNext() throws -> Promise<Void> {
+    Promise.async { await self.core.clearUpNext() }
   }
 
-  func skipToIndex(index: Double) throws -> Promise<Bool> {
-    return Promise.async {
-      return self.core.skipToIndex(index: Int(index))
-    }
+  func reorderTemporaryTrack(trackId: String, newIndex: Double) throws -> Promise<Bool> {
+    Promise.async { await self.core.reorderTemporaryTrack(trackId: trackId, newIndex: Int(newIndex)) }
   }
 
-  // MARK: - Volume Control
+  func getPlayNextQueue() throws -> Promise<[TrackItem]> {
+    Promise.async { await self.core.getPlayNextQueue() }
+  }
 
-  func setVolume(volume: Double) throws -> Bool {
-    return core.setVolume(volume: volume)
+  func getUpNextQueue() throws -> Promise<[TrackItem]> {
+    Promise.async { await self.core.getUpNextQueue() }
   }
 
-  // MARK: - Lazy URL Loading
+  // MARK: - Android Auto (iOS no-op)
 
-  func updateTracks(tracks: [TrackItem]) throws -> Promise<Void> {
-    return Promise.async {
-      self.core.updateTracks(tracks: tracks)
-    }
+  func onAndroidAutoConnectionChange(callback: @escaping (Bool) -> Void) throws {
+    // No-op on iOS
   }
 
-  func getTracksById(trackIds: [String]) throws -> Promise<[TrackItem]> {
-    return Promise.async {
-      return self.core.getTracksById(trackIds: trackIds)
-    }
+  func isAndroidAutoConnected() throws -> Bool { false }
+
+  // MARK: - Event listeners (v2 — store IDs for cleanup)
+
+  func onChangeTrack(callback: @escaping (_ track: TrackItem, _ reason: Reason?) -> Void) throws {
+    let id = core.addOnChangeTrackListener(callback)
+    listenerIds.append(("onChangeTrack", id))
   }
 
-  func getTracksNeedingUrls() throws -> Promise<[TrackItem]> {
-    return Promise.async {
-      return self.core.getTracksNeedingUrls()
-    }
+  func onPlaybackStateChange(callback: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) throws {
+    let id = core.addOnPlaybackStateChangeListener(callback)
+    listenerIds.append(("onPlaybackStateChange", id))
   }
 
-  func getNextTracks(count: Double) throws -> Promise<[TrackItem]> {
-    return Promise.async {
-      return self.core.getNextTracks(count: Int(count))
-    }
+  func onSeek(callback: @escaping (_ position: Double, _ totalDuration: Double) -> Void) throws {
+    let id = core.addOnSeekListener(callback)
+    listenerIds.append(("onSeek", id))
   }
 
-  func getCurrentTrackIndex() throws -> Promise<Double> {
-    return Promise.async {
-      return Double(self.core.getCurrentTrackIndex())
-    }
+  func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws {
+    let id = core.addOnProgressListener(callback)
+    listenerIds.append(("onPlaybackProgressChange", id))
   }
 
-  func onTracksNeedUpdate(callback: @escaping ([TrackItem], Double) -> Void) throws {
-    core.addOnTracksNeedUpdateListener { tracks, lookahead in
+  func onTracksNeedUpdate(callback: @escaping (_ tracks: [TrackItem], _ lookahead: Double) -> Void) throws {
+    let id = core.addOnTracksNeedUpdateListener { tracks, lookahead in
       callback(tracks, Double(lookahead))
     }
+    listenerIds.append(("onTracksNeedUpdate", id))
   }
-  
-  func setPlaybackSpeed(speed: Double) throws -> Promise<Void> {
-    Promise.async{
-      self.core.setPlaybackSpeed(speed)
-    }
-    
+
+  func onTemporaryQueueChange(callback: @escaping (_ playNextQueue: [TrackItem], _ upNextQueue: [TrackItem]) -> Void) throws {
+    let id = core.addOnTemporaryQueueChangeListener(callback)
+    listenerIds.append(("onTemporaryQueueChange", id))
   }
-  
-  func getPlaybackSpeed() throws -> Promise<Double> {
-    return Promise.async{
-      return self.core.getPlaybackSpeed()
+
+  // MARK: - Cleanup
+
+  deinit {
+    for (type, id) in listenerIds {
+      switch type {
+      case "onChangeTrack":           _ = core.removeOnChangeTrackListener(id: id)
+      case "onPlaybackStateChange":   _ = core.removeOnPlaybackStateChangeListener(id: id)
+      case "onSeek":                  _ = core.removeOnSeekListener(id: id)
+      case "onPlaybackProgressChange":_ = core.removeOnProgressListener(id: id)
+      case "onTracksNeedUpdate":      _ = core.removeOnTracksNeedUpdateListener(id: id)
+      case "onTemporaryQueueChange":  _ = core.removeOnTemporaryQueueChangeListener(id: id)
+      default: break
+      }
     }
-    
   }
 }

package/ios/core/ListenerRegistry.swift

@@ -0,0 +1,60 @@
+//
+//  ListenerRegistry.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 25/03/26.
+//
+
+import Foundation
+
+final class ListenerRegistry<T> {
+  private struct Entry {
+    let id: Int64
+    let callback: T
+  }
+
+  private let queue = DispatchQueue(label: "com.nitroplayer.registry")
+  private var entries: [Entry] = []
+  private var nextId: Int64 = 0
+
+  /// Register a callback and return its stable ID for later removal.
+  @discardableResult
+  func add(_ callback: T) -> Int64 {
+    var id: Int64 = 0
+    queue.sync {
+      nextId += 1
+      id = nextId
+      entries.append(Entry(id: id, callback: callback))
+    }
+    return id
+  }
+
+  /// Remove the callback with the given ID. Returns true if found.
+  @discardableResult
+  func remove(id: Int64) -> Bool {
+    var found = false
+    queue.sync {
+      if let idx = entries.firstIndex(where: { $0.id == id }) {
+        entries.remove(at: idx)
+        found = true
+      }
+    }
+    return found
+  }
+
+  /// Remove all registered callbacks.
+  func clear() {
+    queue.sync { entries.removeAll() }
+  }
+
+  /// Invoke action for every registered callback (snapshot iteration — safe under mutation).
+  func forEach(_ action: (T) -> Void) {
+    let snap = queue.sync { entries.map(\.callback) }
+    snap.forEach(action)
+  }
+
+  /// True when no callbacks are registered.
+  var isEmpty: Bool {
+    queue.sync { entries.isEmpty }
+  }
+}