react-native-queue-player 1.0.6 → 1.0.7

package/android/src/main/java/com/margelo/nitro/queueplayer/AirPlayEngine.kt

@@ -243,6 +243,7 @@ internal class AirPlayEngine(
   override val bufferedPositionMs: Long get() = exoPlayer.bufferedPosition
   override val isPlaying: Boolean get() = exoPlayer.isPlaying
   override val currentMediaItem: MediaItem? get() = exoPlayer.currentMediaItem
+  override val isCrossfadeActive: Boolean get() = false
 
   override val allMediaItems: List<MediaItem>
     get() {

package/android/src/main/java/com/margelo/nitro/queueplayer/CrossfadeEngine.kt

@@ -753,6 +753,9 @@ internal class CrossfadeEngine(
   override val currentMediaItem: MediaItem?
     get() = activePlayer.currentMediaItem
 
+  override val isCrossfadeActive: Boolean
+    get() = fadeJob?.isActive == true
+
   override val allMediaItems: List<MediaItem>
     get() {
       val count = leadingPlayer.mediaItemCount

package/android/src/main/java/com/margelo/nitro/queueplayer/GaplessEngine.kt

@@ -373,6 +373,9 @@ internal class GaplessEngine(
   override val currentMediaItem: MediaItem?
     get() = exoPlayer.currentMediaItem
 
+  override val isCrossfadeActive: Boolean
+    get() = false
+
   override val allMediaItems: List<MediaItem>
     get() {
       val count = exoPlayer.mediaItemCount

package/android/src/main/java/com/margelo/nitro/queueplayer/MediaItemBuilder.kt

@@ -113,6 +113,19 @@ object MediaItemBuilder {
     return builder.build()
   }
 
+  /**
+   * Duration (ms) to write onto the current item's metadata for the API 33+
+   * System UI seekbar, or `null` to leave it untouched. A positive
+   * consumer-supplied duration wins; otherwise the decoded player duration is
+   * used; a non-positive player duration (unknown / live / `C.TIME_UNSET`,
+   * which is negative) yields `null`.
+   */
+  internal fun durationToBackfill(existingDurationMs: Long?, playerDurationMs: Long): Long? {
+    if (existingDurationMs != null && existingDurationMs > 0L) return null
+    if (playerDurationMs <= 0L) return null
+    return playerDurationMs
+  }
+
   /**
    * URI for the bundled placeholder artwork in `res/raw/`. Cached
    * per-process; the integer resource ID is package-stable at runtime

package/android/src/main/java/com/margelo/nitro/queueplayer/PlaybackEngine.kt

@@ -110,6 +110,14 @@ interface PlaybackEngine {
   val isPlaying: Boolean
   val currentMediaItem: MediaItem?
 
+  /**
+   * True while a crossfade volume ramp is in flight. Always `false` for
+   * [GaplessEngine]; [CrossfadeEngine] reports its live fade job. Callers
+   * that mutate the leading item (e.g. a metadata backfill) skip while this
+   * is true so they don't touch the outgoing leg mid-fade.
+   */
+  val isCrossfadeActive: Boolean
+
   /**
    * Snapshot of every queued [MediaItem]. Called rarely (engine swap,
    * diagnostic dumps); impl may allocate. The canonical queue model

package/android/src/main/java/com/margelo/nitro/queueplayer/PlaybackService.kt

@@ -307,10 +307,9 @@ class PlaybackService : HeadlessJsMediaService() {
     override fun mediaButtonDispatch() = this@PlaybackService.mediaButtonDispatch
 
     override fun playerCommandsFor(
-      capability: SkipCapability,
-      hasMediaItems: Boolean
+      capability: SkipCapability
     ): Player.Commands =
-      this@PlaybackService.playerCommandsFor(capability, hasMediaItems)
+      this@PlaybackService.playerCommandsFor(capability)
 
     override fun onHeadlessControllerConnect(packageName: String) {
       // Cold-wake the JS bridge so the consumer's
@@ -471,15 +470,9 @@ class PlaybackService : HeadlessJsMediaService() {
     internal fun refreshAvailableCommands() {
       val handler = commandHandler ?: return
       val session = mediaSession ?: return
-      // The cap is global — same Player.Commands for every controller.
-      // `hasMediaItems` reads from the live player so a freshly-empty
-      // queue strips PLAY/PAUSE/PREPARE from the action mask and AA's
-      // dashboard tap routes to Library instead of an empty Now Playing.
-      val hasMediaItems = session.player.mediaItemCount > 0
-      val commands = playerCommandsFor(
-        handler.getCachedSkipCapability(),
-        hasMediaItems
-      )
+      // The cap is global — same Player.Commands for every controller;
+      // only the four skip commands flip with the queue boundary.
+      val commands = playerCommandsFor(handler.getCachedSkipCapability())
       for (controller in session.connectedControllers) {
         session.setAvailableCommands(
           controller,
@@ -1603,38 +1596,9 @@ class PlaybackService : HeadlessJsMediaService() {
    * from `DEFAULT_PLAYER_COMMANDS`.
    */
   internal fun playerCommandsFor(
-    capability: SkipCapability,
-    hasMediaItems: Boolean
+    capability: SkipCapability
   ): Player.Commands {
     val builder = MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
-    if (!hasMediaItems) {
-      // Empty queue → strip every command that contributes to the
-      // legacy `PlaybackStateCompat` action mask's PLAY-related bits.
-      // Android Auto's dashboard-tap launch heuristic reads that mask:
-      // STATE_NONE alone is not enough — the action mask must also
-      // carry no ACTION_PLAY / ACTION_PLAY_PAUSE / ACTION_PREPARE.
-      // Once both are zero, AA lands on the Library/Browse surface
-      // instead of "Now Playing — To play something, tap the icon at
-      // the top left."
-      //
-      // This rides Media3 1.10.0's internal Player.Commands →
-      // PlaybackStateCompat action-mask translation, which is not a public
-      // contract — re-validate on a Media3 upgrade. Unit tests cover the
-      // command-strip input; the resulting action mask is verified on the
-      // Android Auto lane, since the legacy bridge only populates for a
-      // connected controller that can't be driven under Robolectric.
-      builder.remove(Player.COMMAND_PLAY_PAUSE)
-      builder.remove(Player.COMMAND_PREPARE)
-      builder.remove(Player.COMMAND_STOP)
-      builder.remove(Player.COMMAND_SEEK_BACK)
-      builder.remove(Player.COMMAND_SEEK_FORWARD)
-      builder.remove(Player.COMMAND_SEEK_TO_DEFAULT_POSITION)
-      builder.remove(Player.COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM)
-      builder.remove(Player.COMMAND_SEEK_TO_MEDIA_ITEM)
-      builder.remove(Player.COMMAND_SET_SHUFFLE_MODE)
-      builder.remove(Player.COMMAND_SET_REPEAT_MODE)
-      builder.remove(Player.COMMAND_SET_SPEED_AND_PITCH)
-    }
     if (!capability.canSkipNext) {
       builder.remove(Player.COMMAND_SEEK_TO_NEXT)
       builder.remove(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM)

package/android/src/main/java/com/margelo/nitro/queueplayer/PlaybackServiceCallback.kt

@@ -56,17 +56,13 @@ internal class PlaybackServiceCallback(
     fun mediaButtonDispatch(): MediaButtonDispatch?
 
     /** Translate the lib's queue state into the [Player.Commands] set
-     *  controllers should see. The skip pair greys out skip buttons
-     *  that the repeat-mode + queue-position arithmetic disallows;
-     *  `hasMediaItems = false` additionally strips play / pause /
-     *  prepare so that the legacy `PlaybackStateCompat` action mask
-     *  carries no PLAY bit. That signal is what makes Android Auto's
-     *  dashboard tap route to the Library/Browse surface instead of
-     *  the empty "Now Playing — To play something" fallback when the
-     *  queue is empty. */
+     *  controllers should see. Only the skip pair greys out (the
+     *  repeat-mode + queue-position arithmetic disallows it); every
+     *  other command — play/pause, seek, etc. — is preserved so the
+     *  API 33+ System UI derives the play/pause button + the draggable
+     *  seek scrubber from the session's transport commands. */
     fun playerCommandsFor(
-      capability: SkipCapability,
-      hasMediaItems: Boolean
+      capability: SkipCapability
     ): Player.Commands
 
     /** Invoked when a controller from a known headless-eligible
@@ -317,12 +313,8 @@ internal class PlaybackServiceCallback(
       )
     val handler = environment.commandHandler()
     if (handler != null) {
-      val hasMediaItems = session.player.mediaItemCount > 0
       builder.setAvailablePlayerCommands(
-        environment.playerCommandsFor(
-          handler.getCachedSkipCapability(),
-          hasMediaItems
-        )
+        environment.playerCommandsFor(handler.getCachedSkipCapability())
       )
     }
     return builder.build()

package/android/src/main/java/com/margelo/nitro/queueplayer/TrackPlayer.kt

@@ -621,17 +621,6 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
   // `emitStateIfChanged` re-label the resulting PAUSED emit as 'sleep-timer'.
   private var pendingSleepTimerPause = false
 
-  /**
-   * Tracks the most recently published "queue has any media items"
-   * state so [recomputeCapabilities] can detect empty→non-empty
-   * transitions even when the skip-capability pair didn't change
-   * (e.g. setQueue replaces an empty queue with a single-track list:
-   * skip pair stays `(false, false)` but the action mask must flip
-   * to include PLAY again). Initial `false` matches the empty queue
-   * the lib starts with.
-   */
-  private var lastHasMediaItemsReported: Boolean = false
-
   /**
    * Cached classification of the active track's playback source.
    * Recomputed in [handleMediaItemTransition] whenever the active
@@ -2241,21 +2230,15 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     val current = cachedSkipCapability
     val capChanged =
       newPrev != current.canSkipPrevious || newNext != current.canSkipNext
-    val hasMediaItems = count > 0
-    val emptyStateChanged = hasMediaItems != lastHasMediaItemsReported
-    if (!capChanged && !emptyStateChanged) return
-    lastHasMediaItemsReported = hasMediaItems
+    if (!capChanged) return
     val snapshot = SkipCapability(
       canSkipPrevious = newPrev, canSkipNext = newNext)
     cachedSkipCapability = snapshot
-    if (capChanged) skipCapabilityListeners.forEach { it(snapshot) }
-    // Push the new capability into MediaSession.setAvailableCommands
-    // for every connected controller so external surfaces (lock-
-    // screen, Bluetooth AVRCP, Auto, Wear) grey out skip buttons
-    // that the queue boundary makes invalid, and so the PLAY-bit
-    // strip from `playerCommandsFor(_, hasMediaItems=false)` reaches
-    // gearhead the moment the queue empties (and re-appears the
-    // moment a new queue is set).
+    skipCapabilityListeners.forEach { it(snapshot) }
+    // Push the new capability into MediaSession.setAvailableCommands for
+    // every connected controller so external surfaces (lock-screen,
+    // Bluetooth AVRCP, Android Auto, Wear) grey out skip buttons that the
+    // queue boundary makes invalid.
     serviceBinder?.refreshAvailableCommands()
   }
 
@@ -3460,6 +3443,33 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
 
   override fun onActiveItemFormatChanged(engine: PlaybackEngine) {
     refreshNowPlayingFormatForActiveItem()
+    backfillActiveItemDurationIfNeeded(engine)
+  }
+
+  /**
+   * Write `METADATA_KEY_DURATION` onto the current item from the player's
+   * decoded duration when the consumer didn't supply one, so the API 33+
+   * System UI seekbar has a real total time. One-shot per item — once the
+   * item carries a positive duration, [MediaItemBuilder.durationToBackfill]
+   * returns null, so re-fires (and the `onTracksChanged` re-entrancy the
+   * `replaceMediaItem` triggers) are no-ops. Skipped mid-crossfade so the
+   * outgoing leg isn't rewritten during a fade; the incoming item backfills
+   * once it becomes leading and this callback re-fires. Main thread.
+   */
+  @MainThread
+  private fun backfillActiveItemDurationIfNeeded(engine: PlaybackEngine) {
+    if (engine.isCrossfadeActive) return
+    val p = player ?: return
+    val idx = p.currentMediaItemIndex
+    if (idx < 0) return
+    val item = p.currentMediaItem ?: return
+    val dur = MediaItemBuilder.durationToBackfill(
+      item.mediaMetadata.durationMs, p.duration
+    ) ?: return
+    val updated = item.buildUpon()
+      .setMediaMetadata(item.mediaMetadata.buildUpon().setDurationMs(dur).build())
+      .build()
+    p.replaceMediaItem(idx, updated)
   }
 
   override fun onError(engine: PlaybackEngine, exception: PlaybackException) {

package/android/src/test/java/com/margelo/nitro/queueplayer/EqualizerKtTest.kt

@@ -259,6 +259,7 @@ private class FakePlaybackEngine : PlaybackEngine {
   override val bufferedPositionMs: Long get() = error("not used in test")
   override val isPlaying: Boolean get() = error("not used in test")
   override val currentMediaItem: androidx.media3.common.MediaItem? get() = error("not used in test")
+  override val isCrossfadeActive: Boolean get() = false
   override val allMediaItems: List<androidx.media3.common.MediaItem> get() = error("not used in test")
   override fun currentAudioSessionIds(): IntArray = IntArray(0)
   override fun addAudioSessionIdListener(listener: (IntArray) -> Unit): () -> Unit {

package/android/src/test/java/com/margelo/nitro/queueplayer/MediaItemBuilderTest.kt

@@ -1,6 +1,7 @@
 package com.margelo.nitro.queueplayer
 
 import android.content.Context
+import androidx.media3.common.C
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.util.UnstableApi
 import androidx.test.core.app.ApplicationProvider
@@ -366,6 +367,41 @@ class MediaItemBuilderTest {
   private val context: Context
     get() = ApplicationProvider.getApplicationContext()
 
+  // --- durationToBackfill: the System UI seekbar duration derivation decision
+
+  @Test
+  fun `durationToBackfill keeps a positive consumer duration and never overwrites`() {
+    assertNull(
+      MediaItemBuilder.durationToBackfill(existingDurationMs = 42_000L, playerDurationMs = 50_000L),
+    )
+  }
+
+  @Test
+  fun `durationToBackfill derives from the player when the consumer supplied none`() {
+    assertEquals(
+      180_000L,
+      MediaItemBuilder.durationToBackfill(existingDurationMs = null, playerDurationMs = 180_000L),
+    )
+  }
+
+  @Test
+  fun `durationToBackfill treats a non-positive existing duration as absent`() {
+    assertEquals(
+      180_000L,
+      MediaItemBuilder.durationToBackfill(existingDurationMs = 0L, playerDurationMs = 180_000L),
+    )
+  }
+
+  @Test
+  fun `durationToBackfill skips a live or not-yet-decoded player duration`() {
+    assertNull(
+      MediaItemBuilder.durationToBackfill(existingDurationMs = null, playerDurationMs = C.TIME_UNSET),
+    )
+    assertNull(
+      MediaItemBuilder.durationToBackfill(existingDurationMs = null, playerDurationMs = 0L),
+    )
+  }
+
   private fun makeTrack(
     id: String,
     url: String,

package/android/src/test/java/com/margelo/nitro/queueplayer/PlaybackEngineInterfaceTest.kt

@@ -106,6 +106,7 @@ class PlaybackEngineInterfaceTest {
     override val bufferedPositionMs: Long = 0
     override val isPlaying: Boolean = false
     override val currentMediaItem: MediaItem? = null
+    override val isCrossfadeActive: Boolean = false
     override val allMediaItems: List<MediaItem> = emptyList()
 
     override fun currentAudioSessionIds(): IntArray = IntArray(0)

package/android/src/test/java/com/margelo/nitro/queueplayer/PlaybackServiceCallbackBrowseTest.kt

@@ -278,10 +278,9 @@ class PlaybackServiceCallbackBrowseTest {
       override fun commandHandler() = null
       override fun mediaButtonDispatch() = null
       override fun playerCommandsFor(
-        capability: SkipCapability,
-        hasMediaItems: Boolean
+        capability: SkipCapability
       ): Player.Commands =
-        service.playerCommandsFor(capability, hasMediaItems)
+        service.playerCommandsFor(capability)
       override fun onBrowseRequestForChildren(
         parentId: String
       ): ListenableFuture<List<BrowseItem>> = Futures.immediateFuture(resolved)
@@ -309,10 +308,9 @@ class PlaybackServiceCallbackBrowseTest {
       override fun commandHandler() = null
       override fun mediaButtonDispatch() = null
       override fun playerCommandsFor(
-        capability: SkipCapability,
-        hasMediaItems: Boolean
+        capability: SkipCapability
       ): Player.Commands =
-        service.playerCommandsFor(capability, hasMediaItems)
+        service.playerCommandsFor(capability)
       override fun onBrowseRequestForChildren(
         parentId: String
       ): ListenableFuture<List<BrowseItem>> = Futures.immediateFuture(resolved)
@@ -438,10 +436,9 @@ class PlaybackServiceCallbackBrowseTest {
       override fun commandHandler() = null
       override fun mediaButtonDispatch() = null
       override fun playerCommandsFor(
-        capability: SkipCapability,
-        hasMediaItems: Boolean
+        capability: SkipCapability
       ): Player.Commands =
-        service.playerCommandsFor(capability, hasMediaItems)
+        service.playerCommandsFor(capability)
       override fun onHeadlessControllerConnect(packageName: String) {
         called = packageName
       }
@@ -462,10 +459,9 @@ class PlaybackServiceCallbackBrowseTest {
       override fun commandHandler() = null
       override fun mediaButtonDispatch() = null
       override fun playerCommandsFor(
-        capability: SkipCapability,
-        hasMediaItems: Boolean
+        capability: SkipCapability
       ): Player.Commands =
-        service.playerCommandsFor(capability, hasMediaItems)
+        service.playerCommandsFor(capability)
       override fun onHeadlessControllerConnect(packageName: String) {
         called = packageName
       }

package/android/src/test/java/com/margelo/nitro/queueplayer/PlaybackServiceCallbackSearchTest.kt

@@ -68,10 +68,9 @@ class PlaybackServiceCallbackSearchTest {
       override fun commandHandler() = null
       override fun mediaButtonDispatch() = null
       override fun playerCommandsFor(
-        capability: SkipCapability,
-        hasMediaItems: Boolean
+        capability: SkipCapability
       ): Player.Commands =
-        service.playerCommandsFor(capability, hasMediaItems)
+        service.playerCommandsFor(capability)
       override fun onSearchQueryReceived(query: String) {
         received.add(query)
       }

package/android/src/test/java/com/margelo/nitro/queueplayer/PlaybackServiceCallbackTest.kt

@@ -227,8 +227,7 @@ class PlaybackServiceCallbackTest {
   @Test
   fun `playerCommandsFor strips both skips when capability disallows both`() {
     val commands = service.playerCommandsFor(
-      SkipCapability(canSkipPrevious = false, canSkipNext = false),
-      hasMediaItems = true
+      SkipCapability(canSkipPrevious = false, canSkipNext = false)
     )
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -243,23 +242,21 @@ class PlaybackServiceCallbackTest {
   }
 
   @Test
-  fun `playerCommandsFor strips PLAY-related commands when queue is empty`() {
-    // Empty queue → action mask must carry no ACTION_PLAY bits so
-    // AA's dashboard tap routes to Library rather than Now Playing.
+  fun `playerCommandsFor keeps transport commands when queue is empty`() {
+    // Transport commands stay available so the API 33+ System UI keeps the
+    // play/pause button + the draggable seek scrubber; only the skip pair
+    // greys out with the queue boundary.
     val commands = service.playerCommandsFor(
-      SkipCapability(canSkipPrevious = false, canSkipNext = false),
-      hasMediaItems = false
+      SkipCapability(canSkipPrevious = false, canSkipNext = false)
     )
-    assertFalse(
-      "PLAY_PAUSE drives the legacy ACTION_PLAY bit; must be absent on empty queue",
+    assertTrue(
+      "play/pause is retained for the System UI play/pause button",
       commands.contains(Player.COMMAND_PLAY_PAUSE)
     )
-    assertFalse(commands.contains(Player.COMMAND_PREPARE))
-    assertFalse(commands.contains(Player.COMMAND_STOP))
-    assertFalse(commands.contains(Player.COMMAND_SEEK_TO_DEFAULT_POSITION))
-    assertFalse(commands.contains(Player.COMMAND_SET_SPEED_AND_PITCH))
-    assertFalse(commands.contains(Player.COMMAND_SET_REPEAT_MODE))
-    assertFalse(commands.contains(Player.COMMAND_SET_SHUFFLE_MODE))
+    assertTrue(commands.contains(Player.COMMAND_PREPARE))
+    assertTrue(commands.contains(Player.COMMAND_SEEK_TO_DEFAULT_POSITION))
+    assertTrue(commands.contains(Player.COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM))
+    assertTrue(commands.contains(Player.COMMAND_SET_SPEED_AND_PITCH))
   }
 
   @Test
@@ -342,7 +339,7 @@ class PlaybackServiceCallbackTest {
       // The handler's value is what `PlaybackCallback.onConnect` reads,
       // so a fresh `onConnect` against any session sharing this handler
       // sees the post-flip command set.
-      val playerCommands = service.playerCommandsFor(mid, hasMediaItems = true)
+      val playerCommands = service.playerCommandsFor(mid)
       assertTrue(playerCommands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
       assertFalse(playerCommands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
     } finally {
@@ -876,10 +873,9 @@ class PlaybackServiceCallbackTest {
     override fun mediaButtonDispatch(): MediaButtonDispatch? = null
 
     override fun playerCommandsFor(
-      capability: SkipCapability,
-      hasMediaItems: Boolean
+      capability: SkipCapability
     ): Player.Commands =
-      service.playerCommandsFor(capability, hasMediaItems)
+      service.playerCommandsFor(capability)
 
     override fun onPlayFromSearchRequest(
       request: MediaSearchRequest

package/android/src/test/java/com/margelo/nitro/queueplayer/PlayerCommandsForTest.kt

@@ -65,7 +65,6 @@ class PlayerCommandsForTest {
   fun `commands include every skip pair when capability allows both`() {
     val commands = service.playerCommandsFor(
       SkipCapability(canSkipPrevious = true, canSkipNext = true),
-      hasMediaItems = true,
     )
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -78,7 +77,6 @@ class PlayerCommandsForTest {
   fun `commands omit only the next pair when capability disallows skip-next`() {
     val commands = service.playerCommandsFor(
       SkipCapability(canSkipPrevious = true, canSkipNext = false),
-      hasMediaItems = true,
     )
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -91,7 +89,6 @@ class PlayerCommandsForTest {
   fun `commands omit only the previous pair when capability disallows skip-previous`() {
     val commands = service.playerCommandsFor(
       SkipCapability(canSkipPrevious = false, canSkipNext = true),
-      hasMediaItems = true,
     )
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -104,7 +101,6 @@ class PlayerCommandsForTest {
   fun `commands omit both skip pairs when capability disallows both`() {
     val commands = service.playerCommandsFor(
       SkipCapability(canSkipPrevious = false, canSkipNext = false),
-      hasMediaItems = true,
     )
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -119,7 +115,6 @@ class PlayerCommandsForTest {
   fun `repeat OFF at index 0 of a two-track queue exposes only skip-next`() {
     val commands = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.OFF, count = 2, current = 0),
-      hasMediaItems = true,
     )
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
@@ -129,7 +124,6 @@ class PlayerCommandsForTest {
   fun `repeat OFF at the last index of a two-track queue exposes only skip-previous`() {
     val commands = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.OFF, count = 2, current = 1),
-      hasMediaItems = true,
     )
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
     assertTrue(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
@@ -139,7 +133,6 @@ class PlayerCommandsForTest {
   fun `repeat OFF on a single-track queue exposes neither skip command`() {
     val commands = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.OFF, count = 1, current = 0),
-      hasMediaItems = true,
     )
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
     assertFalse(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
@@ -149,15 +142,12 @@ class PlayerCommandsForTest {
   fun `repeat QUEUE wraps so both skip commands stay enabled at every queue position`() {
     val first = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.QUEUE, count = 3, current = 0),
-      hasMediaItems = true,
     )
     val mid = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.QUEUE, count = 3, current = 1),
-      hasMediaItems = true,
     )
     val last = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.QUEUE, count = 3, current = 2),
-      hasMediaItems = true,
     )
     for (commands in listOf(first, mid, last)) {
       assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
@@ -170,7 +160,6 @@ class PlayerCommandsForTest {
     // First track of 2: next available, no previous (no wrap).
     val atFirst = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.TRACK, count = 2, current = 0),
-      hasMediaItems = true,
     )
     assertTrue(atFirst.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
     assertFalse(atFirst.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
@@ -178,31 +167,33 @@ class PlayerCommandsForTest {
     // Last track of 2: previous available, no next (no wrap).
     val atLast = service.playerCommandsFor(
       capabilityFor(repeat = QueueSkipRepeatMode.TRACK, count = 2, current = 1),
-      hasMediaItems = true,
     )
     assertFalse(atLast.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
     assertTrue(atLast.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
   }
 
   @Test
-  fun `empty queue exposes neither skip command regardless of repeat mode`() {
+  fun `empty queue disables skip but keeps transport commands for the System UI`() {
     for (mode in QueueSkipRepeatMode.entries) {
       val commands = service.playerCommandsFor(
         capabilityFor(repeat = mode, count = 0, current = -1),
-        hasMediaItems = false,
       )
       assertFalse(
-        "skip-next is always disabled with no tracks (repeat=$mode)",
+        "skip-next is disabled with no tracks (repeat=$mode)",
         commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM),
       )
       assertFalse(
-        "skip-previous is always disabled with no tracks (repeat=$mode)",
+        "skip-previous is disabled with no tracks (repeat=$mode)",
         commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM),
       )
-      assertFalse(
-        "PLAY_PAUSE is stripped on empty queue so AA lands on Library (repeat=$mode)",
+      assertTrue(
+        "play/pause is retained so the API 33+ System UI keeps the button (repeat=$mode)",
         commands.contains(Player.COMMAND_PLAY_PAUSE),
       )
+      assertTrue(
+        "in-item seek is retained so the seek scrubber stays draggable (repeat=$mode)",
+        commands.contains(Player.COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM),
+      )
     }
   }
 

package/android/src/test/java/com/margelo/nitro/queueplayer/VisualizerKtTest.kt

@@ -187,6 +187,7 @@ private class FakePlaybackEngineWithSinks : PlaybackEngine {
   override val bufferedPositionMs: Long get() = error("not used in test")
   override val isPlaying: Boolean get() = error("not used in test")
   override val currentMediaItem: androidx.media3.common.MediaItem? get() = error("not used in test")
+  override val isCrossfadeActive: Boolean get() = false
   override val allMediaItems: List<androidx.media3.common.MediaItem> get() = error("not used in test")
   override fun currentAudioSessionIds(): IntArray = IntArray(0)
   override fun addAudioSessionIdListener(listener: (IntArray) -> Unit): () -> Unit = { /* noop */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-queue-player",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Nitro Modules audio playback library for React Native — gapless, EQ, crossfade, automotive, voice, casting",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/index.d.ts",