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

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,7 +1,11 @@
 #include "NitroPlayerOnLoad.hpp"
 
 #include <jni.h>
+#include <fbjni/fbjni.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return margelo::nitro::nitroplayer::initialize(vm);
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::nitroplayer::registerAllNatives();
+  });
 }
+

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridPlayerQueue.kt

@@ -22,8 +22,8 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         playlistManager = core.getPlaylistManager()
     }
 
-    private val playlistsChangeListeners = mutableListOf<() -> Unit>()
-    private val playlistChangeListeners = mutableMapOf<String, () -> Unit>()
+    private val playlistsChangeListeners = java.util.concurrent.CopyOnWriteArrayList<() -> Unit>()
+    private val playlistChangeListeners = java.util.concurrent.ConcurrentHashMap<String, () -> Unit>()
 
     @DoNotStrip
     @Keep

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -44,9 +44,9 @@ class TrackPlayerCore private constructor(
     private val downloadManager = DownloadManagerCore.getInstance(context)
     private val mediaLibraryManager = MediaLibraryManager.getInstance(context)
     private var mediaSessionManager: MediaSessionManager? = null
-    private var currentPlaylistId: String? = null
+    @Volatile private var currentPlaylistId: String? = null
     private var isManuallySeeked = false
-    private var isAndroidAutoConnected: Boolean = false
+    @Volatile private var isAndroidAutoConnected: Boolean = false
     private var androidAutoConnectionDetector: AndroidAutoConnectionDetector? = null
     var onAndroidAutoConnectionChange: ((Boolean) -> Unit)? = null
     private var previousMediaItem: MediaItem? = null
@@ -82,7 +82,7 @@ class TrackPlayerCore private constructor(
     private val onPlaybackProgressChangeListeners =
         Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Double, Double, Boolean?) -> Unit>>())
 
-    private var currentRepeatMode: RepeatMode = RepeatMode.OFF
+    @Volatile private var currentRepeatMode: RepeatMode = RepeatMode.OFF
     private var lookaheadCount: Int = 5 // Number of tracks to preload ahead
 
     // Temporary tracks for addToUpNext and playNext
@@ -171,7 +171,7 @@ class TrackPlayerCore private constructor(
                                 // Notify JavaScript
                                 onAndroidAutoConnectionChange?.invoke(connected)
 
-                                NitroPlayerLogger.log("TrackPlayerCore", "🚗 Android Auto connection changed: connected=$connected, type=$connectionType")
+                                NitroPlayerLogger.log("TrackPlayerCore") { "🚗 Android Auto connection changed: connected=$connected, type=$connectionType" }
                             }
                         }
                         registerCarConnectionReceiver()
@@ -423,7 +423,7 @@ class TrackPlayerCore private constructor(
                     }
                 }
             } catch (e: Exception) {
-                NitroPlayerLogger.log("TrackPlayerCore", "❌ TrackPlayerCore: Error playing from playlist track - ${e.message}")
+                NitroPlayerLogger.log("TrackPlayerCore") { "❌ TrackPlayerCore: Error playing from playlist track - ${e.message}" }
                 e.printStackTrace()
             }
         }
@@ -563,19 +563,19 @@ class TrackPlayerCore private constructor(
 
         // Case 1: If fromPlaylist is provided, use that playlist
         if (fromPlaylist != null) {
-            NitroPlayerLogger.log("TrackPlayerCore", "🎵 TrackPlayerCore: Looking for song in specified playlist: $fromPlaylist")
+            NitroPlayerLogger.log("TrackPlayerCore") { "🎵 TrackPlayerCore: Looking for song in specified playlist: $fromPlaylist" }
             val playlist = playlistManager.getPlaylist(fromPlaylist)
             if (playlist != null) {
                 songIndex = playlist.tracks.indexOfFirst { it.id == songId }
                 if (songIndex >= 0) {
                     targetPlaylistId = fromPlaylist
-                    NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index $songIndex in playlist $fromPlaylist")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "✅ Found song at index $songIndex in playlist $fromPlaylist" }
                 } else {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Song $songId not found in specified playlist $fromPlaylist")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Song $songId not found in specified playlist $fromPlaylist" }
                     return
                 }
             } else {
-                NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Playlist $fromPlaylist not found")
+                NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Playlist $fromPlaylist not found" }
                 return
             }
         }
@@ -590,7 +590,7 @@ class TrackPlayerCore private constructor(
                     songIndex = currentPlaylist.tracks.indexOfFirst { it.id == songId }
                     if (songIndex >= 0) {
                         targetPlaylistId = currentPlaylistId
-                        NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index $songIndex in current playlist $currentPlaylistId")
+                        NitroPlayerLogger.log("TrackPlayerCore") { "✅ Found song at index $songIndex in current playlist $currentPlaylistId" }
                     }
                 }
             }
@@ -604,7 +604,7 @@ class TrackPlayerCore private constructor(
                     songIndex = playlist.tracks.indexOfFirst { it.id == songId }
                     if (songIndex >= 0) {
                         targetPlaylistId = playlist.id
-                        NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index $songIndex in playlist ${playlist.id}")
+                        NitroPlayerLogger.log("TrackPlayerCore") { "✅ Found song at index $songIndex in playlist ${playlist.id}" }
                         break
                     }
                 }
@@ -626,7 +626,7 @@ class TrackPlayerCore private constructor(
 
         // Load playlist if it's different from current
         if (currentPlaylistId != targetPlaylistId) {
-            NitroPlayerLogger.log("TrackPlayerCore", "🔄 Loading new playlist: $targetPlaylistId")
+            NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Loading new playlist: $targetPlaylistId" }
             val playlist = playlistManager.getPlaylist(targetPlaylistId)
             if (playlist != null) {
                 currentPlaylistId = targetPlaylistId
@@ -634,12 +634,12 @@ class TrackPlayerCore private constructor(
 
                 // Wait a bit for playlist to load, then play from index
                 // Note: Removed postDelayed to avoid race conditions with subsequent queue operations
-                NitroPlayerLogger.log("TrackPlayerCore", "▶️ Playing from index: $songIndex")
+                NitroPlayerLogger.log("TrackPlayerCore") { "▶️ Playing from index: $songIndex" }
                 playFromIndex(songIndex)
             }
         } else {
             // Playlist already loaded, just play from index
-            NitroPlayerLogger.log("TrackPlayerCore", "▶️ Playing from index: $songIndex")
+            NitroPlayerLogger.log("TrackPlayerCore") { "▶️ Playing from index: $songIndex" }
             playFromIndex(songIndex)
         }
     }
@@ -687,7 +687,7 @@ class TrackPlayerCore private constructor(
                 playFromIndexInternal(currentTrackIndex)
             } else if (currentTrackIndex > 0) {
                 // Go to previous track in original playlist
-                NitroPlayerLogger.log("TrackPlayerCore", "🔄 TrackPlayerCore: Going to previous track, currentTrackIndex: $currentTrackIndex -> ${currentTrackIndex - 1}")
+                NitroPlayerLogger.log("TrackPlayerCore") { "🔄 TrackPlayerCore: Going to previous track, currentTrackIndex: $currentTrackIndex -> ${currentTrackIndex - 1}" }
                 playFromIndexInternal(currentTrackIndex - 1)
             } else {
                 // Already at first track, seek to beginning
@@ -718,7 +718,7 @@ class TrackPlayerCore private constructor(
                     }
             }
         }
-        NitroPlayerLogger.log("TrackPlayerCore", "🔁 setRepeatMode: $mode")
+        NitroPlayerLogger.log("TrackPlayerCore") { "🔁 setRepeatMode: $mode" }
         return true
     }
 
@@ -750,7 +750,15 @@ class TrackPlayerCore private constructor(
             Thread.currentThread().interrupt()
         }
 
-        return result ?: getStateInternal()
+        return result ?: PlayerState(
+            currentTrack = null,
+            currentPosition = 0.0,
+            totalDuration = 0.0,
+            currentState = TrackPlayerState.STOPPED,
+            currentPlaylistId = null,
+            currentIndex = -1.0,
+            currentPlayingType = CurrentPlayingType.NOT_PLAYING
+        )
     }
 
     private fun getStateInternal(): PlayerState =
@@ -832,7 +840,7 @@ class TrackPlayerCore private constructor(
             }
             lookaheadCount?.let {
                 this.lookaheadCount = it
-                NitroPlayerLogger.log("TrackPlayerCore", "🔄 Lookahead count set to: $it")
+                NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Lookahead count set to: $it" }
             }
             mediaSessionManager?.configure(
                 androidAutoEnabled,
@@ -985,7 +993,7 @@ class TrackPlayerCore private constructor(
 
             // Remove tracks before the target from playNext (they're being skipped)
             if (actualListIndex > 0) {
-                repeat(actualListIndex) { playNextStack.removeAt(0) }
+                playNextStack.subList(0, actualListIndex).clear()
             }
 
             // Rebuild queue and advance
@@ -1010,7 +1018,7 @@ class TrackPlayerCore private constructor(
 
             // Remove tracks before target from upNext
             if (actualListIndex > 0) {
-                repeat(actualListIndex) { upNextQueue.removeAt(0) }
+                upNextQueue.subList(0, actualListIndex).clear()
             }
 
             // Rebuild queue and advance
@@ -1066,7 +1074,7 @@ class TrackPlayerCore private constructor(
         }
 
         if (index < 0 || index >= currentTracks.size) {
-            NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Invalid index $index for currentTracks size ${currentTracks.size}")
+            NitroPlayerLogger.log("TrackPlayerCore") { "   ❌ Invalid index $index for currentTracks size ${currentTracks.size}" }
             return
         }
 
@@ -1112,18 +1120,18 @@ class TrackPlayerCore private constructor(
     }
 
     private fun addToUpNextInternal(trackId: String) {
-        NitroPlayerLogger.log("TrackPlayerCore", "📋 TrackPlayerCore: addToUpNext($trackId)")
+        NitroPlayerLogger.log("TrackPlayerCore") { "📋 TrackPlayerCore: addToUpNext($trackId)" }
 
         // Find the track from current playlist or all playlists
         val track = findTrackById(trackId)
         if (track == null) {
-            NitroPlayerLogger.log("TrackPlayerCore", "❌ TrackPlayerCore: Track $trackId not found")
+            NitroPlayerLogger.log("TrackPlayerCore") { "❌ TrackPlayerCore: Track $trackId not found" }
             return
         }
 
         // Add to end of upNext queue (FIFO)
         upNextQueue.add(track)
-        NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Added '${track.title}' to upNext queue (position: ${upNextQueue.size})")
+        NitroPlayerLogger.log("TrackPlayerCore") { "   ✅ Added '${track.title}' to upNext queue (position: ${upNextQueue.size})" }
 
         // Rebuild the player queue if actively playing
         if (::player.isInitialized && player.currentMediaItem != null) {
@@ -1142,18 +1150,18 @@ class TrackPlayerCore private constructor(
     }
 
     private fun playNextInternal(trackId: String) {
-        NitroPlayerLogger.log("TrackPlayerCore", "⏭️ TrackPlayerCore: playNext($trackId)")
+        NitroPlayerLogger.log("TrackPlayerCore") { "⏭️ TrackPlayerCore: playNext($trackId)" }
 
         // Find the track from current playlist or all playlists
         val track = findTrackById(trackId)
         if (track == null) {
-            NitroPlayerLogger.log("TrackPlayerCore", "❌ TrackPlayerCore: Track $trackId not found")
+            NitroPlayerLogger.log("TrackPlayerCore") { "❌ TrackPlayerCore: Track $trackId not found" }
             return
         }
 
         // Insert at beginning of playNext stack (LIFO)
         playNextStack.add(0, track)
-        NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Added '${track.title}' to playNext stack (position: 1)")
+        NitroPlayerLogger.log("TrackPlayerCore") { "   ✅ Added '${track.title}' to playNext stack (position: 1)" }
 
         // Rebuild the player queue if actively playing
         if (::player.isInitialized && player.currentMediaItem != null) {
@@ -1274,7 +1282,7 @@ class TrackPlayerCore private constructor(
                 NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
                 NitroPlayerLogger.log("TrackPlayerCore", "✅ TrackPlayerCore: Android Auto media library set successfully")
             } catch (e: Exception) {
-                NitroPlayerLogger.log("TrackPlayerCore", "❌ TrackPlayerCore: Error setting media library - ${e.message}")
+                NitroPlayerLogger.log("TrackPlayerCore") { "❌ TrackPlayerCore: Error setting media library - ${e.message}" }
                 e.printStackTrace()
             }
         }
@@ -1297,7 +1305,7 @@ class TrackPlayerCore private constructor(
                 // Convert to 0.0-1.0 range for ExoPlayer
                 val normalizedVolume = (clampedVolume / 100.0).toFloat()
                 player.volume = normalizedVolume
-                NitroPlayerLogger.log("TrackPlayerCore", "🔊 TrackPlayerCore: Volume set to $clampedVolume% (normalized: $normalizedVolume)")
+                NitroPlayerLogger.log("TrackPlayerCore") { "🔊 TrackPlayerCore: Volume set to $clampedVolume% (normalized: $normalizedVolume)" }
             }
             true
         } else {
@@ -1342,7 +1350,7 @@ class TrackPlayerCore private constructor(
                 try {
                     callback(track, reason)
                 } catch (e: Exception) {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in track change listener: ${e.message}")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Error in track change listener: ${e.message}" }
                 }
             }
         }
@@ -1363,7 +1371,7 @@ class TrackPlayerCore private constructor(
                 try {
                     callback(state, reason)
                 } catch (e: Exception) {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in playback state listener: ${e.message}")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Error in playback state listener: ${e.message}" }
                 }
             }
         }
@@ -1384,29 +1392,38 @@ class TrackPlayerCore private constructor(
                 try {
                     callback(position, duration)
                 } catch (e: Exception) {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in seek listener: ${e.message}")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Error in seek listener: ${e.message}" }
                 }
             }
         }
     }
 
+    private var progressNotifyCounter = 0
+    private val progressCallbackScratch = ArrayList<(Double, Double, Boolean?) -> Unit>(4)
+
     private fun notifyPlaybackProgress(
         position: Double,
         duration: Double,
         isPlaying: Boolean?,
     ) {
-        val liveCallbacks =
-            synchronized(onPlaybackProgressChangeListeners) {
+        progressCallbackScratch.clear()
+        synchronized(onPlaybackProgressChangeListeners) {
+            if (++progressNotifyCounter % 10 == 0) {
                 onPlaybackProgressChangeListeners.removeAll { !it.isAlive }
-                onPlaybackProgressChangeListeners.map { it.callback }
             }
+            for (box in onPlaybackProgressChangeListeners) {
+                if (box.isAlive) progressCallbackScratch.add(box.callback)
+            }
+        }
+
+        if (progressCallbackScratch.isEmpty()) return
 
         handler.post {
-            for (callback in liveCallbacks) {
+            for (callback in progressCallbackScratch) {
                 try {
                     callback(position, duration, isPlaying)
                 } catch (e: Exception) {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in playback progress listener: ${e.message}")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Error in playback progress listener: ${e.message}" }
                 }
             }
         }
@@ -1502,22 +1519,34 @@ class TrackPlayerCore private constructor(
      */
     fun updateTracks(tracks: List<TrackItem>) {
         handler.post {
-            NitroPlayerLogger.log("TrackPlayerCore", "🔄 updateTracks: ${tracks.size} updates")
+            NitroPlayerLogger.log("TrackPlayerCore") { "🔄 updateTracks: ${tracks.size} updates" }
 
-            // Get current track ID to avoid updating it (preserves gapless playback)
-            val currentTrackId = getCurrentTrack()?.id
+            // Get current track to decide how to handle it
+            val currentTrack = getCurrentTrack()
+            val currentTrackId = currentTrack?.id
+
+            // Separate the current-track update (if any) from the rest
+            val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
+            val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
 
             // Filter out current track and validate
             val safeTracks =
                 tracks.filter { track ->
                     when {
-                        track.id == currentTrackId -> {
-                            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Skipping update for currently playing track: ${track.id} (preserves gapless)")
+                        track.id == currentTrackId && !currentTrackIsEmpty -> {
+                            // Has a real URL already — skip to preserve gapless playback
+                            NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Skipping update for currently playing track: ${track.id} (preserves gapless)" }
                             false
                         }
 
+                        track.id == currentTrackId && currentTrackIsEmpty -> {
+                            // Empty URL — must not be playing, allow the update
+                            NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Updating current track with no URL: ${track.id}" }
+                            track.url.isNotEmpty() // only include if the update actually provides a URL
+                        }
+
                         track.url.isEmpty() -> {
-                            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Skipping track with empty URL: ${track.id}")
+                            NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Skipping track with empty URL: ${track.id}" }
                             false
                         }
 
@@ -1535,9 +1564,26 @@ class TrackPlayerCore private constructor(
             // Update in PlaylistManager
             val affectedPlaylists = playlistManager.updateTracks(safeTracks)
 
-            // Rebuild queue if current playlist was affected
+            // If the current track was one of the updates (had no URL before), replace its
+            // MediaItem in ExoPlayer directly — rebuildQueueFromCurrentPosition skips index 0.
+            if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
+                val exoIndex = player.currentMediaItemIndex
+                if (exoIndex >= 0) {
+                    val playlistId = currentPlaylistId ?: ""
+                    val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
+                    val newMediaItem = currentTrackUpdate.toMediaItem(mediaId)
+                    NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Replacing MediaItem at index $exoIndex for current track with resolved URL" }
+                    player.replaceMediaItem(exoIndex, newMediaItem)
+                    // If ExoPlayer was in an error/idle state waiting for a URI, re-prepare
+                    if (player.playbackState == Player.STATE_IDLE) {
+                        player.prepare()
+                    }
+                }
+            }
+
+            // Rebuild queue for other updated tracks if current playlist was affected
             if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
-                NitroPlayerLogger.log("TrackPlayerCore", "🔄 Rebuilding queue - ${affectedPlaylists[currentPlaylistId]} tracks updated in current playlist")
+                NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Rebuilding queue - ${affectedPlaylists[currentPlaylistId]} tracks updated in current playlist" }
 
                 // This method preserves current item and gapless buffering
                 rebuildQueueFromCurrentPosition()
@@ -1545,7 +1591,7 @@ class TrackPlayerCore private constructor(
                 NitroPlayerLogger.log("TrackPlayerCore", "✅ Queue rebuilt, gapless playback preserved")
             }
 
-            NitroPlayerLogger.log("TrackPlayerCore", "✅ Track updates complete - ${affectedPlaylists.size} playlists affected")
+            NitroPlayerLogger.log("TrackPlayerCore") { "✅ Track updates complete - ${affectedPlaylists.size} playlists affected" }
         }
     }
 
@@ -1696,14 +1742,14 @@ class TrackPlayerCore private constructor(
     }
 
     // Add to class properties
-    private val onTracksNeedUpdateListeners = mutableListOf<WeakReference<OnTracksNeedUpdateListener>>()
+    private val onTracksNeedUpdateListeners = mutableListOf<OnTracksNeedUpdateListener>()
 
     /**
      * Register listener for when tracks need update
      */
     fun addOnTracksNeedUpdateListener(listener: OnTracksNeedUpdateListener) {
         handler.post {
-            onTracksNeedUpdateListeners.add(WeakReference(listener))
+            onTracksNeedUpdateListeners.add(listener)
         }
     }
 
@@ -1712,7 +1758,7 @@ class TrackPlayerCore private constructor(
      */
     fun removeOnTracksNeedUpdateListener(listener: OnTracksNeedUpdateListener) {
         handler.post {
-            onTracksNeedUpdateListeners.removeAll { it.get() == listener || it.get() == null }
+            onTracksNeedUpdateListeners.removeAll { it == listener }
         }
     }
 
@@ -1726,8 +1772,7 @@ class TrackPlayerCore private constructor(
     ) {
         val liveCallbacks =
             synchronized(onTracksNeedUpdateListeners) {
-                onTracksNeedUpdateListeners.removeAll { it.get() == null }
-                onTracksNeedUpdateListeners.mapNotNull { it.get() }
+                onTracksNeedUpdateListeners.toList()
             }
 
         handler.post {
@@ -1735,7 +1780,7 @@ class TrackPlayerCore private constructor(
                 try {
                     callback.onTracksNeedUpdate(tracks, lookahead)
                 } catch (e: Exception) {
-                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in onTracksNeedUpdate listener: ${e.message}")
+                    NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ Error in onTracksNeedUpdate listener: ${e.message}" }
                 }
             }
         }
@@ -1746,11 +1791,23 @@ class TrackPlayerCore private constructor(
      * Call this in onMediaItemTransition or after skipTo operations
      */
     private fun checkUpcomingTracksForUrls(lookahead: Int = 5) {
-        val nextTracks = getNextTracksInternal(lookahead)
-        val tracksNeedingUrls = nextTracks.filter { it.url.isEmpty() }
+        val upcomingTracks = if (currentTrackIndex < 0) {
+            // Playback hasn't started yet - check first N tracks from the loaded playlist
+            currentTracks.take(lookahead)
+        } else {
+            // Playback is active - check upcoming tracks
+            getNextTracksInternal(lookahead)
+        }
+
+        // Always include the current track if it has no URL — it can't play without one
+        val currentTrack = getCurrentTrack()
+        val currentNeedsUrl = currentTrack != null && currentTrack.url.isEmpty()
+        val candidateTracks = if (currentNeedsUrl) listOf(currentTrack!!) + upcomingTracks else upcomingTracks
+
+        val tracksNeedingUrls = candidateTracks.filter { it.url.isEmpty() }
 
         if (tracksNeedingUrls.isNotEmpty()) {
-            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ ${tracksNeedingUrls.size} upcoming tracks need URLs")
+            NitroPlayerLogger.log("TrackPlayerCore") { "⚠️ ${tracksNeedingUrls.size} upcoming tracks need URLs" }
             notifyTracksNeedUpdate(tracksNeedingUrls, lookahead)
         }
     }

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadDatabase.kt

@@ -205,12 +205,14 @@ class DownloadDatabase private constructor(
             downloadedTracks.remove(trackId)
 
             // Remove from all playlist associations
+            val emptyPlaylists = mutableListOf<String>()
             playlistTracks.forEach { (playlistId, trackIds) ->
                 trackIds.remove(trackId)
                 if (trackIds.isEmpty()) {
-                    playlistTracks.remove(playlistId)
+                    emptyPlaylists.add(playlistId)
                 }
             }
+            emptyPlaylists.forEach { playlistTracks.remove(it) }
 
             saveToDisk()
         }

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadManagerCore.kt

@@ -28,6 +28,8 @@ class DownloadManagerCore private constructor(
             instance ?: synchronized(this) {
                 instance ?: DownloadManagerCore(context.applicationContext).also { instance = it }
             }
+
+        private val ACTIVE_STATES = setOf(DownloadState.DOWNLOADING, DownloadState.PENDING, DownloadState.PAUSED)
     }
 
     // Configuration
@@ -221,20 +223,29 @@ class DownloadManagerCore private constructor(
 
     fun getActiveDownloads(): Array<DownloadTask> =
         activeTasks.values
-            .filter { it.state in listOf(DownloadState.DOWNLOADING, DownloadState.PENDING, DownloadState.PAUSED) }
+            .filter { it.state in ACTIVE_STATES }
             .map { it.toDownloadTask() }
             .toTypedArray()
 
     fun getQueueStatus(): DownloadQueueStatus {
-        val metadata = activeTasks.values.toList()
+        var pendingCount = 0
+        var activeCount = 0
+        var failedCount = 0
+        var totalBytes = 0.0
+        var downloadedBytes = 0.0
+
+        for (m in activeTasks.values) {
+            when (m.state) {
+                DownloadState.PENDING -> pendingCount++
+                DownloadState.DOWNLOADING -> activeCount++
+                DownloadState.FAILED -> failedCount++
+                else -> {}
+            }
+            totalBytes += m.totalBytes ?: 0.0
+            downloadedBytes += m.bytesDownloaded
+        }
 
-        val pendingCount = metadata.count { it.state == DownloadState.PENDING }
-        val activeCount = metadata.count { it.state == DownloadState.DOWNLOADING }
         val completedCount = database.getAllDownloadedTracks().size
-        val failedCount = metadata.count { it.state == DownloadState.FAILED }
-
-        val totalBytes = metadata.sumOf { it.totalBytes ?: 0.0 }
-        val downloadedBytes = metadata.sumOf { it.bytesDownloaded }
 
         return DownloadQueueStatus(
             pendingCount = pendingCount.toDouble(),

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadWorker.kt

@@ -35,6 +35,7 @@ class DownloadWorker(
         private const val NOTIFICATION_CHANNEL_ID = "nitro_player_downloads"
         private const val NOTIFICATION_ID = 2001
         private const val BUFFER_SIZE = 8192
+        private val CONTENT_DISPOSITION_REGEX = Regex("filename=\"?([^\";]+)\"?")
     }
 
     private val downloadManager = DownloadManagerCore.getInstance(context)
@@ -130,7 +131,7 @@ class DownloadWorker(
                 if (extension.isNullOrEmpty()) {
                     val contentDisposition = connection.getHeaderField("Content-Disposition")
                     if (contentDisposition != null) {
-                        val match = Regex("filename=\"?([^\";]+)\"?").find(contentDisposition)
+                        val match = CONTENT_DISPOSITION_REGEX.find(contentDisposition)
                         if (match != null) {
                             val filename = match.groupValues[1]
                             extension = MimeTypeMap.getFileExtensionFromUrl(filename)

package/android/src/main/java/com/margelo/nitro/nitroplayer/equalizer/EqualizerCore.kt

@@ -190,8 +190,7 @@ class EqualizerCore private constructor(
             currentPresetName = null // Custom settings
             notifyBandChange(getBands())
             notifyPresetChange(null)
-            saveBandGains(getAllGains())
-            saveCurrentPreset(null)
+            saveBandGainsAndPreset(getAllGains(), null)
             true
         } catch (e: Exception) {
             false
@@ -389,6 +388,19 @@ class EqualizerCore private constructor(
         }
     }
 
+    private fun saveBandGainsAndPreset(gains: List<Double>, presetName: String?) {
+        val json = JSONArray()
+        gains.forEach { json.put(it) }
+        prefs.edit().apply {
+            putString("eq_band_gains", json.toString())
+            if (presetName != null) {
+                putString("eq_current_preset", presetName)
+            } else {
+                remove("eq_current_preset")
+            }
+        }.apply()
+    }
+
     private fun restoreSettings() {
         val enabled = prefs.getBoolean("eq_enabled", false)
         val gainsJson = prefs.getString("eq_band_gains", null)