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

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

@@ -11,6 +11,7 @@ import android.graphics.BitmapFactory
 import android.net.Uri
 import android.os.Build
 import android.util.Log
+import android.util.LruCache
 import androidx.core.app.NotificationCompat
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
@@ -49,7 +50,9 @@ class MediaSessionManager(
         private set
     private var notificationManager: NotificationManager? = null
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-    private val artworkCache = mutableMapOf<String, Bitmap>()
+    private val artworkCache = object : LruCache<String, Bitmap>(20) {
+        override fun sizeOf(key: String, value: Bitmap): Int = 1
+    }
 
     private var androidAutoEnabled: Boolean = false
     private var carPlayEnabled: Boolean = false
@@ -115,7 +118,7 @@ class MediaSessionManager(
                                 mediaItems: MutableList<MediaItem>,
                             ): ListenableFuture<MutableList<MediaItem>> {
                                 // This is called when Android Auto requests to play a track
-                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: onAddMediaItems called with ${mediaItems.size} items")
+                                NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: onAddMediaItems called with ${mediaItems.size} items" }
 
                                 if (mediaItems.isEmpty()) {
                                     return Futures.immediateFuture(mutableListOf())
@@ -129,7 +132,7 @@ class MediaSessionManager(
                                         requestedMediaItem.requestMetadata.mediaUri?.toString()
                                             ?: requestedMediaItem.mediaId
 
-                                    NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Processing mediaId: $mediaId")
+                                    NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: Processing mediaId: $mediaId" }
 
                                     try {
                                         // Parse mediaId format: "playlistId:trackId"
@@ -138,7 +141,7 @@ class MediaSessionManager(
                                             val playlistId = mediaId.substring(0, colonIndex)
                                             val trackId = mediaId.substring(colonIndex + 1)
 
-                                            NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Parsed playlistId: $playlistId, trackId: $trackId")
+                                            NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: Parsed playlistId: $playlistId, trackId: $trackId" }
 
                                             // Get the playlist and track
                                             val playlist = playlistManager.getPlaylist(playlistId)
@@ -148,27 +151,27 @@ class MediaSessionManager(
                                                     // Create a proper MediaItem with all metadata
                                                     val resolvedMediaItem = createMediaItem(track, mediaId)
                                                     updatedMediaItems.add(resolvedMediaItem)
-                                                    NitroPlayerLogger.log("MediaSessionManager", "✅ MediaSessionManager: Resolved track: ${track.title}")
+                                                    NitroPlayerLogger.log("MediaSessionManager") { "✅ MediaSessionManager: Resolved track: ${track.title}" }
                                                 } else {
-                                                    NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Track $trackId not found in playlist")
+                                                    NitroPlayerLogger.log("MediaSessionManager") { "⚠️ MediaSessionManager: Track $trackId not found in playlist" }
                                                     updatedMediaItems.add(requestedMediaItem)
                                                 }
                                             } else {
-                                                NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Playlist $playlistId not found")
+                                                NitroPlayerLogger.log("MediaSessionManager") { "⚠️ MediaSessionManager: Playlist $playlistId not found" }
                                                 updatedMediaItems.add(requestedMediaItem)
                                             }
                                         } else {
-                                            NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Invalid mediaId format: $mediaId")
+                                            NitroPlayerLogger.log("MediaSessionManager") { "⚠️ MediaSessionManager: Invalid mediaId format: $mediaId" }
                                             updatedMediaItems.add(requestedMediaItem)
                                         }
                                     } catch (e: Exception) {
-                                        NitroPlayerLogger.log("MediaSessionManager", "❌ MediaSessionManager: Error processing mediaId - ${e.message}")
+                                        NitroPlayerLogger.log("MediaSessionManager") { "❌ MediaSessionManager: Error processing mediaId - ${e.message}" }
                                         e.printStackTrace()
                                         updatedMediaItems.add(requestedMediaItem)
                                     }
                                 }
 
-                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Returning ${updatedMediaItems.size} resolved media items")
+                                NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: Returning ${updatedMediaItems.size} resolved media items" }
                                 return Futures.immediateFuture(updatedMediaItems)
                             }
 
@@ -180,7 +183,7 @@ class MediaSessionManager(
                                 startPositionMs: Long,
                             ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> {
                                 // This is called when Android Auto wants to set and play media items
-                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: onSetMediaItems called with ${mediaItems.size} items, startIndex: $startIndex")
+                                NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: onSetMediaItems called with ${mediaItems.size} items, startIndex: $startIndex" }
 
                                 if (mediaItems.isEmpty()) {
                                     return Futures.immediateFuture(
@@ -195,7 +198,7 @@ class MediaSessionManager(
                                 try {
                                     // Get the first item's mediaId to determine the playlist
                                     val firstMediaId = mediaItems[0].mediaId
-                                    NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: First mediaId: $firstMediaId")
+                                    NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: First mediaId: $firstMediaId" }
 
                                     // Parse mediaId format: "playlistId:trackId"
                                     if (firstMediaId.contains(':')) {
@@ -203,7 +206,7 @@ class MediaSessionManager(
                                         val playlistId = firstMediaId.substring(0, colonIndex)
                                         val trackId = firstMediaId.substring(colonIndex + 1)
 
-                                        NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Loading full playlist: $playlistId, starting at track: $trackId")
+                                        NitroPlayerLogger.log("MediaSessionManager") { "🎵 MediaSessionManager: Loading full playlist: $playlistId, starting at track: $trackId" }
 
                                         // Get the full playlist
                                         val playlist = playlistManager.getPlaylist(playlistId)
@@ -223,7 +226,7 @@ class MediaSessionManager(
                                                             createMediaItem(track, trackMediaId)
                                                         }.toMutableList()
 
-                                                NitroPlayerLogger.log("MediaSessionManager", "✅ MediaSessionManager: Loaded ${playlistMediaItems.size} tracks, starting at index $trackIndex")
+                                                NitroPlayerLogger.log("MediaSessionManager") { "✅ MediaSessionManager: Loaded ${playlistMediaItems.size} tracks, starting at index $trackIndex" }
 
                                                 // Return the full playlist with the correct start index
                                                 return Futures.immediateFuture(
@@ -241,7 +244,7 @@ class MediaSessionManager(
                                         }
                                     }
                                 } catch (e: Exception) {
-                                    NitroPlayerLogger.log("MediaSessionManager", "❌ MediaSessionManager: Error in onSetMediaItems - ${e.message}")
+                                    NitroPlayerLogger.log("MediaSessionManager") { "❌ MediaSessionManager: Error in onSetMediaItems - ${e.message}" }
                                     e.printStackTrace()
                                 }
 
@@ -283,7 +286,7 @@ class MediaSessionManager(
         if (artworkUrl.isNullOrEmpty()) return null
 
         // Check cache first
-        artworkCache[artworkUrl]?.let { return it }
+        artworkCache.get(artworkUrl)?.let { return it }
 
         return try {
             val bitmap =
@@ -293,7 +296,7 @@ class MediaSessionManager(
                 }
             // Cache the bitmap
             if (bitmap != null) {
-                artworkCache[artworkUrl] = bitmap
+                artworkCache.put(artworkUrl, bitmap)
             }
             bitmap
         } catch (e: Exception) {
@@ -302,12 +305,6 @@ class MediaSessionManager(
         }
     }
 
-    private fun bitmapToByteArray(bitmap: Bitmap): ByteArray {
-        val stream = java.io.ByteArrayOutputStream()
-        bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
-        return stream.toByteArray()
-    }
-
     private fun createNotificationChannel() {
         notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -342,10 +339,12 @@ class MediaSessionManager(
         // Find track in current playlist or all playlists
         return trackPlayerCore?.getCurrentPlaylistId()?.let { playlistId ->
             playlistManager.getPlaylist(playlistId)?.tracks?.find { it.id == trackId }
-        } ?: playlistManager
-            .getAllPlaylists()
-            .flatMap { it.tracks }
-            .find { it.id == trackId }
+        } ?: run {
+            for (playlist in playlistManager.getAllPlaylists()) {
+                playlist.tracks.find { it.id == trackId }?.let { return it }
+            }
+            null
+        }
     }
 
     private fun updateNotification() {
@@ -392,7 +391,7 @@ class MediaSessionManager(
                     .setShowActionsInCompactView(0, 1, 2),
             )
         } catch (e: Exception) {
-            NitroPlayerLogger.log("MediaSessionManager", "Failed to set media session token: ${e.message}")
+            NitroPlayerLogger.log("MediaSessionManager") { "Failed to set media session token: ${e.message}" }
         }
 
         // Add action buttons
@@ -483,7 +482,7 @@ class MediaSessionManager(
         hideNotification()
         mediaSession?.release()
         mediaSession = null
-        artworkCache.clear()
+        artworkCache.evictAll()
     }
 
     private fun createMediaItem(
@@ -501,7 +500,7 @@ class MediaSessionManager(
             try {
                 metadataBuilder.setArtworkUri(Uri.parse(artworkUrl))
             } catch (e: Exception) {
-                NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Invalid artwork URI: $artworkUrl")
+                NitroPlayerLogger.log("MediaSessionManager") { "⚠️ MediaSessionManager: Invalid artwork URI: $artworkUrl" }
             }
         }
 

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

@@ -112,12 +112,8 @@ class PlaylistManager private constructor(
         description: String? = null,
         artwork: String? = null,
     ): Boolean {
-        val playlist =
-            synchronized(playlists) {
-                playlists[playlistId]
-            } ?: return false
-
         synchronized(playlists) {
+            val playlist = playlists[playlistId] ?: return false
             playlists[playlistId] =
                 playlist.copy(
                     name = name ?: playlist.name,
@@ -161,12 +157,8 @@ class PlaylistManager private constructor(
         track: TrackItem,
         index: Int? = null,
     ): Boolean {
-        val playlist =
-            synchronized(playlists) {
-                playlists[playlistId]
-            } ?: return false
-
         synchronized(playlists) {
+            val playlist = playlists[playlistId] ?: return false
             val tracks = playlist.tracks.toMutableList()
             if (index != null && index >= 0 && index <= tracks.size) {
                 tracks.add(index, track)
@@ -199,12 +191,8 @@ class PlaylistManager private constructor(
         tracks: List<TrackItem>,
         index: Int? = null,
     ): Boolean {
-        val playlist =
-            synchronized(playlists) {
-                playlists[playlistId]
-            } ?: return false
-
         synchronized(playlists) {
+            val playlist = playlists[playlistId] ?: return false
             val currentTracks = playlist.tracks.toMutableList()
             if (index != null && index >= 0 && index <= currentTracks.size) {
                 currentTracks.addAll(index, tracks)
@@ -236,13 +224,9 @@ class PlaylistManager private constructor(
         playlistId: String,
         trackId: String,
     ): Boolean {
-        val playlist =
-            synchronized(playlists) {
-                playlists[playlistId]
-            } ?: return false
-
         val removed =
             synchronized(playlists) {
+                val playlist = playlists[playlistId] ?: return false
                 val tracks = playlist.tracks.toMutableList()
                 val removed = tracks.removeAll { it.id == trackId }
                 if (removed) {
@@ -273,18 +257,13 @@ class PlaylistManager private constructor(
         trackId: String,
         newIndex: Int,
     ): Boolean {
-        val playlist =
-            synchronized(playlists) {
-                playlists[playlistId]
-            } ?: return false
-
-        val tracks = playlist.tracks.toMutableList()
-        val oldIndex = tracks.indexOfFirst { it.id == trackId }
-        if (oldIndex < 0 || newIndex < 0 || newIndex >= tracks.size) {
-            return false
-        }
-
         synchronized(playlists) {
+            val playlist = playlists[playlistId] ?: return false
+            val tracks = playlist.tracks.toMutableList()
+            val oldIndex = tracks.indexOfFirst { it.id == trackId }
+            if (oldIndex < 0 || newIndex < 0 || newIndex >= tracks.size) {
+                return false
+            }
             val track = tracks.removeAt(oldIndex)
             tracks.add(newIndex, track)
             playlists[playlistId] = playlist.copy(tracks = tracks)

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

@@ -13,7 +13,7 @@ class Queue {
     /**
      * Get all tracks in the queue
      */
-    fun getTracks(): List<TrackItem> = tracks.toList()
+    fun getTracks(): List<TrackItem> = ArrayList(tracks)
 
     /**
      * Get tracks as an array (for compatibility with existing API)

package/ios/core/TrackPlayerCore.swift

@@ -229,6 +229,7 @@ class TrackPlayerCore: NSObject {
 
     // Create boundary times at each interval
     var boundaryTimes: [NSValue] = []
+    boundaryTimes.reserveCapacity(Int(duration / interval) + 1)
     var time: Double = 0
     while time <= duration {
       let cmTime = CMTime(seconds: time, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
@@ -423,6 +424,7 @@ class TrackPlayerCore: NSObject {
       return
     }
 
+    #if DEBUG
     NitroPlayerLogger.log("TrackPlayerCore", "\n" + String(repeating: "▶", count: Constants.separatorLineLength))
     NitroPlayerLogger.log("TrackPlayerCore", "🔄 CURRENT ITEM CHANGED")
     NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "▶", count: Constants.separatorLineLength))
@@ -449,6 +451,7 @@ class TrackPlayerCore: NSObject {
     }
 
     NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "▶", count: Constants.separatorLineLength) + "\n")
+    #endif
 
     // Log item status
     NitroPlayerLogger.log("TrackPlayerCore", "📱 Item status: \(currentItem.status.rawValue)")
@@ -510,10 +513,12 @@ class TrackPlayerCore: NSObject {
         }
       } else {
         NitroPlayerLogger.log("TrackPlayerCore", "   ⚠️ Track ID '\(trackId)' NOT FOUND in currentTracks!")
+        #if DEBUG
         NitroPlayerLogger.log("TrackPlayerCore", "   Current tracks:")
         for (idx, track) in currentTracks.enumerated() {
           NitroPlayerLogger.log("TrackPlayerCore", "      [\(idx)] \(track.id) - \(track.title)")
         }
+        #endif
       }
     }
 
@@ -811,7 +816,8 @@ class TrackPlayerCore: NSObject {
 
   /// Clears preloaded assets that are no longer needed
   private func cleanupPreloadedAssets(keepingFrom currentIndex: Int) {
-    preloadQueue.async { [weak self] in
+    // Must run on main thread — preloadedAssets is only mutated on main
+    DispatchQueue.main.async { [weak self] in
       guard let self = self else { return }
 
       // Keep assets for current track and upcoming tracks within preload range
@@ -991,6 +997,25 @@ class TrackPlayerCore: NSObject {
     // Clear old preloaded assets when loading new queue
     preloadedAssets.removeAll()
 
+    // Replace current queue (player should always exist after setupPlayer)
+    guard let existingPlayer = self.player else {
+      NitroPlayerLogger.log("TrackPlayerCore", "❌ No player available")
+      return
+    }
+
+    // Always clear old items so a stale playlist doesn't keep playing.
+    NitroPlayerLogger.log("TrackPlayerCore", "🔄 Removing \(existingPlayer.items().count) old items from player")
+    existingPlayer.removeAllItems()
+
+    // Lazy-load mode: if any track has no URL yet, don't populate AVQueuePlayer items now.
+    // Adding downloaded tracks at incorrect positions would cause the wrong track to play.
+    // updateTracks will rebuild from the correct currentTrackIndex once URLs are resolved.
+    let isLazyLoad = tracks.contains { $0.url.isEmpty }
+    if isLazyLoad {
+      NitroPlayerLogger.log("TrackPlayerCore", "⏳ Lazy-load mode — player cleared, awaiting URL resolution")
+      return
+    }
+
     // Create gapless-optimized AVPlayerItems from tracks
     let items = tracks.enumerated().compactMap { (index, track) -> AVPlayerItem? in
       let isPreload = index < Constants.gaplessPreloadCount
@@ -1004,16 +1029,7 @@ class TrackPlayerCore: NSObject {
       return
     }
 
-    // Replace current queue (player should always exist after setupPlayer)
-    guard let existingPlayer = self.player else {
-      NitroPlayerLogger.log("TrackPlayerCore", "❌ No player available - this should never happen!")
-      return
-    }
-
-    NitroPlayerLogger.log("TrackPlayerCore", "🔄 Updating queue - removing \(existingPlayer.items().count) items, adding \(items.count) new items")
-
-    // Remove all existing items
-    existingPlayer.removeAllItems()
+    NitroPlayerLogger.log("TrackPlayerCore", "🔄 Adding \(items.count) new items to player")
 
     // Add new items IN ORDER
     // IMPORTANT: insert(after: nil) puts item at the start
@@ -1023,9 +1039,11 @@ class TrackPlayerCore: NSObject {
       existingPlayer.insert(item, after: lastItem)
       lastItem = item
 
+      #if DEBUG
       if let trackId = item.trackId, let track = tracks.first(where: { $0.id == trackId }) {
         NitroPlayerLogger.log("TrackPlayerCore", "  ➕ Added to player queue [\(index + 1)]: \(track.title)")
       }
+      #endif
     }
 
     #if DEBUG
@@ -1296,6 +1314,18 @@ class TrackPlayerCore: NSObject {
   private func skipToNextInternal() {
     guard let queuePlayer = self.player else { return }
 
+    // Lazy-load: AVQueuePlayer is empty because updatePlayerQueue deferred population.
+    // Delegate to playFromIndexInternal which handles both the has-URL (rebuild queue)
+    // and no-URL (defer + emit) cases correctly.
+    if queuePlayer.items().isEmpty && !currentTracks.isEmpty {
+      let nextIndex = currentTrackIndex + 1
+      if nextIndex < currentTracks.count {
+        _ = skipToIndexInternal(index: nextIndex)
+      }
+      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+      return
+    }
+
     // Remove current temp track from its list before advancing
     if let trackId = queuePlayer.currentItem?.trackId {
       if currentTemporaryType == .playNext {
@@ -1352,11 +1382,11 @@ class TrackPlayerCore: NSObject {
         }
       }
       // Go to current original track position (skip back from temp)
-      self.playFromIndex(index: self.currentTrackIndex)
+      self.rebuildQueueFromPlaylistIndex(index: self.currentTrackIndex)
     } else if self.currentTrackIndex > 0 {
       // Go to previous track in original playlist
       let previousIndex = self.currentTrackIndex - 1
-      self.playFromIndex(index: previousIndex)
+      self.rebuildQueueFromPlaylistIndex(index: previousIndex)
     } else {
       // Already at first track, restart it
       queuePlayer.seek(to: .zero)
@@ -1533,10 +1563,10 @@ class TrackPlayerCore: NSObject {
 
   func playFromIndex(index: Int) {
     if Thread.isMainThread {
-      playFromIndexInternal(index: index)
+      rebuildQueueFromPlaylistIndex(index: index)
     } else {
       DispatchQueue.main.async { [weak self] in
-        self?.playFromIndexInternal(index: index)
+        self?.rebuildQueueFromPlaylistIndex(index: index)
       }
     }
   }
@@ -1580,9 +1610,9 @@ class TrackPlayerCore: NSObject {
     let upNextEnd = upNextStart + effectiveUpNextSize
     let originalRemainingStart = upNextEnd
 
-    // Case 1: Target is before current - use playFromIndex on original
+    // Case 1: Target is before current - rebuild from that playlist index
     if index < currentPos {
-      playFromIndexInternal(index: index)
+      rebuildQueueFromPlaylistIndex(index: index)
       return true
     }
 
@@ -1645,7 +1675,7 @@ class TrackPlayerCore: NSObject {
       upNextQueue.removeAll()
       currentTemporaryType = .none
 
-      let result = playFromIndexInternalWithResult(index: originalIndex)
+      let result = rebuildQueueFromPlaylistIndex(index: originalIndex)
 
       // Check if upcoming tracks need URLs
       checkUpcomingTracksForUrls(lookahead: lookaheadCount)
@@ -1659,20 +1689,23 @@ class TrackPlayerCore: NSObject {
     return false
   }
 
-  private func playFromIndexInternal(index: Int) {
-    _ = playFromIndexInternalWithResult(index: index)
-  }
-
-  private func playFromIndexInternalWithResult(index: Int) -> Bool {
+  /// Clears temporary tracks, rebuilds AVQueuePlayer from `index` in the original playlist,
+  /// and resumes playback only if the player was already playing (preserves paused state).
+  @discardableResult
+  private func rebuildQueueFromPlaylistIndex(index: Int) -> Bool {
     guard index >= 0 && index < self.currentTracks.count else {
-      NitroPlayerLogger.log("TrackPlayerCore", "❌ playFromIndex - invalid index \(index), currentTracks.count = \(self.currentTracks.count)")
+      NitroPlayerLogger.log("TrackPlayerCore", "❌ rebuildQueueFromPlaylistIndex - invalid index \(index), currentTracks.count = \(self.currentTracks.count)")
       return false
     }
 
-    NitroPlayerLogger.log("TrackPlayerCore", "\n🎯 PLAY FROM INDEX \(index)")
+    NitroPlayerLogger.log("TrackPlayerCore", "\n🎯 REBUILD QUEUE FROM PLAYLIST INDEX \(index)")
     NitroPlayerLogger.log("TrackPlayerCore", "   Total tracks in playlist: \(self.currentTracks.count)")
     NitroPlayerLogger.log("TrackPlayerCore", "   Current index: \(self.currentTrackIndex), target index: \(index)")
 
+    // Preserve playback state — only resume if already playing.
+    // This prevents auto-starting when called during queue setup (e.g. loadPlaylist → skipToIndex).
+    let wasPlaying = self.player?.rate ?? 0 > 0
+
     // Clear temporary tracks when jumping to specific index
     self.playNextStack.removeAll()
     self.upNextQueue.removeAll()
@@ -1685,6 +1718,22 @@ class TrackPlayerCore: NSObject {
     // Update currentTrackIndex BEFORE updating queue
     self.currentTrackIndex = index
 
+    // Lazy-load guard: if the target track itself has no URL yet, the queue can't be built.
+    // Emit the track change now (so UI reflects the navigation) and defer queue population
+    // to updateTracks once URL resolution completes.
+    // Only check the target — other unresolved tracks elsewhere in the playlist shouldn't
+    // block a skip to a track that is already playable.
+    let isLazyLoad = fullPlaylist[index].url.isEmpty
+    if isLazyLoad {
+      NitroPlayerLogger.log("TrackPlayerCore", "   ⏳ Lazy-load — deferring AVQueuePlayer setup; emitting track change for index \(index)")
+      self.currentTracks = fullPlaylist
+      if let track = self.currentTracks[safe: index] {
+        notifyTrackChange(track, .skip)
+        self.mediaSessionManager?.onTrackChanged()
+      }
+      return true
+    }
+
     // Recreate the queue starting from the target index
     // This ensures all remaining tracks are in the queue
     let tracksToPlay = Array(fullPlaylist[index...])
@@ -1732,7 +1781,12 @@ class TrackPlayerCore: NSObject {
     // Start preloading upcoming tracks for gapless playback
     self.preloadUpcomingTracks(from: index + 1)
 
-    player.play()
+    // Only resume playback if the player was already playing before we rebuilt
+    // the loaded playlist. This prevents auto-starting when called during queue setup
+    // (e.g. loadPlaylist → skipToIndex).
+    if wasPlaying {
+      player.play()
+    }
     return true
   }
 
@@ -1813,7 +1867,7 @@ class TrackPlayerCore: NSObject {
     // Add playNext stack (LIFO - most recently added plays first)
     // Skip index 0 if current track is from playNext (it's already playing)
     if currentTemporaryType == .playNext && playNextStack.count > 1 {
-      newQueueTracks.append(contentsOf: Array(playNextStack.dropFirst()))
+      newQueueTracks.append(contentsOf: playNextStack.dropFirst())
     } else if currentTemporaryType != .playNext {
       newQueueTracks.append(contentsOf: playNextStack)
     }
@@ -1821,15 +1875,14 @@ class TrackPlayerCore: NSObject {
     // Add upNext queue (in order, FIFO)
     // Skip index 0 if current track is from upNext (it's already playing)
     if currentTemporaryType == .upNext && upNextQueue.count > 1 {
-      newQueueTracks.append(contentsOf: Array(upNextQueue.dropFirst()))
+      newQueueTracks.append(contentsOf: upNextQueue.dropFirst())
     } else if currentTemporaryType != .upNext {
       newQueueTracks.append(contentsOf: upNextQueue)
     }
 
     // Add remaining original tracks
     if currentTrackIndex + 1 < currentTracks.count {
-      let remainingOriginal = Array(currentTracks[(currentTrackIndex + 1)...])
-      newQueueTracks.append(contentsOf: remainingOriginal)
+      newQueueTracks.append(contentsOf: currentTracks[(currentTrackIndex + 1)...])
     }
 
     // Remove all items from player EXCEPT the currently playing one
@@ -1904,17 +1957,26 @@ class TrackPlayerCore: NSObject {
 
       NitroPlayerLogger.log("TrackPlayerCore", "🔄 updateTracks: \(tracks.count) updates")
 
-      // Get current track ID to avoid updating it (preserves gapless playback)
-      let currentTrackId = self.getCurrentTrack()?.id
+      // Get current track to decide how to handle it
+      let currentTrack = self.getCurrentTrack()
+      let currentTrackId = currentTrack?.id
+      let currentTrackIsEmpty = currentTrack?.url.isEmpty ?? false
 
       // Filter out current track and validate
       let safeTracks = tracks.filter { track in
         switch true {
-        case track.id == currentTrackId:
+        case 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)")
           return false
+        case track.id == currentTrackId && currentTrackIsEmpty:
+          // Empty URL — must not be playing, allow the update (only if the new URL is real)
+          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)")
@@ -1943,7 +2005,16 @@ class TrackPlayerCore: NSObject {
       // Update in PlaylistManager
       let affectedPlaylists = self.playlistManager.updateTracks(tracks: safeTracks)
 
-      // Rebuild queue if current playlist was affected
+      // 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]
       {
@@ -1951,12 +2022,36 @@ class TrackPlayerCore: NSObject {
           "TrackPlayerCore",
           "🔄 Rebuilding queue - \(updateCount) tracks updated in current playlist")
 
-        // This method preserves current item
-        self.rebuildAVQueueFromCurrentPosition()
+        // Sync currentTracks from the freshly-updated PlaylistManager so rebuilds use resolved URLs
+        if let updatedPlaylist = self.playlistManager.getPlaylist(playlistId: currentId) {
+          self.currentTracks = updatedPlaylist.tracks
+          NitroPlayerLogger.log("TrackPlayerCore", "📥 Synced currentTracks from PlaylistManager (\(self.currentTracks.count) tracks)")
+        }
 
-        // Re-preload upcoming tracks for gapless playback
-        // CRITICAL: This restores gapless buffering after queue rebuild
-        self.preloadUpcomingTracks(from: self.currentTrackIndex + 1)
+        if self.player?.currentItem == nil, let player = self.player {
+          // No AVPlayerItem exists yet — lazy-load mode: URLs were empty when the queue first
+          // loaded. Rebuild the full queue from currentTrackIndex now that URLs are resolved.
+          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[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()
+          // Re-preload upcoming tracks for gapless playback
+          // CRITICAL: This restores gapless buffering after queue rebuild
+          self.preloadUpcomingTracks(from: self.currentTrackIndex + 1)
+        }
 
         NitroPlayerLogger.log("TrackPlayerCore", "✅ Queue rebuilt, gapless playback preserved")
       }
@@ -2099,8 +2194,14 @@ class TrackPlayerCore: NSObject {
    * Call this in playerItemDidPlayToEndTime or after skip operations
    */
   private func checkUpcomingTracksForUrls(lookahead: Int = 5) {
-    let nextTracks = getNextTracksInternal(count: lookahead)
-    let tracksNeedingUrls = nextTracks.filter { $0.url.isEmpty }
+    let upcomingTracks = getNextTracksInternal(count: lookahead)
+
+    // Always include the current track if it has no URL — it can't play without one
+    let currentTrack = getCurrentTrack()
+    let currentNeedsUrl = currentTrack.map { $0.url.isEmpty } ?? false
+    let candidateTracks = currentNeedsUrl ? [currentTrack!] + upcomingTracks : upcomingTracks
+
+    let tracksNeedingUrls = candidateTracks.filter { $0.url.isEmpty }
 
     if !tracksNeedingUrls.isEmpty {
       NitroPlayerLogger.log(