react-native-queue-player 1.2.0 → 2.0.1

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

@@ -0,0 +1,189 @@
+package com.margelo.nitro.queueplayer
+
+import android.net.Uri
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.HttpDataSource
+import androidx.media3.datasource.TransferListener
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * A response that is a document rather than media fails before any of its bytes
+ * are returned, so neither cache write path — the prefetcher's `CacheWriter` nor
+ * the playback read path's own sink — ever sees them.
+ *
+ * `android.net.Uri` is a framework type, so this runs under Robolectric like
+ * every other test here that parses one.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class MediaValidatingDataSourceTest {
+
+  /** An HTTP source that answers with fixed headers and a fixed body. */
+  private class FakeHttpSource(
+    private val body: ByteArray,
+    private val contentType: String?,
+    /** Bytes to hand back per read, so a body arriving in dribs is covered. */
+    private val chunk: Int = Int.MAX_VALUE
+  ) : HttpDataSource {
+    private var position = 0
+    var readCount = 0
+      private set
+
+    override fun open(dataSpec: DataSpec): Long {
+      position = dataSpec.position.toInt()
+      return (body.size - position).toLong()
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+      readCount += 1
+      if (position >= body.size) return -1
+      val take = minOf(length, chunk, body.size - position)
+      body.copyInto(buffer, offset, position, position + take)
+      position += take
+      return take
+    }
+
+    override fun getUri(): Uri = Uri.parse("https://example.com/track")
+    override fun close() {}
+    override fun addTransferListener(transferListener: TransferListener) {}
+    override fun getResponseHeaders(): Map<String, List<String>> =
+      if (contentType == null) emptyMap() else mapOf("Content-Type" to listOf(contentType))
+
+    override fun setRequestProperty(name: String, value: String) {}
+    override fun clearRequestProperty(name: String) {}
+    override fun clearAllRequestProperties() {}
+    override fun getResponseCode(): Int = 200
+  }
+
+  /** A non-HTTP source, which carries no declared type and is passed through. */
+  private class FakeLocalSource(private val body: ByteArray) : DataSource {
+    private var position = 0
+    override fun open(dataSpec: DataSpec): Long = body.size.toLong()
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+      if (position >= body.size) return -1
+      val take = minOf(length, body.size - position)
+      body.copyInto(buffer, offset, position, position + take)
+      position += take
+      return take
+    }
+    override fun getUri(): Uri = Uri.parse("file:///track.mp3")
+    override fun close() {}
+    override fun addTransferListener(transferListener: TransferListener) {}
+  }
+
+  private val xmlEnvelope =
+    """<api-response status="failed"><error code="70"/></api-response>""".toByteArray()
+  private val mp3 = byteArrayOf(0x49, 0x44, 0x33, 0x04, 0, 0, 0, 0) + ByteArray(120)
+
+  private fun openAndRead(
+    source: DataSource,
+    position: Long = 0L,
+    uri: String = "https://example.com/track"
+  ): ByteArray {
+    source.open(DataSpec.Builder().setUri(uri).setPosition(position).build())
+    val out = ArrayList<Byte>()
+    val buffer = ByteArray(32)
+    while (true) {
+      val read = source.read(buffer, 0, buffer.size)
+      if (read == -1) break
+      for (i in 0 until read) out.add(buffer[i])
+    }
+    return out.toByteArray()
+  }
+
+  @Test
+  fun aDeclaredDocumentFailsBeforeAnythingIsRead() {
+    val upstream = FakeHttpSource(xmlEnvelope, "application/xml")
+    val source = MediaValidatingDataSource(upstream)
+    try {
+      source.open(DataSpec(Uri.parse("https://example.com/track")))
+      fail("a declared document must not open")
+    } catch (e: HttpDataSource.HttpDataSourceException) {
+      assertEquals(PlaybackException.ERROR_CODE_IO_INVALID_HTTP_CONTENT_TYPE, e.reason)
+    }
+    assertEquals("nothing may be read from a refused response", 0, upstream.readCount)
+  }
+
+  @Test
+  fun anUndeclaredMarkupBodyFailsOnTheFirstRead() {
+    val source = MediaValidatingDataSource(FakeHttpSource(xmlEnvelope, null))
+    source.open(DataSpec(Uri.parse("https://example.com/track")))
+    try {
+      source.read(ByteArray(32), 0, 32)
+      fail("a markup body must not be returned")
+    } catch (e: HttpDataSource.HttpDataSourceException) {
+      assertEquals(PlaybackException.ERROR_CODE_IO_INVALID_HTTP_CONTENT_TYPE, e.reason)
+    }
+  }
+
+  @Test
+  fun plainTextWithNoContainerSignatureFailsOnTheFirstRead() {
+    val source = MediaValidatingDataSource(FakeHttpSource("not found".toByteArray(), "text/plain"))
+    source.open(DataSpec(Uri.parse("https://example.com/track")))
+    try {
+      source.read(ByteArray(32), 0, 32)
+      fail("text with no container signature must not be returned")
+    } catch (e: HttpDataSource.HttpDataSourceException) {
+      assertEquals(PlaybackException.ERROR_CODE_IO_INVALID_HTTP_CONTENT_TYPE, e.reason)
+    }
+  }
+
+  @Test
+  fun mediaIsPassedThroughWhole() {
+    val source = MediaValidatingDataSource(FakeHttpSource(mp3, "audio/mpeg"))
+    assertArrayEquals("every byte reaches the caller unchanged", mp3, openAndRead(source))
+  }
+
+  @Test
+  fun mediaArrivingInSmallChunksIsStillPassedThroughWhole() {
+    val source = MediaValidatingDataSource(FakeHttpSource(mp3, "audio/mpeg", chunk = 3))
+    assertArrayEquals(mp3, openAndRead(source))
+  }
+
+  @Test
+  fun aRangedRequestIsJudgedOnItsDeclaredTypeOnly() {
+    // The served window opens with `<`, so the leading-byte rule would refuse it
+    // if it were applied. A body read from an offset says nothing about the
+    // resource's first bytes, so it is not.
+    val markupAtOffset = "....<api-response/>".toByteArray()
+    val ranged = MediaValidatingDataSource(
+      FakeHttpSource(markupAtOffset, "application/octet-stream")
+    )
+    val read = openAndRead(ranged, position = 4L)
+    assertTrue("a partial body is not judged by its first byte", read.isNotEmpty())
+
+    // The same bytes as the whole resource are refused — which is what shows the
+    // acceptance above turns on the range and not on the bytes.
+    val whole = MediaValidatingDataSource(
+      FakeHttpSource("<api-response/>".toByteArray(), "application/octet-stream")
+    )
+    whole.open(DataSpec(Uri.parse("https://example.com/track")))
+    try {
+      whole.read(ByteArray(32), 0, 32)
+      fail("the same markup read from the start of the resource must be refused")
+    } catch (e: HttpDataSource.HttpDataSourceException) {
+      assertEquals(PlaybackException.ERROR_CODE_IO_INVALID_HTTP_CONTENT_TYPE, e.reason)
+    }
+  }
+
+  @Test
+  fun aLocalSourceIsPassedThroughUnjudged() {
+    val source = MediaValidatingDataSource(FakeLocalSource(xmlEnvelope))
+    assertArrayEquals(
+      "a file:// source is not fetched from a server and is not the case this guards",
+      xmlEnvelope,
+      openAndRead(source, uri = "file:///track.mp3")
+    )
+  }
+}

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

@@ -4,7 +4,10 @@ import androidx.media3.common.Format
 import androidx.media3.common.MimeTypes
 import androidx.media3.common.util.UnstableApi
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Rule
 import org.junit.Test
+import org.junit.rules.TemporaryFolder
 
 /**
  * Pure-mapping coverage for [NowPlayingFormatExtractor]. These
@@ -14,6 +17,48 @@ import org.junit.Test
 @UnstableApi
 class NowPlayingFormatExtractorTest {
 
+  @get:Rule
+  val tempFolder = TemporaryFolder()
+
+  /**
+   * FLAC declares no bitrate, so Media3 reports NO_VALUE for it on local files
+   * as well as remote. For a file on disk the average is arithmetic — encoded
+   * bytes over playing time — which is the same derivation iOS uses.
+   */
+  @Test
+  fun averageBitrateIsBytesOverPlayingTime() {
+    val file = tempFolder.newFile("track.flac")
+    file.writeBytes(ByteArray(1_000_000))
+
+    // 1,000,000 bytes over 40 s = 8,000,000 bits / 40 = 200 kbps.
+    assertEquals(
+      200_000.0,
+      NowPlayingFormatExtractor.averageBitrateOf(file.absolutePath, 40.0)!!,
+      0.001
+    )
+  }
+
+  /**
+   * Every input that would make the answer invented rather than measured
+   * yields null: the player has not resolved a duration yet, the duration is
+   * nonsense, the path is absent, or the file has no bytes.
+   */
+  @Test
+  fun averageBitrateIsNullWhenItCannotBeMeasured() {
+    val file = tempFolder.newFile("track.flac")
+    file.writeBytes(ByteArray(1_000))
+
+    assertNull(NowPlayingFormatExtractor.averageBitrateOf(file.absolutePath, null))
+    assertNull(NowPlayingFormatExtractor.averageBitrateOf(file.absolutePath, 0.0))
+    assertNull(NowPlayingFormatExtractor.averageBitrateOf(file.absolutePath, -5.0))
+    assertNull(NowPlayingFormatExtractor.averageBitrateOf(null, 40.0))
+    assertNull(
+      NowPlayingFormatExtractor.averageBitrateOf(
+        tempFolder.newFile("empty.flac").absolutePath, 40.0))
+    assertNull(
+      NowPlayingFormatExtractor.averageBitrateOf("/nonexistent/nope.flac", 40.0))
+  }
+
   @Test
   fun mapCodecCoversAACAliases() {
     assertEquals(AudioCodec.AAC, NowPlayingFormatExtractor.mapCodec(MimeTypes.AUDIO_AAC))

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

@@ -60,7 +60,7 @@ class PitchAwareAudioProcessorChainTest {
 
   @Test
   fun `signalsmith stays active on the float path even when not stretching`() {
-    // The fix for Media3's static pipeline: Signalsmith must remain in the
+    // Media3's pipeline is static: Signalsmith must remain in the
     // active set regardless of mode/speed so it can stretch when music kicks in.
     val chain = newConfiguredChain()
     chain.setMode(PitchCorrectionMode.VOICE)

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

@@ -7,8 +7,16 @@ import androidx.media3.session.LibraryResult
 import androidx.media3.session.MediaLibraryService
 import androidx.media3.session.MediaSession
 import androidx.test.core.app.ApplicationProvider
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
@@ -167,4 +175,43 @@ class PlaybackServiceCallbackSearchTest {
       result.params
     )
   }
+
+  // --- dispatchSearchToJs
+
+  // `Dispatchers.setMain` is the only way to see which dispatcher the notify
+  // lands on; `notifySearchResultChanged` has no other observable effect with
+  // no controller connected.
+  @OptIn(ExperimentalCoroutinesApi::class)
+  @Test
+  fun `dispatchSearchToJs caches the answer then notifies on main`() {
+    // A Nitro Promise is JNI-constructed and cannot exist on the JVM, so
+    // the only JS answer reachable here is a throwing handler; that path
+    // still writes the cache and still notifies, which is the contract a
+    // connected controller depends on to stop waiting.
+    val mainDispatches = AtomicInteger(0)
+    val dispatched = CountDownLatch(1)
+    val recording = object : kotlinx.coroutines.CoroutineDispatcher() {
+      override fun dispatch(context: kotlin.coroutines.CoroutineContext, block: Runnable) {
+        mainDispatches.incrementAndGet()
+        dispatched.countDown()
+        android.os.Handler(android.os.Looper.getMainLooper()).post(block)
+      }
+    }
+    Dispatchers.setMain(recording)
+    try {
+      service.browseCallbacks.registerOnSearchRequest { _ ->
+        throw IllegalStateException("no Nitro runtime under Robolectric")
+      }
+      assertFalse(service.searchResultCache.hasResults("rock"))
+
+      service.dispatchSearchToJs("rock")
+
+      assertTrue("the notify reached a dispatcher", dispatched.await(2, TimeUnit.SECONDS))
+      org.robolectric.Shadows.shadowOf(android.os.Looper.getMainLooper()).idle()
+      assertEquals("notify is dispatched to main", 1, mainDispatches.get())
+      assertEquals(emptyList<BrowseItem>(), service.searchResultCache.getResults("rock"))
+    } finally {
+      Dispatchers.resetMain()
+    }
+  }
 }

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

@@ -259,19 +259,6 @@ class PlaybackServiceCallbackTest {
     assertTrue(commands.contains(Player.COMMAND_SET_SPEED_AND_PITCH))
   }
 
-  @Test
-  fun `refreshAvailableCommands is a no-op when no handler is registered`() {
-    // No handler, no controllers — exercising the early return.
-    binder.refreshAvailableCommands()
-    // Re-issue with a handler but no connected controllers — also a no-op.
-    binder.setCommandHandler(RecordingHandler())
-    binder.refreshAvailableCommands()
-    // The per-controller iteration body (session.setAvailableCommands)
-    // requires a live MediaController that has completed handshake,
-    // which is not reachable from Robolectric without standing up a
-    // full MediaController.Builder.buildAsync() flow.
-  }
-
   // --- TrackPlayer-side handler implementation
 
   @Test
@@ -291,8 +278,8 @@ class PlaybackServiceCallbackTest {
     val player = newConfiguredPlayer()
     try {
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 0
 
@@ -326,8 +313,8 @@ class PlaybackServiceCallbackTest {
 
       // Two-track queue at index 0 — skip-next now allowed.
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 0
       player.recomputeCapabilities()
@@ -352,8 +339,8 @@ class PlaybackServiceCallbackTest {
     val player = newConfiguredPlayer()
     try {
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 1
 
@@ -377,9 +364,9 @@ class PlaybackServiceCallbackTest {
     val player = newConfiguredPlayer()
     try {
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
-        TrackItem("c", "https://example.com/c.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("c", "https://example.com/c.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 0
 
@@ -404,8 +391,8 @@ class PlaybackServiceCallbackTest {
     val player = newConfiguredPlayer()
     try {
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 1
 
@@ -426,8 +413,8 @@ class PlaybackServiceCallbackTest {
     val player = newConfiguredPlayer()
     try {
       player.tracks = listOf(
-        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null),
-        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null),
+        TrackItem("a", "https://example.com/a.m4a", null, null, null, null, null, null, null, null, null, null),
+        TrackItem("b", "https://example.com/b.m4a", null, null, null, null, null, null, null, null, null, null),
       )
       player.currentTrackIndex = 1
 
@@ -444,6 +431,35 @@ class PlaybackServiceCallbackTest {
 
   // --- Voice / browse-leaf routing through onAddMediaItems / onSetMediaItems
 
+  @Test
+  fun `onAddMediaItems asks for append and onSetMediaItems does not`() {
+    val fakeEnv = RecordingEnvironment(service)
+    val routingCallback = PlaybackServiceCallback(fakeEnv)
+    fakeEnv.idResolution = listOf(
+      MediaItem.Builder().setMediaId("resolved")
+        .setUri("https://example.com/resolved.m4a".toUri()).build()
+    )
+    fun idOnlyItem() = MediaItem.Builder().setMediaId("album:1").build()
+
+    routingCallback.onAddMediaItems(
+      session, controllerInfo, mutableListOf(idOnlyItem())
+    ).get()
+    // "Queue up X" grows the queue; Media3 appends what the resolution
+    // returns, so the lib's own queue has to grow by the same amount rather
+    // than being replaced by the new tracks alone.
+    assertEquals(listOf(true), fakeEnv.idAppendFlags)
+
+    fakeEnv.idAppendFlags.clear()
+    routingCallback.onSetMediaItems(
+      session, controllerInfo, mutableListOf(idOnlyItem()), 0, 0L
+    ).get()
+    // A browse-leaf tap is a genuine replace: it takes the no-sync route,
+    // where the JS handler's own `setQueue` is the only writer, so no
+    // append-flagged request reaches the environment at all.
+    assertEquals(listOf("album:1"), fakeEnv.idRequestsNoSync)
+    assertEquals(emptyList<Boolean>(), fakeEnv.idAppendFlags)
+  }
+
   @Test
   fun `onAddMediaItems with searchQuery dispatches to onPlayFromSearchRequest`() {
     val fakeEnv = RecordingEnvironment(service)
@@ -783,7 +799,8 @@ class PlaybackServiceCallbackTest {
         networkTimeoutMs = null,
         audioContentType = null,
         audioCategoryOptions = null,
-        visualizationEnabled = null,
+        voiceVocabularyDonationEnabled = null,
+      visualizationEnabled = null,
         clampSeekToBuffered = null,
       lookaheadCacheMaxSizeMb = null, lookaheadCacheEvictionPolicy = null, progressUpdateIntervalMs = null, backgroundProgressUpdateIntervalMs = null, placeholderArtworkUri = null, skipToPreviousBehavior = null,
       ),
@@ -878,19 +895,26 @@ class PlaybackServiceCallbackTest {
       service.playerCommandsFor(capability)
 
     override fun onPlayFromSearchRequest(
-      request: MediaSearchRequest
+      request: MediaSearchRequest,
+      append: Boolean
     ): ListenableFuture<List<MediaItem>> {
       searchRequests += request
+      searchAppendFlags += append
       return Futures.immediateFuture(searchResolution)
     }
 
     override fun onPlayFromIdRequest(
-      mediaId: String
+      mediaId: String,
+      append: Boolean
     ): ListenableFuture<List<MediaItem>> {
       idRequests += mediaId
+      idAppendFlags += append
       return Futures.immediateFuture(idResolution)
     }
 
+    val searchAppendFlags = mutableListOf<Boolean>()
+    val idAppendFlags = mutableListOf<Boolean>()
+
     override fun onPlayFromIdRequestNoSync(mediaId: String) {
       idRequestsNoSync += mediaId
     }

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

@@ -49,19 +49,19 @@ class PlaybackServiceLifecycleTest {
     val controller = Robolectric.buildService(PlaybackService::class.java).create()
     try {
       val binder = bindLocal(controller.get())
-      assertNotNull("binder.player is initialised in onCreate", binder.player)
+      assertNotNull("the engine's player is initialised in onCreate", binder.engine.mediaSessionPlayer)
       assertNotNull("binder.session is initialised in onCreate", binder.session)
       // The session binds to the stable SessionCommandForwardingPlayer
       // wrapper for its lifetime; the wrapper forwards to the engine's
-      // ExoPlayer the binder exposes.
+      // own ExoPlayer.
       val sessionPlayer = binder.session.player
       assertTrue(
         "binder.session.player is the stable forwarding wrapper",
         sessionPlayer is SessionCommandForwardingPlayer,
       )
       assertSame(
-        "the wrapper forwards to the ExoPlayer instance the binder exposes",
-        binder.player,
+        "the wrapper forwards to the engine's ExoPlayer instance",
+        binder.engine.mediaSessionPlayer,
         (sessionPlayer as SessionCommandForwardingPlayer).wrappedPlayer,
       )
       assertEquals(
@@ -173,8 +173,8 @@ class PlaybackServiceLifecycleTest {
       val binder = bindLocal(service)
       // A loaded + play-ready session: the previous behaviour kept the service
       // alive here. Swipe-away is now an unconditional kill.
-      binder.player.addMediaItem(MediaItem.fromUri("http://example.com/a.mp3"))
-      binder.player.playWhenReady = true
+      binder.engine.mediaSessionPlayer.addMediaItem(MediaItem.fromUri("http://example.com/a.mp3"))
+      binder.engine.mediaSessionPlayer.playWhenReady = true
       shadowOf(Looper.getMainLooper()).idle()
 
       service.onTaskRemoved(null)
@@ -183,7 +183,7 @@ class PlaybackServiceLifecycleTest {
       assertEquals(
         "the player is stopped (idle) on swipe-away",
         Player.STATE_IDLE,
-        binder.player.playbackState,
+        binder.engine.mediaSessionPlayer.playbackState,
       )
       assertTrue(
         "the service stops even with a queued, play-ready session",
@@ -198,7 +198,7 @@ class PlaybackServiceLifecycleTest {
   fun `onDestroy releases the player and clears the session`() {
     val controller = Robolectric.buildService(PlaybackService::class.java).create()
     val binder = bindLocal(controller.get())
-    val player = binder.player
+    val player = binder.engine.mediaSessionPlayer
     val session: MediaSession = binder.session
     assertFalse("player is live before destroy", player.isReleased)
 

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

@@ -134,7 +134,7 @@ class QueueSkipArithmeticTest {
   @Test
   fun `computePrevious OFF — at index 0 returns null (no wrap)`() {
     // The "tap Previous at track 0 restarts current" UX behaviour
-    // is applied by the skipToPrevious glue, not here.
+    // is applied by `skipToPrevious`, not here.
     assertNull(
       QueueSkipArithmetic.computePrevious(5, 0, QueueSkipRepeatMode.OFF)
     )
@@ -443,4 +443,36 @@ class QueueSkipArithmeticTest {
     assertFalse(QueueSkipArithmetic.canSkipPrevious(3, 0, QueueSkipRepeatMode.OFF, restartEnabled = false))
     assertTrue(QueueSkipArithmetic.canSkipPrevious(3, 1, QueueSkipRepeatMode.OFF, restartEnabled = false))
   }
+
+  @Test
+  fun `canSkipPrevious restartEnabled — nothing playing is false in any mode`() {
+    // Nothing is loaded, so there is no track to restart and no previous
+    // track to reach: resolveSkipToPrevious returns NoOp for this state.
+    for (mode in QueueSkipRepeatMode.entries) {
+      assertFalse(QueueSkipArithmetic.canSkipPrevious(5, -1, mode, restartEnabled = true))
+    }
+  }
+
+  @Test
+  fun `canSkipPrevious agrees with resolveSkipToPrevious`() {
+    // canSkipPrevious is the enabled-state of the same decision
+    // resolveSkipToPrevious makes; the two must never disagree.
+    for (count in listOf(0, 1, 3)) {
+      for (index in listOf(-1, 0, 1, 2)) {
+        for (mode in QueueSkipRepeatMode.entries) {
+          for (restart in listOf(false, true)) {
+            val can = QueueSkipArithmetic.canSkipPrevious(count, index, mode, restart)
+            val resolved = QueueSkipArithmetic.resolveSkipToPrevious(
+              count, index, mode, restart, positionMs = 0
+            )
+            assertEquals(
+              "count=$count index=$index mode=$mode restart=$restart",
+              can,
+              resolved != QueueSkipArithmetic.SkipToPreviousAction.NoOp
+            )
+          }
+        }
+      }
+    }
+  }
 }