react-native-queue-player 1.0.0

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

@@ -0,0 +1,124 @@
+package com.margelo.nitro.queueplayer
+
+import android.net.Uri
+import androidx.media3.common.util.UnstableApi
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+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.annotation.Config
+import java.io.File
+
+/**
+ * Coverage for [ArtworkContentProvider]'s public companion surface —
+ * token registry, idempotent `mapFileUri`, and per-consumer-app
+ * authority. The provider is exported with `grantUriPermissions`, so
+ * the token-collision + missing-file paths are security-relevant.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class ArtworkContentProviderTest {
+
+  private lateinit var tempDir: File
+
+  @Before
+  fun setUp() {
+    // ContentProvider.onCreate must run so the companion captures the
+    // app context. Robolectric's `buildContentProvider` mounts the
+    // provider against the test application.
+    Robolectric.buildContentProvider(ArtworkContentProvider::class.java).create()
+    tempDir = File.createTempFile("rnqp-art", "").apply {
+      delete()
+      mkdirs()
+    }
+  }
+
+  @Test
+  fun `authority is namespaced to the consumer applicationId`() {
+    val expected =
+      ApplicationProvider.getApplicationContext<android.content.Context>()
+        .packageName + ".rnqp.artwork"
+    assertEquals(expected, ArtworkContentProvider.authority())
+  }
+
+  @Test
+  fun `mapFileUri passes non-file URIs through unchanged`() {
+    val http = Uri.parse("https://cdn.example.com/cover.jpg")
+    assertEquals(http, ArtworkContentProvider.mapFileUri(http))
+
+    val content = Uri.parse("content://media/external/audio/albumart/42")
+    assertEquals(content, ArtworkContentProvider.mapFileUri(content))
+  }
+
+  @Test
+  fun `mapFileUri passes through when the file does not exist`() {
+    val missing = Uri.fromFile(File(tempDir, "missing.jpg"))
+    assertEquals(missing, ArtworkContentProvider.mapFileUri(missing))
+  }
+
+  @Test
+  fun `mapFileUri rewrites a readable file uri to content scheme`() {
+    val file = File(tempDir, "cover.jpg").apply { writeBytes(byteArrayOf(0)) }
+    val rewritten = ArtworkContentProvider.mapFileUri(Uri.fromFile(file))
+    assertEquals("content", rewritten.scheme)
+    assertEquals(ArtworkContentProvider.authority(), rewritten.authority)
+    assertEquals(1, rewritten.pathSegments.size)
+    assertEquals(32, rewritten.pathSegments[0].length)
+  }
+
+  @Test
+  fun `mapFileUri is idempotent for the same path`() {
+    val file = File(tempDir, "stable.jpg").apply { writeBytes(byteArrayOf(0)) }
+    val first = ArtworkContentProvider.mapFileUri(Uri.fromFile(file))
+    val second = ArtworkContentProvider.mapFileUri(Uri.fromFile(file))
+    assertEquals(first, second)
+  }
+
+  @Test
+  fun `different paths produce different tokens`() {
+    val a = File(tempDir, "a.jpg").apply { writeBytes(byteArrayOf(0)) }
+    val b = File(tempDir, "b.jpg").apply { writeBytes(byteArrayOf(0)) }
+    val ua = ArtworkContentProvider.mapFileUri(Uri.fromFile(a))
+    val ub = ArtworkContentProvider.mapFileUri(Uri.fromFile(b))
+    assertNotEquals(ua.pathSegments[0], ub.pathSegments[0])
+  }
+
+  @Test
+  fun `openFile returns null for an unregistered token`() {
+    val provider = ArtworkContentProvider().apply { /* no onCreate */ }
+    val unknownUri = Uri.Builder()
+      .scheme("content")
+      .authority("anything.rnqp.artwork")
+      .appendPath("deadbeefdeadbeefdeadbeefdeadbeef")
+      .build()
+    assertNull(provider.openFile(unknownUri, "r"))
+  }
+
+  @Test
+  fun `openFile returns null when the path is empty`() {
+    val provider = ArtworkContentProvider().apply { /* no onCreate */ }
+    val noPath = Uri.Builder()
+      .scheme("content")
+      .authority("anything.rnqp.artwork")
+      .build()
+    assertNull(provider.openFile(noPath, "r"))
+  }
+
+  @Test
+  fun `openFile opens a registered file with a real ParcelFileDescriptor`() {
+    val file = File(tempDir, "fd.jpg").apply { writeBytes("hi".toByteArray()) }
+    val content = ArtworkContentProvider.mapFileUri(Uri.fromFile(file))
+    val pfd = ArtworkContentProvider().openFile(content, "r")
+    assertNotNull(pfd)
+    pfd?.close()
+  }
+}

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

@@ -0,0 +1,122 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.Player
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Pure-Kotlin coverage for [AudioFocusErrorMapping]. No Robolectric
+ * needed — the mapping reads only [Player] reason int constants and
+ * has no Android dependency at runtime.
+ */
+class AudioFocusErrorMappingTest {
+
+  @Test
+  fun `playWhenReady AUDIO_FOCUS_LOSS reason maps to LOSS_PERMANENT`() {
+    val mapping = AudioFocusErrorMapping.mapPlayWhenReadyReason(
+      Player.PLAY_WHEN_READY_CHANGE_REASON_AUDIO_FOCUS_LOSS
+    )
+    assertEquals("AUDIO_FOCUS_LOSS_PERMANENT", mapping?.nativeDomain)
+    assertEquals(
+      "Audio focus lost permanently; Media3 has paused playback.",
+      mapping?.message
+    )
+  }
+
+  @Test
+  fun `non-focus playWhenReady reasons map to null`() {
+    assertNull(AudioFocusErrorMapping.mapPlayWhenReadyReason(
+      Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST
+    ))
+    assertNull(AudioFocusErrorMapping.mapPlayWhenReadyReason(
+      Player.PLAY_WHEN_READY_CHANGE_REASON_REMOTE
+    ))
+    assertNull(AudioFocusErrorMapping.mapPlayWhenReadyReason(
+      Player.PLAY_WHEN_READY_CHANGE_REASON_END_OF_MEDIA_ITEM
+    ))
+    assertNull(AudioFocusErrorMapping.mapPlayWhenReadyReason(-999))
+  }
+
+  @Test
+  fun `entry into TRANSIENT_AUDIO_FOCUS_LOSS maps to LOSS_TRANSIENT`() {
+    val mapping = AudioFocusErrorMapping.mapSuppressionReason(
+      reason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+      previous = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+    )
+    assertEquals("AUDIO_FOCUS_LOSS_TRANSIENT", mapping?.nativeDomain)
+    assertEquals(
+      "Audio focus lost transiently; Media3 has paused playback.",
+      mapping?.message
+    )
+  }
+
+  @Test
+  fun `exit from TRANSIENT_AUDIO_FOCUS_LOSS to NONE maps to GAIN`() {
+    val mapping = AudioFocusErrorMapping.mapSuppressionReason(
+      reason = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+      previous = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+    )
+    assertEquals("AUDIO_FOCUS_GAIN", mapping?.nativeDomain)
+    assertEquals("Audio focus regained.", mapping?.message)
+  }
+
+  @Test
+  fun `redundant TRANSIENT to TRANSIENT transition maps to null`() {
+    assertNull(
+      "an unchanged suppression reason carries no new focus event",
+      AudioFocusErrorMapping.mapSuppressionReason(
+        reason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+        previous = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+      )
+    )
+  }
+
+  @Test
+  fun `NONE to NONE transition maps to null`() {
+    assertNull(AudioFocusErrorMapping.mapSuppressionReason(
+      reason = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+      previous = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+    ))
+  }
+
+  @Test
+  fun `non-focus suppression reasons map to null`() {
+    // UNSUITABLE_AUDIO_OUTPUT or UNSUITABLE_AUDIO_ROUTE (Media3 1.x)
+    // — non-focus suppression. Mapping ignores it.
+    val unsuitable = Player.PLAYBACK_SUPPRESSION_REASON_UNSUITABLE_AUDIO_OUTPUT
+    assertNull(AudioFocusErrorMapping.mapSuppressionReason(
+      reason = unsuitable,
+      previous = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+    ))
+    assertNull(AudioFocusErrorMapping.mapSuppressionReason(
+      reason = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+      previous = unsuitable,
+    ))
+  }
+
+  @Test
+  fun `every emitted nativeDomain shares the AUDIO_FOCUS_ prefix`() {
+    val emitted = listOfNotNull(
+      AudioFocusErrorMapping.mapPlayWhenReadyReason(
+        Player.PLAY_WHEN_READY_CHANGE_REASON_AUDIO_FOCUS_LOSS
+      ),
+      AudioFocusErrorMapping.mapSuppressionReason(
+        reason = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+        previous = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+      ),
+      AudioFocusErrorMapping.mapSuppressionReason(
+        reason = Player.PLAYBACK_SUPPRESSION_REASON_NONE,
+        previous = Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS,
+      ),
+    )
+    assertEquals(3, emitted.size)
+    for (mapping in emitted) {
+      assertTrue(
+        "domain ${mapping.nativeDomain} must start with the shared AUDIO_FOCUS_ prefix",
+        mapping.nativeDomain.startsWith(AudioFocusErrorMapping.NATIVE_DOMAIN_PREFIX)
+      )
+    }
+  }
+}

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

@@ -0,0 +1,57 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.lang.reflect.Field
+
+/**
+ * Unit coverage for [AudioPipelineRenderersFactory] construction — it wraps a
+ * caller-supplied [androidx.media3.common.audio.AudioProcessorChain] and opts
+ * the produced sink into float output. The engines drive end-to-end exercise of
+ * `buildAudioSink` via `ExoPlayer.Builder.build()` in
+ * [GaplessEngineLifecycleTest] / [CrossfadeEngineLifecycleTest]; `buildAudioSink`
+ * itself is `protected` on [DefaultRenderersFactory] and cannot be called
+ * outside the Media3 internal call path. Chain composition + order is covered by
+ * [PitchAwareAudioProcessorChainTest].
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class AudioPipelineRenderersFactoryTest {
+
+  private val context get() = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+  @Test
+  fun `factory accepts an audio processor chain`() {
+    val factory =
+      AudioPipelineRenderersFactory(context, PitchAwareAudioProcessorChain(emptyArray()))
+    assertNotNull(factory)
+  }
+
+  @Test
+  fun `factory enables audio float output so the float processors see Float32 PCM`() {
+    // [DefaultRenderersFactory.enableAudioFloatOutput] defaults to false;
+    // without an explicit opt-in Media3 propagates `enableFloatOutput = false`
+    // into [buildAudioSink], which makes the sink emit Int16 PCM and silently
+    // disables the float-gated processors (ReplayGain + the music stretcher,
+    // whose isActive gate on ENCODING_PCM_FLOAT). The factory's init block flips
+    // the flag to true; pin that by reading the private field via reflection —
+    // no public accessor exists, but the field name is stable across Media3 1.x.
+    val factory =
+      AudioPipelineRenderersFactory(context, PitchAwareAudioProcessorChain(emptyArray()))
+    val field: Field =
+      DefaultRenderersFactory::class.java.getDeclaredField("enableFloatOutput")
+    field.isAccessible = true
+    assertTrue(
+      "AudioPipelineRenderersFactory must enable float output",
+      field.getBoolean(factory),
+    )
+  }
+}

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

@@ -0,0 +1,264 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Intent
+import android.os.Looper
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaSession
+import androidx.test.core.app.ApplicationProvider
+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
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.android.controller.ServiceController
+import org.robolectric.annotation.Config
+
+/**
+ * Robolectric coverage for the AVRCP-relevant surface of the
+ * [PlaybackService] [MediaSession]. Media3 bridges a connected
+ * [androidx.media3.session.MediaController] (which is what an
+ * Android Auto, Wear, or Bluetooth A2DP/AVRCP head unit binds as)
+ * directly to `MediaSession.player.currentMediaItem.mediaMetadata`
+ * + the session's available `Player.Commands`. The bridge is built
+ * into Media3 — the lib does not write any AVRCP code itself, so
+ * this suite asserts that the session surface a controller would
+ * read reflects the lib's queue + skip-capability state.
+ *
+ * `MediaController.Builder.buildAsync()` is too heavyweight to drive
+ * to a connected state under Robolectric (the connection handshake
+ * blocks on the framework's process binder). The bridge ingests the
+ * same fields exercised here, so direct reads against
+ * `session.player` cover the AVRCP-visible state without standing
+ * up a controller. The end-to-end Bluetooth pairing pass is the
+ * user-led manual verification lane (per AGENTS rule on physical-
+ * device test lanes).
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class AvrcpMetadataTest {
+
+  private lateinit var controller: ServiceController<PlaybackService>
+  private lateinit var service: PlaybackService
+  private lateinit var binder: PlaybackService.LocalBinder
+  private lateinit var session: MediaSession
+
+  @Before
+  fun setUp() {
+    controller = Robolectric.buildService(PlaybackService::class.java).create()
+    service = controller.get()
+    val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+    val intent = Intent(context.applicationContext, PlaybackService::class.java)
+      .setAction(PlaybackService.ACTION_LOCAL_BIND)
+    binder = service.onBind(intent) as PlaybackService.LocalBinder
+    session = binder.session
+  }
+
+  @After
+  fun tearDown() {
+    controller.destroy()
+  }
+
+  // --- Metadata propagation through the session surface
+
+  @Test
+  fun `currentMediaItem mediaMetadata reflects title artist album for the head of the queue`() {
+    val track = TrackItem(
+      id = "t1",
+      url = "https://example.com/a.m4a",
+      title = "Song X",
+      artist = "Artist Y",
+      album = "Album Z",
+      duration = null,
+      artworkUrl = null,
+      extras = null,
+    )
+    setQueueOnSession(listOf(track))
+
+    val metadata = session.player.currentMediaItem?.mediaMetadata
+    assertEquals("Song X", metadata?.title?.toString())
+    assertEquals("Artist Y", metadata?.artist?.toString())
+    assertEquals("Album Z", metadata?.albumTitle?.toString())
+  }
+
+  @Test
+  fun `currentMediaItem mediaMetadata exposes artworkUri to the AVRCP surface`() {
+    val track = TrackItem(
+      id = "t1",
+      url = "https://example.com/a.m4a",
+      title = "Song",
+      artist = "Artist",
+      album = "Album",
+      duration = null,
+      artworkUrl = "https://example.com/cover.jpg",
+      extras = null,
+    )
+    setQueueOnSession(listOf(track))
+
+    assertEquals(
+      "https://example.com/cover.jpg",
+      session.player.currentMediaItem?.mediaMetadata?.artworkUri?.toString(),
+    )
+  }
+
+  @Test
+  fun `currentMediaItem mediaMetadata exposes durationMs when track duration is positive`() {
+    val track = TrackItem(
+      id = "t1",
+      url = "https://example.com/a.m4a",
+      title = "Song",
+      artist = "Artist",
+      album = "Album",
+      duration = 42.0,
+      artworkUrl = null,
+      extras = null,
+    )
+    setQueueOnSession(listOf(track))
+
+    assertEquals(42_000L, session.player.currentMediaItem?.mediaMetadata?.durationMs)
+  }
+
+  @Test
+  fun `setMediaItems followed by prepare swaps the AVRCP-visible metadata to the new head`() {
+    val first = TrackItem(
+      id = "first",
+      url = "https://example.com/first.m4a",
+      title = "First",
+      artist = "A1",
+      album = "B1",
+      duration = null,
+      artworkUrl = null,
+      extras = null,
+    )
+    val second = TrackItem(
+      id = "second",
+      url = "https://example.com/second.m4a",
+      title = "Second",
+      artist = "A2",
+      album = "B2",
+      duration = null,
+      artworkUrl = null,
+      extras = null,
+    )
+
+    setQueueOnSession(listOf(first))
+    assertEquals("First", session.player.currentMediaItem?.mediaMetadata?.title?.toString())
+
+    setQueueOnSession(listOf(second))
+    assertEquals("Second", session.player.currentMediaItem?.mediaMetadata?.title?.toString())
+    assertEquals("A2", session.player.currentMediaItem?.mediaMetadata?.artist?.toString())
+  }
+
+  // --- Empty queue surface
+
+  @Test
+  fun `setMediaItems with an empty list leaves the AVRCP surface with no current item`() {
+    val track = TrackItem(
+      id = "t1",
+      url = "https://example.com/a.m4a",
+      title = "Song",
+      artist = "Artist",
+      album = "Album",
+      duration = null,
+      artworkUrl = null,
+      extras = null,
+    )
+    setQueueOnSession(listOf(track))
+    assertEquals(1, session.player.mediaItemCount)
+
+    setQueueOnSession(emptyList())
+
+    assertEquals(0, session.player.mediaItemCount)
+    assertNull(session.player.currentMediaItem)
+  }
+
+  // --- Skip-capability reflection on the session surface
+
+  @Test
+  fun `available player commands include skip-next and exclude skip-previous when the cap so allows`() {
+    val handler = StaticCapabilityHandler(
+      SkipCapability(canSkipPrevious = false, canSkipNext = true)
+    )
+    binder.setCommandHandler(handler)
+
+    val controllerInfo = MediaSession.ControllerInfo.createTestOnlyControllerInfo(
+      "avrcp-controller", 0, 0, 0, 0, false, android.os.Bundle.EMPTY, false
+    )
+    val commands = PlaybackServiceCallback(service.callbackEnvironment)
+      .onConnect(session, controllerInfo)
+      .availablePlayerCommands
+
+    assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT))
+    assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
+    assertFalse(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS))
+    assertFalse(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
+  }
+
+  @Test
+  fun `available player commands flip with the cached skip capability between consecutive connects`() {
+    val handler = StaticCapabilityHandler(
+      SkipCapability(canSkipPrevious = false, canSkipNext = false)
+    )
+    binder.setCommandHandler(handler)
+    val callback = PlaybackServiceCallback(service.callbackEnvironment)
+    val controllerInfo = MediaSession.ControllerInfo.createTestOnlyControllerInfo(
+      "avrcp-controller", 0, 0, 0, 0, false, android.os.Bundle.EMPTY, false
+    )
+
+    val noSkips = callback.onConnect(session, controllerInfo).availablePlayerCommands
+    assertFalse(noSkips.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
+    assertFalse(noSkips.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
+
+    handler.capability = SkipCapability(canSkipPrevious = true, canSkipNext = true)
+    val bothSkips = callback.onConnect(session, controllerInfo).availablePlayerCommands
+    assertTrue(bothSkips.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
+    assertTrue(bothSkips.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
+  }
+
+  // --- Helpers
+
+  /**
+   * Hand the player the production-built MediaItems for [tracks]
+   * and pump the main looper so the resulting metadata change
+   * propagates to `currentMediaItem`. Mirrors the call shape the
+   * lib uses inside `TrackPlayer.setQueueInternal`.
+   */
+  private fun setQueueOnSession(tracks: List<TrackItem>) {
+    val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+    val items: List<MediaItem> = MediaItemBuilder.buildMediaItems(context, tracks)
+    session.player.setMediaItems(items)
+    session.player.prepare()
+    shadowOf(Looper.getMainLooper()).idle()
+  }
+
+  /**
+   * Minimal handler that surfaces a static skip capability and
+   * tolerates every other callback as a no-op. The metadata path
+   * doesn't exercise the transport / skip / media-button hooks; the
+   * cap-reflection tests only need the cap getter to return the
+   * value under test.
+   */
+  private class StaticCapabilityHandler(
+    var capability: SkipCapability,
+  ) : PlaybackService.MediaSessionCommandHandler {
+    override fun onTransportCommand() {}
+    override fun onSkipToNextCommand(): Boolean = false
+    override fun onSkipToPreviousCommand(): Boolean = false
+    override fun getCachedSkipCapability(): SkipCapability = capability
+    override fun onMediaPlay() {}
+    override fun onMediaPause() {}
+    override fun onMediaTogglePlayPause() {}
+    override fun onMediaSkipNext() {}
+    override fun onMediaSkipPrevious() {}
+    override fun onAudioFocusEvent(mapping: AudioFocusErrorMapping.Mapping) {}
+    override fun onBecomingNoisy() {}
+  }
+}

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

@@ -0,0 +1,104 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+
+/**
+ * Pure-Kotlin coverage for [BrowseCallbackRegistry]'s slot-replace
+ * + dispose semantics. The Promise-typed callbacks are stored as
+ * function references; tests use simple stand-in lambdas — actual
+ * dispatch coverage lives at the integration layer
+ * (`PlaybackServiceCallbackSearchTest` for the search dispatch
+ * path; future Maestro flows for end-to-end Auto cold-wake).
+ */
+@UnstableApi
+class BrowseCallbackRegistryTest {
+
+  @Test
+  fun `empty registry returns null for every slot`() {
+    val r = BrowseCallbackRegistry()
+    assertNull(r.browseRequestCallback())
+    assertNull(r.searchRequestCallback())
+    assertNull(r.playFromSearchRequestCallback())
+    assertNull(r.playFromIdRequestCallback())
+    assertNull(r.carConnectCallback())
+    assertNull(r.carDisconnectCallback())
+    assertNull(r.serviceReadyCallback())
+  }
+
+  @Test
+  fun `registerOnServiceReady stores the callback + disposer clears`() {
+    val r = BrowseCallbackRegistry()
+    val cb: (ServiceReadyReason) -> Unit = { /* no-op */ }
+    val disposer = r.registerOnServiceReady(cb)
+    assertSame(cb, r.serviceReadyCallback())
+    disposer()
+    assertNull("disposer clears the slot", r.serviceReadyCallback())
+  }
+
+  @Test
+  fun `clear drops the onServiceReady slot too`() {
+    val r = BrowseCallbackRegistry()
+    r.registerOnServiceReady { }
+    assertNotNull(r.serviceReadyCallback())
+    r.clear()
+    assertNull(r.serviceReadyCallback())
+  }
+
+  @Test
+  fun `registerOnCarConnect stores the callback + returns disposer that clears`() {
+    val r = BrowseCallbackRegistry()
+    val cb: () -> Unit = { /* no-op */ }
+    val disposer = r.registerOnCarConnect(cb)
+    assertSame(cb, r.carConnectCallback())
+    disposer()
+    assertNull("disposer clears the slot", r.carConnectCallback())
+  }
+
+  @Test
+  fun `register replaces a prior callback in the same slot`() {
+    val r = BrowseCallbackRegistry()
+    val first: () -> Unit = { }
+    val second: () -> Unit = { }
+    r.registerOnCarConnect(first)
+    r.registerOnCarConnect(second)
+    assertSame(
+      "second register replaces the first",
+      second,
+      r.carConnectCallback()
+    )
+  }
+
+  @Test
+  fun `disposing the prior callback after a replace is a no-op`() {
+    // Re-registration before the first disposer fires is the
+    // standard "JS handler swapped" path. The first disposer must
+    // NOT clear the new (live) registration.
+    val r = BrowseCallbackRegistry()
+    val first: () -> Unit = { }
+    val second: () -> Unit = { }
+    val firstDispose = r.registerOnCarConnect(first)
+    r.registerOnCarConnect(second)
+    firstDispose()
+    assertSame(
+      "stale dispose does NOT clear the live registration",
+      second,
+      r.carConnectCallback()
+    )
+  }
+
+  @Test
+  fun `clear drops every slot`() {
+    val r = BrowseCallbackRegistry()
+    r.registerOnCarConnect { }
+    r.registerOnCarDisconnect { }
+    assertNotNull(r.carConnectCallback())
+    assertNotNull(r.carDisconnectCallback())
+    r.clear()
+    assertNull(r.carConnectCallback())
+    assertNull(r.carDisconnectCallback())
+  }
+}