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

package/ios/core/TrackPlayerUrlLoader.swift

@@ -0,0 +1,169 @@
+//
+//  TrackPlayerUrlLoader.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 25/03/26.
+//
+
+import AVFoundation
+import Foundation
+
+extension TrackPlayerCore {
+
+  func updateTracks(tracks: [TrackItem]) async {
+    await withPlayerQueueNoThrow { self.updateTracksInternal(tracks: tracks) }
+  }
+
+  func getTracksById(trackIds: [String]) async -> [TrackItem] {
+    await withPlayerQueueNoThrow { self.playlistManager.getTracksById(trackIds: trackIds) }
+  }
+
+  func getTracksNeedingUrls() async -> [TrackItem] {
+    await withPlayerQueueNoThrow { self.getTracksNeedingUrlsInternal() }
+  }
+
+  func getNextTracks(count: Int) async -> [TrackItem] {
+    await withPlayerQueueNoThrow { self.getNextTracksInternal(count: count) }
+  }
+
+  // MARK: - Internal
+
+  func updateTracksInternal(tracks: [TrackItem]) {
+    NitroPlayerLogger.log("TrackPlayerCore", "🔄 updateTracks: \(tracks.count) updates")
+
+    let currentTrack = self.getCurrentTrack()
+    let currentTrackId = currentTrack?.id
+    // A track is only "empty" if it has no remote URL AND is not downloaded.
+    let currentTrackIsEmpty = currentTrack.map {
+      $0.url.isEmpty && !DownloadManagerCore.shared.isTrackDownloaded(trackId: $0.id)
+    } ?? false
+
+    let safeTracks = tracks.filter { track in
+      switch true {
+      case track.id == currentTrackId && !currentTrackIsEmpty:
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "⚠️ Skipping update for currently playing track: \(track.id) (preserves gapless)")
+        return false
+      case track.id == currentTrackId && currentTrackIsEmpty:
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "🔄 Updating current track with no URL: \(track.id)")
+        return !track.url.isEmpty
+      case track.url.isEmpty:
+        NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Skipping track with empty URL: \(track.id)")
+        return false
+      default:
+        return true
+      }
+    }
+
+    guard !safeTracks.isEmpty else {
+      NitroPlayerLogger.log("TrackPlayerCore", "✅ No valid updates to apply")
+      return
+    }
+
+    // Invalidate preloaded assets for tracks with updated data
+    let updatedTrackIds = Set(safeTracks.map { $0.id })
+    for trackId in updatedTrackIds {
+      if self.preloadedAssets[trackId] != nil {
+        NitroPlayerLogger.log("TrackPlayerCore", "🗑️ Invalidating preloaded asset for track: \(trackId)")
+        self.preloadedAssets.removeValue(forKey: trackId)
+      }
+    }
+
+    // Update in PlaylistManager
+    let affectedPlaylists = self.playlistManager.updateTracks(tracks: safeTracks)
+
+    // If the current track had no URL and now has one, replace the current AVPlayerItem
+    if let update = currentTrack, currentTrackIsEmpty, !update.url.isEmpty {
+      NitroPlayerLogger.log("TrackPlayerCore",
+        "🔄 Replacing current AVPlayerItem for track with resolved URL: \(update.id)")
+      if let newItem = self.createGaplessPlayerItem(for: update, isPreload: false) {
+        self.player?.replaceCurrentItem(with: newItem)
+      }
+    }
+
+    // Rebuild queue if current playlist was affected
+    if let currentId = self.currentPlaylistId,
+      let updateCount = affectedPlaylists[currentId]
+    {
+      NitroPlayerLogger.log("TrackPlayerCore",
+        "🔄 Rebuilding queue - \(updateCount) tracks updated in current playlist")
+
+      // Sync currentTracks from the freshly-updated PlaylistManager
+      if let updatedPlaylist = self.playlistManager.getPlaylist(playlistId: currentId) {
+        self.currentTracks = updatedPlaylist.tracks
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "📥 Synced currentTracks from PlaylistManager (\(self.currentTracks.count) tracks)")
+      }
+
+      if self.player?.currentItem == nil, let player = self.player {
+        // No AVPlayerItem exists yet — lazy-load mode: URLs were empty when the queue first loaded.
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "🔄 No current item — full queue rebuild from currentTrackIndex \(self.currentTrackIndex)")
+        player.removeAllItems()
+        var lastItem: AVPlayerItem? = nil
+        for (offset, track) in self.currentTracks[max(0, self.currentTrackIndex)...].enumerated() {
+          let isPreload = offset < Constants.gaplessPreloadCount
+          if let newItem = self.createGaplessPlayerItem(for: track, isPreload: isPreload) {
+            player.insert(newItem, after: lastItem)
+            lastItem = newItem
+          }
+        }
+        player.play()
+        self.preloadUpcomingTracks(from: self.currentTrackIndex + 1)
+      } else {
+        // A current AVPlayerItem already exists — preserve it and only rebuild upcoming items.
+        self.rebuildAVQueueFromCurrentPosition(changedTrackIds: updatedTrackIds)
+        self.preloadUpcomingTracks(from: self.currentTrackIndex + 1)
+      }
+
+      NitroPlayerLogger.log("TrackPlayerCore", "✅ Queue rebuilt, gapless playback preserved")
+    }
+
+    NitroPlayerLogger.log("TrackPlayerCore",
+      "✅ Track updates complete - \(affectedPlaylists.count) playlists affected")
+  }
+
+  func getTracksNeedingUrlsInternal() -> [TrackItem] {
+    guard let currentId = currentPlaylistId,
+      let playlist = playlistManager.getPlaylist(playlistId: currentId)
+    else { return [] }
+
+    // Only return tracks that truly can't play: empty remote URL AND not downloaded locally.
+    return playlist.tracks.filter {
+      $0.url.isEmpty && !DownloadManagerCore.shared.isTrackDownloaded(trackId: $0.id)
+    }
+  }
+
+  func getNextTracksInternal(count: Int) -> [TrackItem] {
+    let actualQueue = getActualQueueInternal()
+    guard !actualQueue.isEmpty else { return [] }
+
+    guard let currentTrack = getCurrentTrack(),
+      let currentIndex = actualQueue.firstIndex(where: { $0.id == currentTrack.id })
+    else { return [] }
+
+    let startIndex = currentIndex + 1
+    let endIndex = min(startIndex + count, actualQueue.count)
+    return startIndex < actualQueue.count ? Array(actualQueue[startIndex..<endIndex]) : []
+  }
+
+  func checkUpcomingTracksForUrls(lookahead: Int = 5) {
+    let upcomingTracks = getNextTracksInternal(count: lookahead)
+
+    let currentTrack = getCurrentTrack()
+    let currentNeedsUrl = currentTrack.map {
+      $0.url.isEmpty && !DownloadManagerCore.shared.isTrackDownloaded(trackId: $0.id)
+    } ?? false
+    let candidateTracks = currentNeedsUrl ? [currentTrack!] + upcomingTracks : upcomingTracks
+
+    let tracksNeedingUrls = candidateTracks.filter {
+      $0.url.isEmpty && !DownloadManagerCore.shared.isTrackDownloaded(trackId: $0.id)
+    }
+
+    if !tracksNeedingUrls.isEmpty {
+      NitroPlayerLogger.log("TrackPlayerCore", "⚠️ \(tracksNeedingUrls.count) upcoming tracks need URLs")
+      notifyTracksNeedUpdate(tracks: tracksNeedingUrls, lookahead: lookahead)
+    }
+  }
+}

package/ios/equalizer/EqualizerCore.swift

@@ -40,27 +40,10 @@ class EqualizerCore {
   private let currentPresetKey = "eq_current_preset"
   private let customPresetsKey = "eq_custom_presets"
 
-  // MARK: - Weak Callback Wrapper
-
-  private class WeakCallbackBox<T> {
-    private(set) weak var owner: AnyObject?
-    let callback: T
-
-    init(owner: AnyObject, callback: T) {
-      self.owner = owner
-      self.callback = callback
-    }
-
-    var isAlive: Bool { owner != nil }
-  }
-
-  // Event callbacks
-  private var onEnabledChangeListeners: [WeakCallbackBox<(Bool) -> Void>] = []
-  private var onBandChangeListeners: [WeakCallbackBox<([EqualizerBand]) -> Void>] = []
-  private var onPresetChangeListeners: [WeakCallbackBox<(Variant_NullType_String?) -> Void>] = []
-
-  private let listenersQueue = DispatchQueue(
-    label: "com.equalizer.listeners", attributes: .concurrent)
+  // Event listeners (v2 — ListenerRegistry with stable IDs)
+  private let onEnabledChangeListeners = ListenerRegistry<(Bool) -> Void>()
+  private let onBandChangeListeners = ListenerRegistry<([EqualizerBand]) -> Void>()
+  private let onPresetChangeListeners = ListenerRegistry<(Variant_NullType_String?) -> Void>()
 
   // MARK: - Built-in Presets
 
@@ -428,88 +411,40 @@ class EqualizerCore {
     NitroPlayerLogger.log("EqualizerCore", "✅ Restored settings - enabled: \(enabled), gains: \(currentGains)")
   }
 
-  // MARK: - Callback Management
+  // MARK: - Listener Management (v2 — stable IDs)
 
-  func addOnEnabledChangeListener(owner: AnyObject, _ callback: @escaping (Bool) -> Void) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      let box = WeakCallbackBox(owner: owner, callback: callback)
-      self?.onEnabledChangeListeners.append(box)
-    }
+  @discardableResult func addOnEnabledChangeListener(_ callback: @escaping (Bool) -> Void) -> Int64 {
+    onEnabledChangeListeners.add(callback)
+  }
+  @discardableResult func removeOnEnabledChangeListener(id: Int64) -> Bool {
+    onEnabledChangeListeners.remove(id: id)
   }
 
-  func addOnBandChangeListener(owner: AnyObject, _ callback: @escaping ([EqualizerBand]) -> Void) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      let box = WeakCallbackBox(owner: owner, callback: callback)
-      self?.onBandChangeListeners.append(box)
-    }
+  @discardableResult func addOnBandChangeListener(_ callback: @escaping ([EqualizerBand]) -> Void) -> Int64 {
+    onBandChangeListeners.add(callback)
+  }
+  @discardableResult func removeOnBandChangeListener(id: Int64) -> Bool {
+    onBandChangeListeners.remove(id: id)
   }
 
-  func addOnPresetChangeListener(
-    owner: AnyObject, _ callback: @escaping (Variant_NullType_String?) -> Void
-  ) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      let box = WeakCallbackBox(owner: owner, callback: callback)
-      self?.onPresetChangeListeners.append(box)
-    }
+  @discardableResult func addOnPresetChangeListener(_ callback: @escaping (Variant_NullType_String?) -> Void) -> Int64 {
+    onPresetChangeListeners.add(callback)
+  }
+  @discardableResult func removeOnPresetChangeListener(id: Int64) -> Bool {
+    onPresetChangeListeners.remove(id: id)
   }
 
   private func notifyEnabledChange(_ enabled: Bool) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      guard let self = self else { return }
-      self.onEnabledChangeListeners.removeAll { !$0.isAlive }
-
-      let callbacks = self.onEnabledChangeListeners.compactMap {
-        $0.isAlive ? $0.callback : nil
-      }
-
-      if !callbacks.isEmpty {
-        DispatchQueue.main.async {
-          for callback in callbacks {
-            callback(enabled)
-          }
-        }
-      }
-    }
+    onEnabledChangeListeners.forEach { $0(enabled) }
   }
 
   private func notifyBandChange(_ bands: [EqualizerBand]) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      guard let self = self else { return }
-      self.onBandChangeListeners.removeAll { !$0.isAlive }
-
-      let callbacks = self.onBandChangeListeners.compactMap {
-        $0.isAlive ? $0.callback : nil
-      }
-
-      if !callbacks.isEmpty {
-        DispatchQueue.main.async {
-          for callback in callbacks {
-            callback(bands)
-          }
-        }
-      }
-    }
+    onBandChangeListeners.forEach { $0(bands) }
   }
 
   private func notifyPresetChange(_ presetName: String?) {
-    listenersQueue.async(flags: .barrier) { [weak self] in
-      guard let self = self else { return }
-      self.onPresetChangeListeners.removeAll { !$0.isAlive }
-
-      let callbacks = self.onPresetChangeListeners.compactMap {
-        $0.isAlive ? $0.callback : nil
-      }
-
-      if !callbacks.isEmpty {
-        let variant: Variant_NullType_String? = presetName.map { .second($0) }
-
-        DispatchQueue.main.async {
-          for callback in callbacks {
-            callback(variant)
-          }
-        }
-      }
-    }
+    let variant: Variant_NullType_String? = presetName.map { .second($0) }
+    onPresetChangeListeners.forEach { $0(variant) }
   }
 }
 

package/ios/media/MediaSessionManager.swift

@@ -20,7 +20,7 @@ class MediaSessionManager {
 
   // MARK: - Properties
 
-  private var trackPlayerCore: TrackPlayerCore?
+  private weak var trackPlayerCore: TrackPlayerCore?
   private let artworkCache = NSCache<NSString, UIImage>()
 
   private var showInNotification: Bool = true
@@ -28,6 +28,11 @@ class MediaSessionManager {
   // Tracks the artwork URL currently shown so we can discard stale async loads
   private var lastArtworkUrl: String?
 
+  // Cached values received from playerQueue — main-thread-only reads (no sync needed)
+  private var cachedTrack: TrackItem?
+  private var cachedState: PlayerState?
+  private var cachedQueue: [TrackItem] = []
+
   init() {
     setupRemoteCommandCenter()
   }
@@ -47,27 +52,27 @@ class MediaSessionManager {
     refresh()
   }
 
-  // MARK: - Single refresh entry point
+  // MARK: - Entry point from playerQueue (called via DispatchQueue.main.async)
   //
-  // All public callbacks route here. Always dispatches to main thread so
-  // MPNowPlayingInfoCenter and MPRemoteCommandCenter are only touched from main.
+  // Receives pre-computed values captured on playerQueue — no player access here.
+
+  func updateFromPlayerQueue(track: TrackItem, state: PlayerState, queue: [TrackItem]) {
+    cachedTrack = track
+    cachedState = state
+    cachedQueue = queue
+    refreshInternal()
+  }
+
+  // MARK: - Refresh using cached values (main thread only)
 
   func refresh() {
     if Thread.isMainThread {
       refreshInternal()
     } else {
-      DispatchQueue.main.async { [weak self] in
-        self?.refreshInternal()
-      }
+      DispatchQueue.main.async { [weak self] in self?.refreshInternal() }
     }
   }
 
-  // Convenience aliases used by TrackPlayerCore call sites
-  func updateNowPlayingInfo() { refresh() }
-  func onTrackChanged() { refresh() }
-  func onPlaybackStateChanged() { refresh() }
-  func onQueueChanged() { refresh() }
-
   // MARK: - Core internal update (main thread only)
 
   private func refreshInternal() {
@@ -77,21 +82,13 @@ class MediaSessionManager {
       return
     }
 
-    guard let core = trackPlayerCore,
-      let track = core.getCurrentTrack()
-    else {
+    guard let track = cachedTrack, let state = cachedState else {
       clearNowPlayingInfo()
       disableAllCommands()
       return
     }
 
-    // Fetch snapshot once — both calls are cheap on main thread (no sync overhead)
-    let state = core.getState()
-    let queue = core.getActualQueue()
-
-    // Find the actual position of the current track inside the actual queue.
-    // state.currentIndex is the original-playlist index which is wrong when a
-    // temp (playNext / upNext) track is playing.
+    let queue = cachedQueue
     let positionInQueue = queue.firstIndex(where: { $0.id == track.id }) ?? -1
 
     updateNowPlayingInfoInternal(track: track, state: state, queue: queue, positionInQueue: positionInQueue)
@@ -145,7 +142,6 @@ class MediaSessionManager {
         MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
         loadArtwork(url: artworkUrl) { [weak self] image in
           guard let self = self, let image = image else { return }
-          // Discard if track changed while loading
           guard self.lastArtworkUrl == artworkUrl else { return }
           var updated = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
           updated[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
@@ -168,8 +164,6 @@ class MediaSessionManager {
   private func setupRemoteCommandCenter() {
     let commandCenter = MPRemoteCommandCenter.shared()
 
-    // Clear any previously registered targets before adding fresh ones.
-    // Prevents duplicate handlers if this were ever called more than once.
     commandCenter.playCommand.removeTarget(nil)
     commandCenter.pauseCommand.removeTarget(nil)
     commandCenter.togglePlayPauseCommand.removeTarget(nil)
@@ -183,7 +177,7 @@ class MediaSessionManager {
     commandCenter.playCommand.isEnabled = true
     commandCenter.playCommand.addTarget { [weak self] _ in
       guard let core = self?.trackPlayerCore else { return .commandFailed }
-      core.play()
+      Task { await core.play() }
       return .success
     }
 
@@ -191,7 +185,7 @@ class MediaSessionManager {
     commandCenter.pauseCommand.isEnabled = true
     commandCenter.pauseCommand.addTarget { [weak self] _ in
       guard let core = self?.trackPlayerCore else { return .commandFailed }
-      core.pause()
+      Task { await core.pause() }
       return .success
     }
 
@@ -199,51 +193,45 @@ class MediaSessionManager {
     commandCenter.togglePlayPauseCommand.isEnabled = true
     commandCenter.togglePlayPauseCommand.addTarget { [weak self] _ in
       guard let core = self?.trackPlayerCore else { return .commandFailed }
-      if core.getState().currentState == .playing {
-        core.pause()
-      } else {
-        core.play()
-      }
+      let isPlaying = self?.cachedState?.currentState == .playing
+      Task { if isPlaying { await core.pause() } else { await core.play() } }
       return .success
     }
 
-    // Next track — isEnabled managed dynamically in updateCommandCenterState
+    // Next track
     commandCenter.nextTrackCommand.isEnabled = false
     commandCenter.nextTrackCommand.addTarget { [weak self] _ in
       guard let core = self?.trackPlayerCore else { return .commandFailed }
-      core.skipToNext()
+      Task { await core.skipToNext() }
       return .success
     }
 
-    // Previous track — isEnabled managed dynamically in updateCommandCenterState
+    // Previous track
     commandCenter.previousTrackCommand.isEnabled = false
     commandCenter.previousTrackCommand.addTarget { [weak self] _ in
       guard let core = self?.trackPlayerCore else { return .commandFailed }
-      core.skipToPrevious()
+      Task { await core.skipToPrevious() }
       return .success
     }
 
-    // Disable skip-forward/backward — these replace the scrubber with non-interactive buttons
     commandCenter.seekForwardCommand.isEnabled = false
     commandCenter.seekBackwardCommand.isEnabled = false
 
-    // Scrubber — isEnabled managed dynamically based on known duration
+    // Scrubber
     commandCenter.changePlaybackPositionCommand.isEnabled = false
     commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
-      guard let self = self,
-        let core = self.trackPlayerCore,
+      guard let core = self?.trackPlayerCore,
         let positionEvent = event as? MPChangePlaybackPositionCommandEvent
       else {
         return .commandFailed
       }
-      // Optimistically freeze the scrubber at the tapped position while the async
-      // seek is in flight — updateNowPlayingInfo in the seek completion restores it.
+      // Optimistically freeze the scrubber at the tapped position
       if var info = MPNowPlayingInfoCenter.default().nowPlayingInfo {
         info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = positionEvent.positionTime
         info[MPNowPlayingInfoPropertyPlaybackRate] = 0.0
         MPNowPlayingInfoCenter.default().nowPlayingInfo = info
       }
-      core.seek(position: positionEvent.positionTime)
+      Task { await core.seek(position: positionEvent.positionTime) }
       return .success
     }
   }
@@ -260,13 +248,8 @@ class MediaSessionManager {
     let playerDuration = state.totalDuration
     let hasDuration = playerDuration > 0 && !playerDuration.isNaN && !playerDuration.isInfinite
 
-    // Next: only enabled when there is a track after the current one
     commandCenter.nextTrackCommand.isEnabled = hasCurrentTrack && isNotLast
-
-    // Previous: always enabled when something is playing — either restarts current or goes back
     commandCenter.previousTrackCommand.isEnabled = hasCurrentTrack
-
-    // Scrubber: only enabled when we have a known, finite duration
     commandCenter.changePlaybackPositionCommand.isEnabled = hasCurrentTrack && hasDuration
   }
 

package/ios/playlist/PlaylistManager.swift

@@ -268,9 +268,6 @@ class PlaylistManager {
 
     currentPlaylistId = playlistId
 
-    // Update TrackPlayerCore
-    TrackPlayerCore.shared.loadPlaylist(playlistId: playlistId)
-
     return true
   }
 
@@ -399,9 +396,7 @@ class PlaylistManager {
     let (allPlaylists, currentListeners) = queue.sync {
       (Array(playlists.values), listeners)
     }
-    DispatchQueue.main.async {
-      currentListeners.forEach { $0.1(allPlaylists, operation) }
-    }
+    currentListeners.forEach { $0.1(allPlaylists, operation) }
   }
 
   private func notifyPlaylistChanged(_ playlistId: String, _ operation: QueueOperation?) {
@@ -413,9 +408,7 @@ class PlaylistManager {
 
     guard let (playlist, currentListeners) = result else { return }
 
-    DispatchQueue.main.async {
-      currentListeners.forEach { $0.1(playlist, operation) }
-    }
+    currentListeners.forEach { $0.1(playlist, operation) }
   }
 
   private func scheduleSave() {