react-native-queue-player 1.0.6 → 1.0.8

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

@@ -544,6 +544,7 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
   // simultaneously without clobbering each other.
   private val stateChangeListeners = ListenerRegistry<(PlayerState, StateChangeReason) -> Unit>()
   private val trackChangeListeners = ListenerRegistry<(TrackItem?, Double, TrackChangeReason, Double?) -> Unit>()
+  private val queueChangeListeners = ListenerRegistry<(Array<TrackItem>, Double, QueueChangeReason) -> Unit>()
   private val progressListeners = ListenerRegistry<(PlayerProgress) -> Unit>()
   // Buffer state — discrete empty/buffering/stalled/full for the active track, derived
   // from Media3's playback state + buffered-ahead. Recomputed on the engine
@@ -621,17 +622,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
@@ -1456,6 +1446,7 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     serviceBinder?.engine?.setWakeMode(pickWakeMode(newTracks))
     rescheduleLookahead()
     recomputeCapabilities()
+    emitQueueChange(QueueChangeReason.SET_QUEUE)
   }
 
   /**
@@ -1514,6 +1505,7 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     serviceBinder?.engine?.setWakeMode(pickWakeMode(newTracks))
     rescheduleLookahead()
     recomputeCapabilities()
+    emitQueueChange(QueueChangeReason.SET_QUEUE)
     return items
   }
 
@@ -1606,6 +1598,7 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     serviceBinder?.engine?.setWakeMode(pickWakeMode(this.tracks))
     rescheduleLookahead()
     recomputeCapabilities()
+    emitQueueChange(QueueChangeReason.ADD)
     return at
   }
 
@@ -1699,6 +1692,9 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     serviceBinder?.engine?.setWakeMode(pickWakeMode(this.tracks))
     rescheduleLookahead()
     recomputeCapabilities()
+    // Reached only past the `sanitised.isEmpty()` guard, so ≥1 track was
+    // removed; tracks + index are final.
+    emitQueueChange(QueueChangeReason.REMOVE)
     return sanitised
   }
 
@@ -1764,6 +1760,9 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     for (i in this.tracks.indices) retryAttemptsRemaining[i] = attempts
     rescheduleLookahead()
     recomputeCapabilities()
+    // Reached only past the invalid / `from == to` / pinned-current
+    // guards, so the order actually changed.
+    emitQueueChange(QueueChangeReason.MOVE)
     return true
   }
 
@@ -1782,6 +1781,7 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
   @VisibleForTesting
   internal fun clearQueueInternal() {
     val p = player ?: return
+    val queueWasNonEmpty = tracks.isNotEmpty()
     // Reset authoritative state BEFORE the ExoPlayer mutation.
     // `clearMediaItems()` fires `onMediaItemTransition(null,
     // REASON_PLAYLIST_CHANGED)` synchronously, which routes through
@@ -1799,6 +1799,11 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     retryAttemptsRemaining.clear()
     tracks = emptyList()
     currentTrackIndex = -1
+    // Fire queue-change BEFORE setMediaItems (which synchronously fires
+    // onTrackChange via onMediaItemTransition) so a `useQueue()` consumer
+    // sees the empty queue + index -1 together. Only when the queue was
+    // actually non-empty — clearing an empty queue is a no-op.
+    if (queueWasNonEmpty) emitQueueChange(QueueChangeReason.CLEAR)
     // Route through the engine surface (not directly through the
     // leading leg) so CrossfadeEngine can also tear down the
     // standby leg's preroll'd items + cancel any in-flight fade.
@@ -2241,21 +2246,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()
   }
 
@@ -2819,6 +2818,8 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
 
     rescheduleLookahead()
     recomputeCapabilities()
+    // Skip a single-track shuffle — the order can't change.
+    if (newTracks.size > 1) emitQueueChange(QueueChangeReason.SHUFFLE)
 
     return ShuffleResult(
       tracks = newTracks.toTypedArray(),
@@ -2909,6 +2910,27 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     return { trackChangeListeners.remove(id) }
   }
 
+  override fun onQueueChange(
+    callback: (queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason) -> Unit
+  ): () -> Unit {
+    val id = queueChangeListeners.add(callback)
+    return { queueChangeListeners.remove(id) }
+  }
+
+  /**
+   * Fire onQueueChange with an atomic snapshot of the post-mutation
+   * queue + current index. Main-thread only — every queue mutation
+   * commits on main, so [tracks] / [currentTrackIndex] are settled here.
+   * Callers gate this on an actual content/order change so a no-op
+   * mutation never emits.
+   */
+  @MainThread
+  private fun emitQueueChange(reason: QueueChangeReason) {
+    val snapshot = tracks.toTypedArray()
+    val index = currentTrackIndex.toDouble()
+    queueChangeListeners.forEach { it(snapshot, index, reason) }
+  }
+
   override fun onProgress(
     callback: (progress: PlayerProgress) -> Unit
   ): () -> Unit {
@@ -3460,6 +3482,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