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

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

@@ -22,12 +22,12 @@ class EqualizerCore {
   private(set) var isEqualizerEnabled: Bool = false
   private var currentPresetName: String?
 
-  // Standard 5-band frequencies: 60Hz, 230Hz, 910Hz, 3.6kHz, 14kHz
-  let frequencies: [Float] = [60, 230, 910, 3600, 14000]
-  private let frequencyLabels = ["60 Hz", "230 Hz", "910 Hz", "3.6 kHz", "14 kHz"]
+  // Standard 10-band frequencies: 31Hz, 63Hz, 125Hz, 250Hz, 500Hz, 1kHz, 2kHz, 4kHz, 8kHz, 16kHz
+  let frequencies: [Float] = [31, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
+  private let frequencyLabels = ["31 Hz", "63 Hz", "125 Hz", "250 Hz", "500 Hz", "1 kHz", "2 kHz", "4 kHz", "8 kHz", "16 kHz"]
 
   // Current gains storage - internal so TapContext can access
-  private(set) var currentGains: [Double] = [0, 0, 0, 0, 0]
+  private(set) var currentGains: [Double] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   private var cachedBands: [EqualizerBand]?
   private var cachedCustomPresets: [EqualizerPreset]?
 
@@ -40,46 +40,33 @@ 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
 
   private static let builtInPresets: [String: [Double]] = [
-    "Flat": [0, 0, 0, 0, 0],
-    "Bass Boost": [6, 4, 0, 0, 0],
-    "Bass Reducer": [-6, -4, 0, 0, 0],
-    "Treble Boost": [0, 0, 0, 4, 6],
-    "Treble Reducer": [0, 0, 0, -4, -6],
-    "Vocal Boost": [-2, 0, 4, 2, 0],
-    "Rock": [5, 3, -1, 3, 5],
-    "Pop": [-1, 2, 4, 2, -1],
-    "Jazz": [3, 1, -2, 2, 4],
-    "Classical": [4, 2, -1, 2, 3],
-    "Hip Hop": [6, 4, 0, 1, 3],
-    "Electronic": [5, 3, 0, 2, 5],
-    "Acoustic": [4, 2, 1, 3, 3],
-    "R&B": [3, 6, 2, -1, 2],
-    "Loudness": [6, 3, -1, 3, 6],
+    "Flat":               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "Rock":               [4.8, 2.88, -3.36, -4.8, -1.92, 2.4, 5.28, 6.72, 6.72, 6.72],
+    "Pop":                [0.96, 2.88, 4.32, 4.8, 3.36, 0.0, -1.44, -1.44, 0.96, 0.96],
+    "Classical":          [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.32, -4.32, -4.32, -5.76],
+    "Dance":              [5.76, 4.32, 1.44, 0.0, 0.0, -3.36, -4.32, -4.32, 0.0, 0.0],
+    "Techno":             [4.8, 3.36, 0.0, -3.36, -2.88, 0.0, 4.8, 5.76, 5.76, 5.28],
+    "Club":               [0.0, 0.0, 4.8, 3.36, 3.36, 3.36, 1.92, 0.0, 0.0, 0.0],
+    "Live":               [-2.88, 0.0, 2.4, 3.36, 3.36, 3.36, 2.4, 1.44, 1.44, 1.44],
+    "Reggae":             [0.0, 0.0, 0.0, -3.36, 0.0, 3.84, 3.84, 0.0, 0.0, 0.0],
+    "Full Bass":          [4.8, 5.76, 5.76, 3.36, 0.96, -2.4, -4.8, -6.24, -6.72, -6.72],
+    "Full Treble":        [-5.76, -5.76, -5.76, -2.4, 1.44, 6.72, 9.6, 9.6, 9.6, 10.08],
+    "Full Bass & Treble": [4.32, 3.36, 0.0, -4.32, -2.88, 0.96, 4.8, 6.72, 7.2, 7.2],
+    "Large Hall":         [6.24, 6.24, 3.36, 3.36, 0.0, -2.88, -2.88, -2.88, 0.0, 0.0],
+    "Party":              [4.32, 4.32, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.32, 4.32],
+    "Ska":                [-1.44, -2.88, -2.4, 0.0, 2.4, 3.36, 5.28, 5.76, 6.72, 5.76],
+    "Soft":               [2.88, 0.96, 0.0, -1.44, 0.0, 2.4, 4.8, 5.76, 6.72, 7.2],
+    "Soft Rock":          [2.4, 2.4, 1.44, 0.0, -2.4, -3.36, -1.92, 0.0, 1.44, 5.28],
+    "Headphones":         [2.88, 6.72, 3.36, -1.92, -1.44, 0.96, 2.88, 5.76, 7.68, 8.64],
+    "Laptop Speakers":    [2.88, 6.72, 3.36, -1.92, -1.44, 0.96, 2.88, 5.76, 7.68, 8.64],
   ]
 
   // MARK: - Initialization
@@ -206,7 +193,7 @@ class EqualizerCore {
 
   func getBands() -> [EqualizerBand] {
     if let cached = cachedBands { return cached }
-    let bands = (0..<5).map { i in
+    let bands = (0..<10).map { i in
       EqualizerBand(
         index: Double(i),
         centerFrequency: Double(frequencies[i]),
@@ -219,7 +206,7 @@ class EqualizerCore {
   }
 
   func setBandGain(bandIndex: Int, gainDb: Double) -> Bool {
-    guard bandIndex >= 0 && bandIndex < 5 else { return false }
+    guard bandIndex >= 0 && bandIndex < 10 else { return false }
 
     let clampedGain = max(-12.0, min(12.0, gainDb))
     currentGains[bandIndex] = clampedGain
@@ -237,9 +224,9 @@ class EqualizerCore {
   }
 
   func setAllBandGains(_ gains: [Double]) -> Bool {
-    guard gains.count == 5 else { return false }
+    guard gains.count == 10 else { return false }
 
-    for i in 0..<5 {
+    for i in 0..<10 {
       currentGains[i] = max(-12.0, min(12.0, gains[i]))
     }
     cachedBands = nil
@@ -390,7 +377,7 @@ class EqualizerCore {
   }
 
   func reset() {
-    _ = setAllBandGains([0, 0, 0, 0, 0])
+    _ = setAllBandGains([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     currentPresetName = "Flat"
     notifyPresetChange("Flat")
     saveCurrentPreset("Flat")
@@ -417,10 +404,11 @@ class EqualizerCore {
 
     if let data = UserDefaults.standard.data(forKey: bandGainsKey),
       let gains = try? JSONDecoder().decode([Double].self, from: data),
-      gains.count == 5
+      gains.count == 10
     {
       currentGains = gains
     }
+    // else: migration from 5-band or fresh install — start at flat (currentGains already zeroed)
 
     currentPresetName = UserDefaults.standard.string(forKey: currentPresetKey)
     isEqualizerEnabled = enabled
@@ -428,88 +416,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) }
   }
 }
 
@@ -521,28 +461,28 @@ private class TapContext {
   var sampleRate: Float = 44100.0
   var channelCount: Int = 2
 
-  // Biquad filter states for 5 bands
+  // Biquad filter states for 10 bands
   // Each band needs 4 delay elements per channel (x[n-1], x[n-2], y[n-1], y[n-2])
   var filterStates: [[Float]] = []
 
-  // Biquad coefficients for 5 bands
+  // Biquad coefficients for 10 bands
   // Each band: [b0, b1, b2, a1, a2] (normalized, a0 = 1)
   var filterCoeffs: [[Double]] = []
 
   init(eqCore: EqualizerCore) {
     self.eqCore = eqCore
-    // Initialize 5 bands with flat coefficients
-    for _ in 0..<5 {
+    // Initialize 10 bands with flat coefficients
+    for _ in 0..<10 {
       filterCoeffs.append([1.0, 0.0, 0.0, 0.0, 0.0])  // Flat/bypass
     }
   }
 
   func updateCoefficients() {
     guard let eqCore = eqCore else { return }
-    let frequencies: [Float] = [60, 230, 910, 3600, 14000]
+    let frequencies: [Float] = [31, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
     let gains = eqCore.currentGains
 
-    for i in 0..<5 {
+    for i in 0..<10 {
       filterCoeffs[i] = calculatePeakingEQCoefficients(
         frequency: Double(frequencies[i]),
         gain: gains[i],
@@ -582,7 +522,7 @@ private class TapContext {
 
   func resetFilterStates() {
     filterStates = []
-    for _ in 0..<5 {
+    for _ in 0..<10 {
       // 4 delay elements per channel (2 for input history, 2 for output history)
       filterStates.append(Array(repeating: Float(0.0), count: channelCount * 4))
     }
@@ -678,8 +618,8 @@ private func tapProcessCallback(
     let frameCount = Int(numberFramesOut.pointee)
     let samples = data.assumingMemoryBound(to: Float.self)
 
-    // Apply all 5 EQ bands in series
-    for bandIndex in 0..<5 {
+    // Apply all 10 EQ bands in series
+    for bandIndex in 0..<10 {
       let coeffs: [Double] = context.filterCoeffs[bandIndex]
 
       // Skip if essentially flat

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
   }