react-native-queue-player 1.0.4 → 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/NotificationProvider.kt

@@ -18,6 +18,12 @@ import androidx.media3.session.DefaultMediaNotificationProvider
  * `setMediaButtonPreferences(...)` builder call; this provider reads
  * those preferences directly.
  *
+ * This provider only pins the channel + notification id — it does NOT
+ * restyle transport buttons. On API 33+ the System UI media control is
+ * derived from the media session, so `MediaNotification.Provider` layout
+ * changes take effect only pre-33; transport customization belongs in the
+ * session's available commands + media button preferences, never here.
+ *
  * Artwork loading is wired separately on the [androidx.media3.session.MediaSession]
  * via `setBitmapLoader(...)` — the provider routes artwork requests
  * through that loader chain

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,
@@ -788,20 +781,18 @@ class PlaybackService : HeadlessJsMediaService() {
     )
 
   /**
-   * The compact notification view shows three buttons in priority
-   * order: prev / play-pause / next. Media3 1.9+ resolves these from
-   * standard player commands set via [CommandButton.Builder.setPlayerCommand]
-   * — no custom command handlers required. The expanded view shows
-   * the same three buttons plus the scrub progress bar that
-   * `DefaultMediaNotificationProvider` adds automatically when the
-   * session reports a known duration.
+   * The back + forward buttons for the notification compact view and the
+   * Android Auto control row. Play/pause is intentionally NOT supplied:
+   * Media3 owns the central slot (`CommandButton.SLOT_CENTRAL`) and
+   * synthesizes a state-aware play/pause from `COMMAND_PLAY_PAUSE`. A
+   * caller-supplied central button is dropped on the notification path
+   * (`DefaultMediaNotificationProvider` builds its own play/pause) and on
+   * Android Auto forces a static, non-toggling icon — so supplying only
+   * back/forward lets Media3 render the toggling play/pause on both
+   * surfaces. The expanded view adds the scrub progress bar automatically
+   * when the session reports a known duration.
    */
   private fun buildMediaButtonPreferences(): List<CommandButton> {
-    val playPause = CommandButton.Builder(CommandButton.ICON_PLAY)
-      .setPlayerCommand(Player.COMMAND_PLAY_PAUSE)
-      .setSlots(CommandButton.SLOT_CENTRAL)
-      .setDisplayName(getString(R.string.rnqp_action_play_pause))
-      .build()
     // In `interval` mode the back/forward slots jump within the current track
     // (COMMAND_SEEK_BACK / COMMAND_SEEK_FORWARD, honored by
     // [SessionCommandForwardingPlayer] with the runtime interval); in `track`
@@ -813,7 +804,6 @@ class PlaybackService : HeadlessJsMediaService() {
           .setSlots(CommandButton.SLOT_BACK)
           .setDisplayName(getString(R.string.rnqp_action_jump_backward))
           .build(),
-        playPause,
         CommandButton.Builder(CommandButton.ICON_SKIP_FORWARD)
           .setPlayerCommand(Player.COMMAND_SEEK_FORWARD)
           .setSlots(CommandButton.SLOT_FORWARD)
@@ -826,7 +816,6 @@ class PlaybackService : HeadlessJsMediaService() {
           .setSlots(CommandButton.SLOT_BACK)
           .setDisplayName(getString(R.string.rnqp_action_previous))
           .build(),
-        playPause,
         CommandButton.Builder(CommandButton.ICON_NEXT)
           .setPlayerCommand(Player.COMMAND_SEEK_TO_NEXT)
           .setSlots(CommandButton.SLOT_FORWARD)
@@ -1607,31 +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."
-      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)
@@ -1646,11 +1613,11 @@ class PlaybackService : HeadlessJsMediaService() {
   /**
    * Hook the [PlaybackCallback] consults before letting Media3 route
    * a controller-initiated command to the bound player. Calls run on
-   * the service main looper. Skip-next / skip-previous return true
-   * when the implementation has handled the skip itself, so the
-   * default routing is suppressed; the transport hook fires for play /
-   * pause / seek / setPlaybackSpeed and is purely a side-channel
-   * notification (no return value).
+   * the service main looper. Skip-next / skip-previous / seek-to-queue-item
+   * return true when the implementation has handled the command itself,
+   * so the default routing is suppressed; the transport hook fires for
+   * play / pause / in-item seek / setPlaybackSpeed and is purely a
+   * side-channel notification (no return value).
    */
   internal interface MediaSessionCommandHandler {
     /** Stamps `system` on the state-change channel for the upcoming
@@ -1662,6 +1629,12 @@ class PlaybackService : HeadlessJsMediaService() {
     /** Returns true if the lib intercepted the skip and the default
      *  routing should be suppressed. */
     fun onSkipToPreviousCommand(): Boolean
+    /** Routes an external controller's tap on a queue row (Android Auto's
+     *  "seek to this item") through the lib's `skipToIndex` path so the
+     *  canonical current index + track-change reason land. Returns true
+     *  when handled so the default per-item seek is suppressed; returns
+     *  false for an out-of-range index so the default routing no-ops it. */
+    fun onSeekToMediaItemCommand(mediaItemIndex: Int): Boolean
 
     /**
      * Returns the lib's current authoritative skip capability —

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()
@@ -368,6 +360,14 @@ internal class PlaybackServiceCallback(
     return dispatch.handle(intent, RemoteCommandDeduper.Channel.SESSION_KEY)
   }
 
+  /**
+   * Cold-start playback resumption: a hardware / Bluetooth media button that
+   * wakes the service while nothing is loaded. Returns an empty queue by
+   * design — the lib does not reconstruct a queue here; a consumer that wants
+   * resume-from-cold restores its own queue on launch via `setQueue`. The
+   * override exists (rather than being omitted) because Media3 requires a
+   * declared `MediaButtonReceiver` to pair with an `onPlaybackResumption`.
+   */
   override fun onPlaybackResumption(
     mediaSession: MediaSession,
     controller: MediaSession.ControllerInfo,

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

@@ -89,6 +89,15 @@ internal class SessionCommandForwardingPlayer(
       Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM ->
         if (commandHandler()?.onSkipToPreviousCommand() == true) Futures.immediateVoidFuture()
         else super.handleSeek(mediaItemIndex, positionMs, seekCommand)
+      // Android Auto's queue-row tap. A raw per-item seek would move the
+      // player without updating the lib's canonical current index — the
+      // SEEK transition handler only syncs the index for player-originated
+      // transitions, not controller seeks. Route through the skip path so
+      // the index + track-change reason land; an index the lib declines
+      // (out of range) falls through to the default seek.
+      Player.COMMAND_SEEK_TO_MEDIA_ITEM ->
+        if (commandHandler()?.onSeekToMediaItemCommand(mediaItemIndex) == true) Futures.immediateVoidFuture()
+        else super.handleSeek(mediaItemIndex, positionMs, seekCommand)
       // Interval-skip mode: recompute the target with the runtime jump interval
       // rather than the wrapped player's build-time seek increment, so the value
       // is adjustable at runtime.

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
@@ -991,6 +980,25 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
         return true
       }
 
+      override fun onSeekToMediaItemCommand(mediaItemIndex: Int): Boolean {
+        // Decline an out-of-range index so the default per-item seek
+        // no-ops it (Media3 passes C.INDEX_UNSET when the seek implies
+        // no move).
+        if (mediaItemIndex < 0 || mediaItemIndex >= tracks.size) return false
+        pendingStateChangeReason = StateChangeReason.SYSTEM
+        // Same path as the public skipToIndex: jump the receiver while
+        // casting, else the local engine. Both write currentTrackIndex +
+        // the USER_SKIP_TO_INDEX reason that a raw controller seek skips.
+        // The tapped track starts at position 0 — the controller's
+        // positionMs is intentionally not threaded through, matching the
+        // public skipToIndex "play this track" contract.
+        if (com.margelo.nitro.queueplayer.cast.CastTransportRouter.routeSkipToIndex(mediaItemIndex)) {
+          return true
+        }
+        skipToIndexInternal(mediaItemIndex)
+        return true
+      }
+
       override fun onMediaPlay() {
         pendingStateChangeReason = StateChangeReason.SYSTEM
         serviceBinder?.engine?.play()
@@ -2222,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()
   }
 
@@ -3441,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/main/res/values/strings.xml

@@ -11,9 +11,6 @@
        transport button. Shown by TalkBack and by pre-Media3 controllers
        that read the platform PlaybackStateCompat custom-action name. -->
   <string name="rnqp_action_previous">Previous</string>
-  <!-- Accessibility / legacy-controller label for the play-pause
-       transport button. -->
-  <string name="rnqp_action_play_pause">Play or pause</string>
   <!-- Accessibility / legacy-controller label for the next-track
        transport button. -->
   <string name="rnqp_action_next">Next</string>

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

@@ -252,6 +252,7 @@ class AvrcpMetadataTest {
     override fun onTransportCommand() {}
     override fun onSkipToNextCommand(): Boolean = false
     override fun onSkipToPreviousCommand(): Boolean = false
+    override fun onSeekToMediaItemCommand(mediaItemIndex: Int): Boolean = false
     override fun getCachedSkipCapability(): SkipCapability = capability
     override fun onMediaPlay() {}
     override fun onMediaPause() {}

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/MediaButtonDispatchTest.kt

@@ -179,6 +179,7 @@ class MediaButtonDispatchTest {
     override fun onTransportCommand() { transportCalls++ }
     override fun onSkipToNextCommand(): Boolean { skipNextCmdCalls++; return true }
     override fun onSkipToPreviousCommand(): Boolean { skipPreviousCmdCalls++; return true }
+    override fun onSeekToMediaItemCommand(mediaItemIndex: Int): Boolean = false
     override fun getCachedSkipCapability(): SkipCapability =
       SkipCapability(canSkipPrevious = true, canSkipNext = true)
     override fun onMediaPlay() { playCalls++ }

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

@@ -0,0 +1,99 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Intent
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.CommandButton
+import androidx.media3.session.MediaSession
+import androidx.test.core.app.ApplicationProvider
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.android.controller.ServiceController
+import org.robolectric.annotation.Config
+
+/**
+ * Robolectric coverage for the media button preferences the notification
+ * compact view + Android Auto control row consume, produced by
+ * [PlaybackService.buildMediaButtonPreferences] and read back off the
+ * session's public `mediaButtonPreferences`.
+ *
+ * The lib supplies only the back / forward buttons. Play/pause belongs to
+ * Media3's central slot: `DefaultMediaNotificationProvider` synthesizes a
+ * state-aware play/pause from `COMMAND_PLAY_PAUSE`, and Android Auto fills
+ * the empty central slot the same way — so a lib-supplied `SLOT_CENTRAL`
+ * button is dropped on the notification and forces a static, non-toggling
+ * icon on Android Auto.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class MediaButtonPreferencesTest {
+
+  private lateinit var controller: ServiceController<PlaybackService>
+  private lateinit var service: PlaybackService
+  private lateinit var session: MediaSession
+
+  @Before
+  fun setUp() {
+    controller = Robolectric.buildService(PlaybackService::class.java).create()
+    service = controller.get()
+    val intent = Intent(
+      ApplicationProvider.getApplicationContext<android.content.Context>(),
+      PlaybackService::class.java,
+    ).setAction(PlaybackService.ACTION_LOCAL_BIND)
+    val binder = service.onBind(intent) as PlaybackService.LocalBinder
+    session = binder.session
+  }
+
+  @After
+  fun tearDown() {
+    controller.destroy()
+  }
+
+  @Test
+  fun `track mode supplies previous plus next and leaves play-pause to Media3`() {
+    service.applyRemoteControls(RemoteSkipMode.TRACK, 15_000L, 15_000L)
+    val prefs = session.mediaButtonPreferences
+    assertNoLibPlayPause(prefs)
+    assertTrue(
+      "previous occupies the back slot",
+      prefs.any { it.slots.contains(CommandButton.SLOT_BACK) },
+    )
+    assertTrue(
+      "next occupies the forward slot",
+      prefs.any { it.slots.contains(CommandButton.SLOT_FORWARD) },
+    )
+  }
+
+  @Test
+  fun `interval mode supplies skip-back plus skip-forward and leaves play-pause to Media3`() {
+    service.applyRemoteControls(RemoteSkipMode.INTERVAL, 15_000L, 10_000L)
+    val prefs = session.mediaButtonPreferences
+    assertNoLibPlayPause(prefs)
+    assertTrue(
+      "skip-back occupies the back slot",
+      prefs.any { it.slots.contains(CommandButton.SLOT_BACK) },
+    )
+    assertTrue(
+      "skip-forward occupies the forward slot",
+      prefs.any { it.slots.contains(CommandButton.SLOT_FORWARD) },
+    )
+  }
+
+  private fun assertNoLibPlayPause(prefs: List<CommandButton>) {
+    assertFalse(
+      "play/pause is Media3's central-slot button, never supplied by the lib",
+      prefs.any { it.playerCommand == Player.COMMAND_PLAY_PAUSE },
+    )
+    assertFalse(
+      "the lib never claims SLOT_CENTRAL — Media3 owns it",
+      prefs.any { it.slots.contains(CommandButton.SLOT_CENTRAL) },
+    )
+  }
+}

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
       }