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

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

@@ -41,6 +41,28 @@ class TrackPlayerCore private constructor(
     private val handler = android.os.Handler(android.os.Looper.getMainLooper())
     private lateinit var player: ExoPlayer
     private val playlistManager = PlaylistManager.getInstance(context)
+
+    // Named Runnable so handler.removeCallbacks() can coalesce rapid playlist
+    // mutations (e.g. N individual removes followed by a batch add during shuffle)
+    // into a single player update, preventing audio gaps on Android.
+    private val updateCurrentPlaylistRunnable = Runnable {
+        val playlistId = currentPlaylistId ?: return@Runnable
+        val playlist = playlistManager.getPlaylist(playlistId) ?: return@Runnable
+
+        // Always update the canonical track list first.
+        currentTracks = playlist.tracks
+
+        if (::player.isInitialized && player.currentMediaItem != null && player.currentMediaItemIndex >= 0) {
+            // Something is actively playing — rebuild only the items AFTER the
+            // current position using surgical removeMediaItems/addMediaItems.
+            // This avoids setMediaItems() which replaces the entire ExoPlayer
+            // queue (including the current item) and causes an audible gap.
+            rebuildQueueFromCurrentPosition()
+        } else {
+            // Nothing playing yet — safe to do a full replace.
+            updatePlayerQueue(playlist.tracks)
+        }
+    }
     private val downloadManager = DownloadManagerCore.getInstance(context)
     private val mediaLibraryManager = MediaLibraryManager.getInstance(context)
     private var mediaSessionManager: MediaSessionManager? = null
@@ -434,14 +456,13 @@ class TrackPlayerCore private constructor(
      * Update the player queue when playlist changes
      */
     fun updatePlaylist(playlistId: String) {
-        handler.post {
-            if (currentPlaylistId == playlistId) {
-                val playlist = playlistManager.getPlaylist(playlistId)
-                if (playlist != null) {
-                    updatePlayerQueue(playlist.tracks)
-                }
-            }
-        }
+        // Debounce: rapid back-to-back calls (e.g. removing N tracks then adding
+        // the shuffled replacement) are coalesced into a single setMediaItems call.
+        // removeCallbacks cancels any pending-but-not-yet-executed callback so only
+        // the final playlist state triggers a player rebuild.
+        if (currentPlaylistId != playlistId) return
+        handler.removeCallbacks(updateCurrentPlaylistRunnable)
+        handler.post(updateCurrentPlaylistRunnable)
     }
 
     /**
@@ -1180,6 +1201,20 @@ class TrackPlayerCore private constructor(
         val currentIndex = player.currentMediaItemIndex
         if (currentIndex < 0) return
 
+        // Handle removed-current-track case: if the currently playing media item is no longer
+        // in currentTracks (e.g. the user removed it while it was playing), delegate to
+        // playFromIndexInternal so the player immediately starts the next track.
+        val currentTrackId = player.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+        if (currentTrackId != null && currentTracks.none { it.id == currentTrackId }) {
+            val targetIndex = when {
+                currentTracks.isEmpty() -> return
+                currentTrackIndex < currentTracks.size -> currentTrackIndex
+                else -> currentTracks.size - 1
+            }
+            playFromIndexInternal(targetIndex)
+            return
+        }
+
         val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
 
         // Add playNext stack (LIFO - most recently added plays first)
@@ -1588,6 +1623,35 @@ class TrackPlayerCore private constructor(
             if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
                 NitroPlayerLogger.log("TrackPlayerCore") { "🔄 Rebuilding queue - ${affectedPlaylists[currentPlaylistId]} tracks updated in current playlist" }
 
+                // PlaylistManager.updateTracks() creates a new Playlist via .copy(tracks = newTracks),
+                // so our currentTracks reference still points at the old list with empty URLs.
+                // Refresh it now so rebuildQueueFromCurrentPosition builds MediaItems with the
+                // resolved URLs, allowing ExoPlayer to pre-buffer the next track for gapless playback.
+                val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
+                if (refreshedPlaylist != null) {
+                    currentTracks = refreshedPlaylist.tracks
+
+                    // Also reconcile any queued items that still reference old TrackItem instances
+                    // from this playlist, so that gapless pre-buffering uses tracks with resolved URLs.
+                    val updatedTrackById = currentTracks.associateBy { it.id }
+
+                    // Update playNextStack entries to point at the refreshed TrackItem objects.
+                    playNextStack.forEachIndexed { index, track ->
+                        val updated = updatedTrackById[track.id]
+                        if (updated != null && updated !== track) {
+                            playNextStack[index] = updated
+                        }
+                    }
+
+                    // Update upNextQueue entries to point at the refreshed TrackItem objects.
+                    upNextQueue.forEachIndexed { index, track ->
+                        val updated = updatedTrackById[track.id]
+                        if (updated != null && updated !== track) {
+                            upNextQueue[index] = updated
+                        }
+                    }
+                }
+
                 // This method preserves current item and gapless buffering
                 rebuildQueueFromCurrentPosition()
 

package/ios/core/TrackPlayerCore.swift

@@ -48,6 +48,10 @@ class TrackPlayerCore: NSObject {
   private var currentPlaylistId: String?
   private var currentTrackIndex: Int = -1
   private var currentTracks: [TrackItem] = []
+  // Debounce work item — rapid playlist mutations (e.g. N individual removes
+  // during shuffle) are coalesced into a single rebuildAVQueueFromCurrentPosition
+  // call, preventing audio gaps/interruptions on iOS.
+  private var pendingPlaylistUpdateWorkItem: DispatchWorkItem?
   private var isManuallySeeked = false
   private var currentRepeatMode: RepeatMode = .off
   private var lookaheadCount: Int = 5  // Number of tracks to preload ahead
@@ -649,7 +653,13 @@ class TrackPlayerCore: NSObject {
   }
 
   func updatePlaylist(playlistId: String) {
-    DispatchQueue.main.async { [weak self] in
+    guard currentPlaylistId == playlistId else { return }
+
+    // Cancel any pending rebuild so back-to-back calls (e.g. N individual removes
+    // during shuffle) collapse into a single rebuild at the end.
+    pendingPlaylistUpdateWorkItem?.cancel()
+
+    let workItem = DispatchWorkItem { [weak self] in
       guard let self = self else { return }
       guard self.currentPlaylistId == playlistId,
         let playlist = self.playlistManager.getPlaylist(playlistId: playlistId)
@@ -667,6 +677,9 @@ class TrackPlayerCore: NSObject {
       // Rebuild only the items after the currently playing item
       self.rebuildAVQueueFromCurrentPosition()
     }
+
+    pendingPlaylistUpdateWorkItem = workItem
+    DispatchQueue.main.async(execute: workItem)
   }
 
   // MARK: - Public Methods
@@ -1918,6 +1931,21 @@ class TrackPlayerCore: NSObject {
     let currentItem = player.currentItem
     let playingItems = player.items()
 
+    // ---- Handle removed-current-track case ----
+    // If the currently playing AVPlayerItem is no longer in currentTracks (e.g. the user
+    // removed it while it was playing), delegate to rebuildQueueFromPlaylistIndex so the
+    // player immediately starts what is now at currentTrackIndex in the updated list.
+    if let playingTrackId = currentItem?.trackId,
+      !currentTracks.contains(where: { $0.id == playingTrackId }) {
+      let targetIndex = currentTrackIndex < currentTracks.count
+        ? currentTrackIndex
+        : currentTracks.count - 1
+      if targetIndex >= 0 {
+        _ = rebuildQueueFromPlaylistIndex(index: targetIndex)
+      }
+      return
+    }
+
     // ---- Build the desired upcoming track list ----
 
     var newQueueTracks: [TrackItem] = []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.5.9-alpha.1",
+  "version": "0.6.1",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",