react-native-nitro-player 0.5.8 → 0.5.9-alpha.1

package/ios/download/DownloadDatabase.swift

@@ -82,6 +82,12 @@ final class DownloadDatabase {
     }
   }
 
+  private func _isTrackDownloadedUnsafe(trackId: String) -> Bool {
+    guard let record = downloadedTracks[trackId] else { return false }
+    let absolutePath = resolveAbsolutePath(for: record)
+    return FileManager.default.fileExists(atPath: absolutePath)
+  }
+
   func isPlaylistDownloaded(playlistId: String) -> Bool {
     return queue.sync {
       guard let trackIds = playlistTracks[playlistId], !trackIds.isEmpty else { return false }
@@ -93,7 +99,7 @@ final class DownloadDatabase {
 
       // Check if all tracks are downloaded
       for track in playlistModel.tracks {
-        if !isTrackDownloaded(trackId: track.id) {
+        if !_isTrackDownloadedUnsafe(trackId: track.id) {
           return false
         }
       }
@@ -108,7 +114,7 @@ final class DownloadDatabase {
 
       // Check if at least one track is downloaded
       for trackId in trackIds {
-        if isTrackDownloaded(trackId: trackId) {
+        if _isTrackDownloadedUnsafe(trackId: trackId) {
           return true
         }
       }

package/ios/download/DownloadFileManager.swift

@@ -304,8 +304,18 @@ final class DownloadFileManager {
     return bytesFreed
   }
 
+  private static let commonAudioExtensions = ["mp3", "m4a", "aac", "wav", "flac", "ogg", "opus", "mp4"]
+
   func getLocalPath(for trackId: String) -> String? {
-    // Check private directory first
+    // Try common extensions first (fast O(1) path)
+    for ext in Self.commonAudioExtensions {
+      let privatePath = privateDownloadsDirectory.appendingPathComponent("\(trackId).\(ext)").path
+      if fileManager.fileExists(atPath: privatePath) { return privatePath }
+      let publicPath = publicDownloadsDirectory.appendingPathComponent("\(trackId).\(ext)").path
+      if fileManager.fileExists(atPath: publicPath) { return publicPath }
+    }
+
+    // Fallback to directory enumeration for uncommon extensions
     let privateFiles =
       (try? fileManager.contentsOfDirectory(
         at: privateDownloadsDirectory, includingPropertiesForKeys: nil)) ?? []
@@ -315,7 +325,6 @@ final class DownloadFileManager {
       }
     }
 
-    // Check public directory
     let publicFiles =
       (try? fileManager.contentsOfDirectory(
         at: publicDownloadsDirectory, includingPropertiesForKeys: nil)) ?? []

package/ios/download/DownloadManagerCore.swift

@@ -58,6 +58,9 @@ final class DownloadManagerCore: NSObject {
   /// Playlist associations (downloadId -> playlistId)
   private var playlistAssociations: [String: String] = [:]
 
+  /// Cached parsed (downloadId, trackId) tuples per task description to avoid repeated string splitting
+  private var parsedDescriptionCache: [String: (downloadId: String, trackId: String)] = [:]
+
   /// Background completion handler from AppDelegate
   var backgroundCompletionHandler: (() -> Void)?
 
@@ -258,10 +261,50 @@ final class DownloadManagerCore: NSObject {
     }
   }
 
+  private func _pauseDownloadUnsafe(downloadId: String) {
+    guard let task = self.activeTasks[downloadId] else { return }
+    task.cancel(byProducingResumeData: { resumeData in
+      self.taskMetadata[downloadId]?.resumeData = resumeData
+    })
+    self.taskMetadata[downloadId]?.state = .paused
+    if let trackId = self.taskMetadata[downloadId]?.trackId {
+      self.notifyStateChange(downloadId: downloadId, trackId: trackId, state: .paused, error: nil)
+    }
+  }
+
+  private func _resumeDownloadUnsafe(downloadId: String) {
+    guard let metadata = self.taskMetadata[downloadId] else { return }
+    var task: URLSessionDownloadTask
+    if let resumeData = metadata.resumeData {
+      task = self.backgroundSession.downloadTask(withResumeData: resumeData)
+    } else if let track = self.trackMetadata[metadata.trackId],
+              let url = URL(string: track.url) {
+      task = self.backgroundSession.downloadTask(with: url)
+    } else { return }
+    task.taskDescription = "\(downloadId)|\(metadata.trackId)"
+    self.activeTasks[downloadId] = task
+    self.taskMetadata[downloadId]?.state = .downloading
+    self.taskMetadata[downloadId]?.resumeData = nil
+    task.resume()
+    self.notifyStateChange(downloadId: downloadId, trackId: metadata.trackId, state: .downloading, error: nil)
+  }
+
+  private func _cancelDownloadUnsafe(downloadId: String) {
+    guard let task = self.activeTasks[downloadId] else { return }
+    task.cancel()
+    if let trackId = self.taskMetadata[downloadId]?.trackId {
+      self.taskMetadata[downloadId]?.state = .cancelled
+      self.notifyStateChange(downloadId: downloadId, trackId: trackId, state: .cancelled, error: nil)
+      self.cleanupPersistedMetadata(trackId: trackId, downloadId: downloadId)
+    }
+    self.activeTasks.removeValue(forKey: downloadId)
+    self.taskMetadata.removeValue(forKey: downloadId)
+  }
+
   func pauseAllDownloads() {
     queue.async(flags: .barrier) {
       for downloadId in self.activeTasks.keys {
-        self.pauseDownload(downloadId: downloadId)
+        self._pauseDownloadUnsafe(downloadId: downloadId)
       }
     }
   }
@@ -270,7 +313,7 @@ final class DownloadManagerCore: NSObject {
     queue.async(flags: .barrier) {
       for downloadId in self.taskMetadata.keys where self.taskMetadata[downloadId]?.state == .paused
       {
-        self.resumeDownload(downloadId: downloadId)
+        self._resumeDownloadUnsafe(downloadId: downloadId)
       }
     }
   }
@@ -278,7 +321,7 @@ final class DownloadManagerCore: NSObject {
   func cancelAllDownloads() {
     queue.async(flags: .barrier) {
       for downloadId in self.activeTasks.keys {
-        self.cancelDownload(downloadId: downloadId)
+        self._cancelDownloadUnsafe(downloadId: downloadId)
       }
     }
   }
@@ -302,15 +345,24 @@ final class DownloadManagerCore: NSObject {
 
   func getQueueStatus() -> DownloadQueueStatus {
     return queue.sync {
-      let metadata = Array(taskMetadata.values)
+      var pendingCount = 0
+      var activeCount = 0
+      var failedCount = 0
+      var totalBytes = 0.0
+      var downloadedBytes = 0.0
+
+      for m in taskMetadata.values {
+        switch m.state {
+        case .pending: pendingCount += 1
+        case .downloading: activeCount += 1
+        case .failed: failedCount += 1
+        default: break
+        }
+        totalBytes += m.totalBytes ?? 0
+        downloadedBytes += m.bytesDownloaded
+      }
 
-      let pendingCount = metadata.filter { $0.state == .pending }.count
-      let activeCount = metadata.filter { $0.state == .downloading }.count
       let completedCount = DownloadDatabase.shared.getAllDownloadedTracks().count
-      let failedCount = metadata.filter { $0.state == .failed }.count
-
-      let totalBytes = metadata.reduce(0.0) { $0 + ($1.totalBytes ?? 0) }
-      let downloadedBytes = metadata.reduce(0.0) { $0 + $1.bytesDownloaded }
 
       return DownloadQueueStatus(
         pendingCount: Double(pendingCount),
@@ -601,6 +653,17 @@ final class DownloadManagerCore: NSObject {
     savePersistedMetadata()
   }
 
+  private func parseTaskDescription(_ description: String) -> (downloadId: String, trackId: String)? {
+    if let cached = parsedDescriptionCache[description] {
+      return cached
+    }
+    let parts = description.split(separator: "|")
+    guard parts.count == 2 else { return nil }
+    let result = (downloadId: String(parts[0]), trackId: String(parts[1]))
+    parsedDescriptionCache[description] = result
+    return result
+  }
+
   // MARK: - TrackItem Serialization
 
   private func trackItemToRecord(_ track: TrackItem) -> TrackItemRecord {
@@ -725,14 +788,13 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
       NitroPlayerLogger.log("DownloadManagerCore", "❌ No task description")
       return
     }
-    let parts = description.split(separator: "|")
-    guard parts.count == 2 else {
+    guard let parsed = parseTaskDescription(description) else {
       NitroPlayerLogger.log("DownloadManagerCore", "❌ Invalid task description format: \(description)")
       return
     }
 
-    let downloadId = String(parts[0])
-    let trackId = String(parts[1])
+    let downloadId = parsed.downloadId
+    let trackId = parsed.trackId
 
       NitroPlayerLogger.log("DownloadManagerCore", "🎯 Processing completion for downloadId=\(downloadId), trackId=\(trackId)")
 
@@ -834,12 +896,11 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
     _ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64,
     totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64
   ) {
-    guard let description = downloadTask.taskDescription else { return }
-    let parts = description.split(separator: "|")
-    guard parts.count == 2 else { return }
+    guard let description = downloadTask.taskDescription,
+          let parsed = parseTaskDescription(description) else { return }
 
-    let downloadId = String(parts[0])
-    let trackId = String(parts[1])
+    let downloadId = parsed.downloadId
+    let trackId = parsed.trackId
 
     queue.async(flags: .barrier) {
       self.taskMetadata[downloadId]?.bytesDownloaded = Double(totalBytesWritten)
@@ -862,14 +923,12 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
 
   func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
     guard let downloadTask = task as? URLSessionDownloadTask,
-      let description = downloadTask.taskDescription
+      let description = downloadTask.taskDescription,
+      let parsed = parseTaskDescription(description)
     else { return }
 
-    let parts = description.split(separator: "|")
-    guard parts.count == 2 else { return }
-
-    let downloadId = String(parts[0])
-    let trackId = String(parts[1])
+    let downloadId = parsed.downloadId
+    let trackId = parsed.trackId
 
     guard let error = error else { return }  // Success case handled in didFinishDownloadingTo
 

package/ios/equalizer/EqualizerCore.swift

@@ -28,6 +28,8 @@ class EqualizerCore {
 
   // Current gains storage - internal so TapContext can access
   private(set) var currentGains: [Double] = [0, 0, 0, 0, 0]
+  private var cachedBands: [EqualizerBand]?
+  private var cachedCustomPresets: [EqualizerPreset]?
 
   // Dirty flag: set when gains change so TapContext only recalculates when needed
   var gainsDirty: Bool = true
@@ -89,11 +91,35 @@ class EqualizerCore {
 
   // MARK: - Audio Mix Creation for AVPlayerItem
 
-  /// Applies an AVAudioMix with equalizer processing for the given AVPlayerItem asynchronously
+  /// Applies an AVAudioMix with equalizer processing for the given AVPlayerItem.
+  /// No-ops when the equalizer is disabled so that AVPlayerItems remain tap-free,
+  /// keeping the audio pipeline configuration identical across all queued items
+  /// and allowing AVQueuePlayer to perform seamless gapless transitions.
+  ///
+  /// When the asset's "tracks" key is already loaded (e.g. from preloading),
+  /// the mix is applied **synchronously** so the item enters AVQueuePlayer with
+  /// the correct tap from the start — avoiding a pipeline reconfiguration that
+  /// causes an audible gap at the transition.
   func applyAudioMix(to playerItem: AVPlayerItem) {
+    guard isEqualizerEnabled else {
+      // Ensure no stale tap remains from a previous enable/disable cycle
+      if playerItem.audioMix != nil {
+        playerItem.audioMix = nil
+      }
+      return
+    }
+
     let asset = playerItem.asset
 
-    // Load "tracks" key asynchronously to avoid blocking
+    // Fast path: "tracks" already loaded (from preloadUpcomingTracks) — apply synchronously.
+    var keyError: NSError?
+    if asset.statusOfValue(forKey: "tracks", error: &keyError) == .loaded {
+      buildAndApplyAudioMix(to: playerItem, asset: asset)
+      NitroPlayerLogger.log("EqualizerCore", "✅ Applied audio mix with EQ tap to player item (sync — preloaded)")
+      return
+    }
+
+    // Slow path: load "tracks" key asynchronously to avoid blocking
     asset.loadValuesAsynchronously(forKeys: ["tracks"]) { [weak self] in
       guard let self = self else { return }
 
@@ -111,50 +137,55 @@ class EqualizerCore {
         return
       }
 
-      guard let audioTrack = asset.tracks(withMediaType: .audio).first else {
-        NitroPlayerLogger.log("EqualizerCore", "⚠️ No audio track found in asset")
-        return
-      }
+      // Apply directly — audioMix is thread-safe and applying on the
+      // loadValues completion queue avoids a main-thread hop that would
+      // delay tap attachment and risk a pipeline mismatch at pre-roll time.
+      self.buildAndApplyAudioMix(to: playerItem, asset: asset)
+      NitroPlayerLogger.log("EqualizerCore", "✅ Applied audio mix with EQ tap to player item (async)")
+    }
+  }
 
-      // Create audio mix input parameters
-      let inputParams = AVMutableAudioMixInputParameters(track: audioTrack)
-
-      // Create the audio processing tap
-      var callbacks = MTAudioProcessingTapCallbacks(
-        version: kMTAudioProcessingTapCallbacksVersion_0,
-        clientInfo: UnsafeMutableRawPointer(Unmanaged.passRetained(self).toOpaque()),
-        init: tapInitCallback,
-        finalize: tapFinalizeCallback,
-        prepare: tapPrepareCallback,
-        unprepare: tapUnprepareCallback,
-        process: tapProcessCallback
-      )
+  /// Creates an MTAudioProcessingTap-backed AVAudioMix and sets it on the player item.
+  /// Must be called when the asset's "tracks" key is already loaded.
+  private func buildAndApplyAudioMix(to playerItem: AVPlayerItem, asset: AVAsset) {
+    guard let audioTrack = asset.tracks(withMediaType: .audio).first else {
+      NitroPlayerLogger.log("EqualizerCore", "⚠️ No audio track found in asset")
+      return
+    }
 
-      var tap: MTAudioProcessingTap?
-      let createStatus = MTAudioProcessingTapCreate(
-        kCFAllocatorDefault,
-        &callbacks,
-        kMTAudioProcessingTapCreationFlag_PreEffects,
-        &tap
-      )
+    // Create audio mix input parameters
+    let inputParams = AVMutableAudioMixInputParameters(track: audioTrack)
+
+    // Create the audio processing tap
+    var callbacks = MTAudioProcessingTapCallbacks(
+      version: kMTAudioProcessingTapCallbacksVersion_0,
+      clientInfo: UnsafeMutableRawPointer(Unmanaged.passRetained(self).toOpaque()),
+      init: tapInitCallback,
+      finalize: tapFinalizeCallback,
+      prepare: tapPrepareCallback,
+      unprepare: tapUnprepareCallback,
+      process: tapProcessCallback
+    )
 
-      guard createStatus == noErr, let audioTap = tap else {
-        NitroPlayerLogger.log("EqualizerCore", "❌ Failed to create audio processing tap, status: \(createStatus)")
-        return
-      }
+    var tap: MTAudioProcessingTap?
+    let createStatus = MTAudioProcessingTapCreate(
+      kCFAllocatorDefault,
+      &callbacks,
+      kMTAudioProcessingTapCreationFlag_PreEffects,
+      &tap
+    )
 
-      inputParams.audioTapProcessor = audioTap
+    guard createStatus == noErr, let audioTap = tap else {
+      NitroPlayerLogger.log("EqualizerCore", "❌ Failed to create audio processing tap, status: \(createStatus)")
+      return
+    }
 
-      // Create audio mix
-      let audioMix = AVMutableAudioMix()
-      audioMix.inputParameters = [inputParams]
+    inputParams.audioTapProcessor = audioTap
 
-      // Apply to player item on main thread (AVPlayerItem properties should be accessed/modified on main thread or serial queue usually, but audioMix is thread safe - safely done on main to be sure)
-      DispatchQueue.main.async {
-        playerItem.audioMix = audioMix
-        NitroPlayerLogger.log("EqualizerCore", "✅ Applied audio mix with EQ tap to player item (async)")
-      }
-    }
+    // Create and apply audio mix
+    let audioMix = AVMutableAudioMix()
+    audioMix.inputParameters = [inputParams]
+    playerItem.audioMix = audioMix
   }
 
   // MARK: - Public Methods
@@ -174,7 +205,8 @@ class EqualizerCore {
   }
 
   func getBands() -> [EqualizerBand] {
-    return (0..<5).map { i in
+    if let cached = cachedBands { return cached }
+    let bands = (0..<5).map { i in
       EqualizerBand(
         index: Double(i),
         centerFrequency: Double(frequencies[i]),
@@ -182,6 +214,8 @@ class EqualizerCore {
         frequencyLabel: frequencyLabels[i]
       )
     }
+    cachedBands = bands
+    return bands
   }
 
   func setBandGain(bandIndex: Int, gainDb: Double) -> Bool {
@@ -189,6 +223,7 @@ class EqualizerCore {
 
     let clampedGain = max(-12.0, min(12.0, gainDb))
     currentGains[bandIndex] = clampedGain
+    cachedBands = nil
     gainsDirty = true
 
     currentPresetName = nil
@@ -207,6 +242,7 @@ class EqualizerCore {
     for i in 0..<5 {
       currentGains[i] = max(-12.0, min(12.0, gains[i]))
     }
+    cachedBands = nil
     gainsDirty = true
 
     notifyBandChange(getBands())
@@ -231,15 +267,18 @@ class EqualizerCore {
   }
 
   func getCustomPresets() -> [EqualizerPreset] {
+    if let cached = cachedCustomPresets { return cached }
     guard let data = UserDefaults.standard.data(forKey: customPresetsKey),
       let presets = try? JSONDecoder().decode([String: [Double]].self, from: data)
     else {
       return []
     }
 
-    return presets.map { name, gains in
+    let result = presets.map { name, gains in
       EqualizerPreset(name: name, gains: gains, type: .custom)
     }
+    cachedCustomPresets = result
+    return result
   }
 
   func applyPreset(_ presetName: String) -> Bool {
@@ -292,6 +331,7 @@ class EqualizerCore {
 
     if let data = try? JSONEncoder().encode(presets) {
       UserDefaults.standard.set(data, forKey: customPresetsKey)
+      cachedCustomPresets = nil
       currentPresetName = name
       notifyPresetChange(name)
       saveCurrentPreset(name)
@@ -321,6 +361,7 @@ class EqualizerCore {
 
     if let data = try? JSONEncoder().encode(presets) {
       UserDefaults.standard.set(data, forKey: customPresetsKey)
+      cachedCustomPresets = nil
 
       if currentPresetName == name {
         currentPresetName = nil

package/ios/media/MediaSessionManager.swift

@@ -21,7 +21,7 @@ class MediaSessionManager {
   // MARK: - Properties
 
   private var trackPlayerCore: TrackPlayerCore?
-  private var artworkCache: [String: UIImage] = [:]
+  private let artworkCache = NSCache<NSString, UIImage>()
 
   private var showInNotification: Bool = true
 
@@ -135,7 +135,7 @@ class MediaSessionManager {
     // Artwork: use cache synchronously when available, otherwise kick off async load
     if let artwork = track.artwork, case .second(let artworkUrl) = artwork {
       lastArtworkUrl = artworkUrl
-      if let cachedImage = artworkCache[artworkUrl] {
+      if let cachedImage = artworkCache.object(forKey: artworkUrl as NSString) {
         nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
           boundsSize: CGSize(width: Constants.artworkSize, height: Constants.artworkSize),
           requestHandler: { _ in cachedImage }
@@ -285,7 +285,7 @@ class MediaSessionManager {
   }
 
   private func loadArtwork(url: String, completion: @escaping (UIImage?) -> Void) {
-    if let cached = artworkCache[url] {
+    if let cached = artworkCache.object(forKey: url as NSString) {
       completion(cached)
       return
     }
@@ -301,7 +301,7 @@ class MediaSessionManager {
         return
       }
       DispatchQueue.main.async {
-        self?.artworkCache[url] = image
+        self?.artworkCache.setObject(image, forKey: url as NSString)
         completion(image)
       }
     }.resume()
@@ -310,6 +310,6 @@ class MediaSessionManager {
   func release() {
     clearNowPlayingInfo()
     disableAllCommands()
-    artworkCache.removeAll()
+    artworkCache.removeAllObjects()
   }
 }

package/ios/playlist/PlaylistModel.swift

@@ -15,7 +15,7 @@ class PlaylistModel {
   let name: String
   let description: String?
   let artwork: String?
-  var tracks: [TrackItem]
+  let tracks: [TrackItem]
 
   init(
     id: String, name: String, description: String? = nil, artwork: String? = nil,

package/ios/queue/HybridPlayerQueue.swift

@@ -77,6 +77,7 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
 
   func onPlaylistsChanged(callback: @escaping ([Playlist], QueueOperation?) -> Void) throws {
     // Store callback in static storage so it persists across HybridPlayerQueue instances
+    HybridPlayerQueue.playlistsChangeCallbacks.removeAll()
     HybridPlayerQueue.playlistsChangeCallbacks.append(callback)
 
     // Register a single listener with PlaylistManager that dispatches to all callbacks
@@ -94,6 +95,7 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
 
   func onPlaylistChanged(callback: @escaping (String, Playlist, QueueOperation?) -> Void) throws {
     // Store callback in static storage so it persists across HybridPlayerQueue instances
+    HybridPlayerQueue.playlistChangeCallbacks.removeAll()
     HybridPlayerQueue.playlistChangeCallbacks.append(callback)
 
     // Register listeners for all existing playlists (only once per playlist)

package/ios/storage/NitroPlayerStorage.swift

@@ -35,10 +35,12 @@ enum NitroPlayerStorage {
   /// Uses `FileManager` APIs — never hardcodes the UUID-based container path
   /// so this resolves correctly regardless of which device or simulator the
   /// app runs on.
-  private static func storageDirectory() -> URL {
+  private static let storageDir: URL = {
     let appSupport = FileManager.default.urls(
       for: .applicationSupportDirectory, in: .userDomainMask
     ).first!
     return appSupport.appendingPathComponent("NitroPlayer", isDirectory: true)
-  }
+  }()
+
+  private static func storageDirectory() -> URL { storageDir }
 }

package/lib/hooks/usePlaylist.js

@@ -41,6 +41,9 @@ export function usePlaylist() {
     const [isLoading, setIsLoading] = useState(true);
     const isMounted = useRef(true);
     const hasSubscribed = useRef(false);
+    // Tracks the last fetched playlist ID so track-change events can skip
+    // a full refresh when the playlist itself hasn't changed.
+    const lastPlaylistIdRef = useRef(undefined);
     const refreshPlaylists = useCallback(() => {
         if (!isMounted.current)
             return;
@@ -49,6 +52,7 @@ export function usePlaylist() {
             const playlistId = PlayerQueue.getCurrentPlaylistId();
             if (!isMounted.current)
                 return;
+            lastPlaylistIdRef.current = playlistId;
             setCurrentPlaylistId(playlistId);
             // Get current playlist details
             if (playlistId) {
@@ -88,6 +92,24 @@ export function usePlaylist() {
             }
         }
     }, []);
+    // Lightweight track-change handler: only does a full refresh when the
+    // active playlist ID has actually changed (e.g. cross-playlist navigation).
+    // Within-playlist track changes — the common case — are skipped with a
+    // single bridge call instead of three.
+    const refreshOnTrackChange = useCallback(() => {
+        if (!isMounted.current)
+            return;
+        try {
+            const newPlaylistId = PlayerQueue.getCurrentPlaylistId();
+            if (newPlaylistId === lastPlaylistIdRef.current)
+                return;
+            lastPlaylistIdRef.current = newPlaylistId;
+            refreshPlaylists();
+        }
+        catch (error) {
+            console.error('[usePlaylist] Error checking playlist ID on track change:', error);
+        }
+    }, [refreshPlaylists]);
     // Initialize and setup mounted ref
     useEffect(() => {
         isMounted.current = true;
@@ -113,18 +135,17 @@ export function usePlaylist() {
             console.error('[usePlaylist] Error setting up playlist listener:', error);
         }
     }, [refreshPlaylists]);
-    // Also refresh when track changes (as it might indicate playlist loaded)
+    // Refresh on track change only if the active playlist ID changed.
     useEffect(() => {
         const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-            // Refresh to update currentPlaylistId when track changes
             if (isMounted.current) {
-                refreshPlaylists();
+                refreshOnTrackChange();
             }
         });
         return () => {
             unsubscribe();
         };
-    }, [refreshPlaylists]);
+    }, [refreshOnTrackChange]);
     return {
         currentPlaylist,
         currentPlaylistId,

package/nitrogen/generated/android/NitroPlayer+autolinking.cmake

@@ -2,7 +2,7 @@
 # NitroPlayer+autolinking.cmake
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2026 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a CMake file that adds all files generated by Nitrogen

package/nitrogen/generated/android/NitroPlayer+autolinking.gradle

@@ -2,7 +2,7 @@
 /// NitroPlayer+autolinking.gradle
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 /// This is a Gradle file that adds all files generated by Nitrogen