react-native-queue-player 1.0.0

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

@@ -0,0 +1,192 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Intent
+import android.view.KeyEvent
+import com.margelo.nitro.queueplayer.RemoteCommandDeduper.Channel
+import org.junit.Assert.assertEquals
+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.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Robolectric coverage for [MediaButtonDispatch] — key-code → command mapping
+ * plus the receipt-time-windowed de-dup that absorbs the same physical press
+ * fanned out across the session-callback and broadcast routes, while letting
+ * distinct presses through (including synthesised Bluetooth keys with a
+ * constant `downTime`).
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class MediaButtonDispatchTest {
+
+  private lateinit var handler: RecordingHandler
+  private lateinit var dispatch: MediaButtonDispatch
+  private var now: Long = 1_000L
+
+  @Before
+  fun setUp() {
+    handler = RecordingHandler()
+    now = 1_000L
+    dispatch = MediaButtonDispatch(handler, nowUptimeMs = { now })
+  }
+
+  @Test
+  fun `KEYCODE_MEDIA_PLAY_PAUSE invokes onMediaTogglePlayPause and reports handled`() {
+    val handled = dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE), Channel.SESSION_KEY)
+    assertTrue(handled)
+    assertEquals(1, handler.toggleCalls)
+    assertEquals(0, handler.playCalls)
+    assertEquals(0, handler.pauseCalls)
+    assertEquals(0, handler.skipNextCalls)
+    assertEquals(0, handler.skipPreviousCalls)
+  }
+
+  @Test
+  fun `KEYCODE_HEADSETHOOK invokes onMediaTogglePlayPause`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_HEADSETHOOK), Channel.SESSION_KEY))
+    assertEquals(1, handler.toggleCalls)
+  }
+
+  @Test
+  fun `KEYCODE_MEDIA_PLAY invokes onMediaPlay`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PLAY), Channel.SESSION_KEY))
+    assertEquals(1, handler.playCalls)
+    assertEquals(0, handler.toggleCalls)
+  }
+
+  @Test
+  fun `KEYCODE_MEDIA_PAUSE invokes onMediaPause`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PAUSE), Channel.SESSION_KEY))
+    assertEquals(1, handler.pauseCalls)
+  }
+
+  @Test
+  fun `KEYCODE_MEDIA_NEXT invokes onMediaSkipNext`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT), Channel.SESSION_KEY))
+    assertEquals(1, handler.skipNextCalls)
+  }
+
+  @Test
+  fun `KEYCODE_MEDIA_PREVIOUS invokes onMediaSkipPrevious`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PREVIOUS), Channel.SESSION_KEY))
+    assertEquals(1, handler.skipPreviousCalls)
+  }
+
+  @Test
+  fun `same press fanned across both routes within the window acts once`() {
+    // One physical press arriving on the session callback then the broadcast,
+    // 15ms apart — the second is suppressed but still claimed.
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE), Channel.SESSION_KEY))
+    now += 15
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE), Channel.BROADCAST))
+    assertEquals(1, handler.toggleCalls)
+  }
+
+  @Test
+  fun `repeated Bluetooth Next with a constant downTime each fire`() {
+    // The regression this fix targets: AVRCP/Bluetooth keys synthesise a
+    // constant downTime (here 0). Three distinct presses past the window must
+    // all skip — the old downTime-keyed de-dup suppressed every press after the first.
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, downTime = 0), Channel.SESSION_KEY))
+    now += 300
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, downTime = 0), Channel.SESSION_KEY))
+    now += 300
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, downTime = 0), Channel.SESSION_KEY))
+    assertEquals(3, handler.skipNextCalls)
+  }
+
+  @Test
+  fun `auto-repeat from a held key claims but does not multi-skip`() {
+    // The initial press skips; auto-repeat ACTION_DOWNs (repeat > 0), even spaced
+    // past the de-dup window, are claimed but not dispatched.
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, repeat = 0), Channel.SESSION_KEY))
+    now += 200
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, repeat = 1), Channel.SESSION_KEY))
+    now += 200
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT, repeat = 2), Channel.SESSION_KEY))
+    assertEquals(1, handler.skipNextCalls)
+  }
+
+  @Test
+  fun `same-channel near-instant redelivery is suppressed`() {
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT), Channel.SESSION_KEY))
+    now += 3
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_NEXT), Channel.SESSION_KEY))
+    assertEquals(1, handler.skipNextCalls)
+  }
+
+  @Test
+  fun `ACTION_UP no-ops the handler and reports unhandled`() {
+    val key = KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE)
+    val intent = Intent(Intent.ACTION_MEDIA_BUTTON).apply { putExtra(Intent.EXTRA_KEY_EVENT, key) }
+    assertFalse(dispatch.handle(intent, Channel.SESSION_KEY))
+    assertEquals(0, handler.toggleCalls)
+  }
+
+  @Test
+  fun `non-media keycodes report unhandled and do not invoke the handler`() {
+    assertFalse(dispatch.handle(downIntent(KeyEvent.KEYCODE_VOLUME_UP), Channel.SESSION_KEY))
+    assertEquals(0, handler.playCalls)
+    assertEquals(0, handler.toggleCalls)
+    assertEquals(0, handler.skipNextCalls)
+  }
+
+  @Test
+  fun `null intent reports unhandled`() {
+    assertFalse(dispatch.handle(null, Channel.SESSION_KEY))
+  }
+
+  @Test
+  fun `intent without EXTRA_KEY_EVENT reports unhandled`() {
+    assertFalse(dispatch.handle(Intent(Intent.ACTION_MEDIA_BUTTON), Channel.SESSION_KEY))
+  }
+
+  @Test
+  fun `unhandled keycode does not poison de-dup state for the next valid press`() {
+    dispatch.handle(downIntent(KeyEvent.KEYCODE_VOLUME_UP), Channel.SESSION_KEY)
+    now += 5
+    assertTrue(dispatch.handle(downIntent(KeyEvent.KEYCODE_MEDIA_PLAY), Channel.SESSION_KEY))
+    assertEquals(1, handler.playCalls)
+  }
+
+  // --- Helpers
+
+  private fun downIntent(keyCode: Int, downTime: Long = 0L, repeat: Int = 0): Intent {
+    val key = KeyEvent(
+      /* downTime = */ downTime,
+      /* eventTime = */ downTime,
+      /* action = */ KeyEvent.ACTION_DOWN,
+      /* code = */ keyCode,
+      /* repeat = */ repeat,
+    )
+    return Intent(Intent.ACTION_MEDIA_BUTTON).apply { putExtra(Intent.EXTRA_KEY_EVENT, key) }
+  }
+
+  private class RecordingHandler : PlaybackService.MediaSessionCommandHandler {
+    var transportCalls = 0
+    var skipNextCmdCalls = 0
+    var skipPreviousCmdCalls = 0
+    var playCalls = 0
+    var pauseCalls = 0
+    var toggleCalls = 0
+    var skipNextCalls = 0
+    var skipPreviousCalls = 0
+
+    override fun onTransportCommand() { transportCalls++ }
+    override fun onSkipToNextCommand(): Boolean { skipNextCmdCalls++; return true }
+    override fun onSkipToPreviousCommand(): Boolean { skipPreviousCmdCalls++; return true }
+    override fun getCachedSkipCapability(): SkipCapability =
+      SkipCapability(canSkipPrevious = true, canSkipNext = true)
+    override fun onMediaPlay() { playCalls++ }
+    override fun onMediaPause() { pauseCalls++ }
+    override fun onMediaTogglePlayPause() { toggleCalls++ }
+    override fun onMediaSkipNext() { skipNextCalls++ }
+    override fun onMediaSkipPrevious() { skipPreviousCalls++ }
+    override fun onAudioFocusEvent(mapping: AudioFocusErrorMapping.Mapping) {}
+    override fun onBecomingNoisy() {}
+  }
+}

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

@@ -0,0 +1,389 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Context
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.util.UnstableApi
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * MediaItemBuilder unit tests.
+ *
+ * Mirrors the shape of iOS `AVQueueBuilderTests`:
+ * - `mergeHttpRequestProperties` is the header/UA merging core.
+ *   Eight tests cover the iOS merge-invariant set (empty, headers
+ *   only, UA only, merged, empty-UA, UA-in-headers-overridden-by-
+ *   explicit-field, null safety).
+ * - `buildMediaItems` covers MediaItem construction (id + uri
+ *   preserved; empty input → empty output; remote + file URIs
+ *   both produce items — the file/remote routing difference is a
+ *   DataSource.Factory concern, not a MediaItem concern).
+ *
+ * Factory-building is exercised by type only (the internal
+ * `DefaultHttpDataSource.Factory` is configured via a builder chain
+ * whose effective state is hard to read back without reflection —
+ * the factory is wired into ExoPlayer at construction time and
+ * exercised implicitly through the TrackPlayer lifecycle tests).
+ *
+ * @Config sdk=34 — Robolectric 4.11.1's max supported SDK.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class MediaItemBuilderTest {
+
+  // --- mergeHttpRequestProperties
+
+  @Test
+  fun `mergeHttpRequestProperties returns empty when nothing supplied`() {
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = null, userAgent = null
+    )
+    assertTrue("no headers + no UA should produce empty map", merged.isEmpty())
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties passes headers through verbatim when no UA`() {
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = mapOf("Authorization" to "Bearer t0ken", "X-Custom" to "42"),
+      userAgent = null
+    )
+    assertEquals("Bearer t0ken", merged["Authorization"])
+    assertEquals("42", merged["X-Custom"])
+    assertNull("no UA configured → no UA injected", merged["User-Agent"])
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties injects UA as User-Agent header when headers null`() {
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = null, userAgent = "RNQPDemo/1.0"
+    )
+    assertEquals("RNQPDemo/1.0", merged["User-Agent"])
+    assertEquals(1, merged.size)
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties merges headers and explicit UA`() {
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = mapOf("Authorization" to "Bearer t0ken"),
+      userAgent = "RNQPDemo/1.0"
+    )
+    assertEquals("Bearer t0ken", merged["Authorization"])
+    assertEquals("RNQPDemo/1.0", merged["User-Agent"])
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties ignores empty-string UA`() {
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = mapOf("Authorization" to "Bearer t0ken"),
+      userAgent = ""
+    )
+    assertNull(
+      "empty-string UA must be treated the same as no UA",
+      merged["User-Agent"]
+    )
+    assertEquals("Bearer t0ken", merged["Authorization"])
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties explicit UA overrides headers User-Agent`() {
+    // Matches iOS AVQueueBuilder contract: explicit typed field is
+    // canonical and wins over any User-Agent key already present in
+    // the headers dict.
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = mapOf("User-Agent" to "stale-value"),
+      userAgent = "canonical-value"
+    )
+    assertEquals("canonical-value", merged["User-Agent"])
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties preserves headers User-Agent when UA is null`() {
+    // Inverse of the previous case: when the caller hasn't set
+    // `userAgent`, a User-Agent key in `headers` is kept as-is.
+    val merged = MediaItemBuilder.mergeHttpRequestProperties(
+      headers = mapOf("User-Agent" to "from-headers"),
+      userAgent = null
+    )
+    assertEquals("from-headers", merged["User-Agent"])
+  }
+
+  @Test
+  fun `mergeHttpRequestProperties does not mutate the input headers map`() {
+    val input = mapOf("Authorization" to "Bearer t0ken")
+    MediaItemBuilder.mergeHttpRequestProperties(
+      headers = input, userAgent = "RNQPDemo/1.0"
+    )
+    assertNull(
+      "mutation would corrupt the caller's PlayerConfig.httpHeaders",
+      input["User-Agent"]
+    )
+  }
+
+  // --- buildMediaItems
+
+  @Test
+  fun `buildMediaItems returns empty list for empty input`() {
+    val result = MediaItemBuilder.buildMediaItems(context, emptyList())
+    assertTrue(result.isEmpty())
+  }
+
+  @Test
+  fun `buildMediaItems preserves id and uri for one track`() {
+    val track = makeTrack(id = "t1", url = "https://example.com/track.m4a")
+    val items = MediaItemBuilder.buildMediaItems(context, listOf(track))
+
+    assertEquals(1, items.size)
+    assertEquals("t1", items[0].mediaId)
+    assertEquals(
+      "https://example.com/track.m4a",
+      items[0].localConfiguration?.uri?.toString()
+    )
+  }
+
+  @Test
+  fun `buildMediaItems builds one MediaItem per track preserving order`() {
+    val tracks = (1..5).map {
+      makeTrack(id = "t$it", url = "https://example.com/$it.m4a")
+    }
+    val items = MediaItemBuilder.buildMediaItems(context, tracks)
+
+    assertEquals(5, items.size)
+    items.forEachIndexed { index, mediaItem ->
+      assertEquals("t${index + 1}", mediaItem.mediaId)
+      assertEquals(
+        "https://example.com/${index + 1}.m4a",
+        mediaItem.localConfiguration?.uri?.toString()
+      )
+    }
+  }
+
+  @Test
+  fun `buildMediaItems accepts file URIs verbatim`() {
+    // Parity with iOS `AVQueueBuilderTests.testMakeItemForFileURL
+    // SkipsHeaderDictionary`: the test asserts the URI scheme is
+    // preserved, but does NOT assert the file/remote routing
+    // downstream. The factory plumbing is opaque post-build on
+    // both platforms (AVURLAsset options can't be read back on
+    // iOS; DefaultDataSource.Factory wiring is internal on
+    // Android), so the documented contract is the test.
+    val track = makeTrack(id = "local", url = "file:///tmp/track.m4a")
+    val items = MediaItemBuilder.buildMediaItems(context, listOf(track))
+
+    assertEquals(1, items.size)
+    val uri = items[0].localConfiguration?.uri
+    assertNotNull("file URI must be parsed into localConfiguration", uri)
+    assertEquals("file", uri?.scheme)
+  }
+
+  // --- buildMediaItems MIME plumbing
+
+  @Test
+  fun `buildMediaItems sets MIME from URL extension for http urls`() {
+    val track = makeTrack(id = "t", url = "https://example.com/song.mp3")
+    val items = MediaItemBuilder.buildMediaItems(context, listOf(track), lookaheadCache = null)
+    assertEquals("audio/mpeg", items[0].localConfiguration?.mimeType)
+  }
+
+  @Test
+  fun `buildMediaItems leaves MIME unset for file URIs even when extension is recognisable`() {
+    // file:// bypasses the lookahead cache; setting MIME on these
+    // is meaningless and could mis-cue Media3. Mirrors iOS where
+    // the file-extension trick fires only on HTTP downloads.
+    val track = makeTrack(id = "local", url = "file:///tmp/song.mp3")
+    val items = MediaItemBuilder.buildMediaItems(context, listOf(track), lookaheadCache = null)
+    assertNull(items[0].localConfiguration?.mimeType)
+  }
+
+  // --- buildMediaItems MediaMetadata coverage
+
+  private fun metadataFor(track: TrackItem): MediaMetadata =
+    MediaItemBuilder.buildMediaItems(context, listOf(track))[0].mediaMetadata
+
+  @Test
+  fun `MediaMetadata sets title artist album from track fields`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      title = "Song",
+      artist = "Artist",
+      album = "Album"
+    )
+    val metadata = metadataFor(track)
+    assertEquals("Song", metadata.title?.toString())
+    assertEquals("Artist", metadata.artist?.toString())
+    assertEquals("Album", metadata.albumTitle?.toString())
+  }
+
+  @Test
+  fun `MediaMetadata coerces null title artist album to empty string`() {
+    val metadata = metadataFor(makeTrack(id = "t", url = "https://example.com/s.mp3"))
+    assertEquals("", metadata.title?.toString())
+    assertEquals("", metadata.artist?.toString())
+    assertEquals("", metadata.albumTitle?.toString())
+  }
+
+  @Test
+  fun `MediaMetadata uses artworkUri when artworkUrl is non-empty`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      artworkUrl = "https://example.com/cover.jpg"
+    )
+    val metadata = metadataFor(track)
+    assertEquals("https://example.com/cover.jpg", metadata.artworkUri?.toString())
+    assertNull(metadata.artworkData)
+  }
+
+  @Test
+  fun `MediaMetadata uses placeholder resource URI when artworkUrl is null`() {
+    val metadata = metadataFor(makeTrack(id = "t", url = "https://example.com/s.mp3"))
+    val expected =
+      "android.resource://${context.packageName}/${R.raw.rnqp_placeholder}"
+    assertEquals(expected, metadata.artworkUri?.toString())
+    assertNull(metadata.artworkData)
+  }
+
+  @Test
+  fun `MediaMetadata uses placeholder resource URI when artworkUrl is empty`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      artworkUrl = ""
+    )
+    val metadata = metadataFor(track)
+    val expected =
+      "android.resource://${context.packageName}/${R.raw.rnqp_placeholder}"
+    assertEquals(expected, metadata.artworkUri?.toString())
+  }
+
+  @Test
+  fun `MediaMetadata uses placeholder resource URI when artworkUrl is whitespace only`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      artworkUrl = "   "
+    )
+    val metadata = metadataFor(track)
+    val expected =
+      "android.resource://${context.packageName}/${R.raw.rnqp_placeholder}"
+    assertEquals(expected, metadata.artworkUri?.toString())
+  }
+
+  @Test
+  fun `MediaMetadata sets durationMs from positive seconds`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      duration = 12.5
+    )
+    assertEquals(12_500L, metadataFor(track).durationMs)
+  }
+
+  @Test
+  fun `MediaMetadata omits duration when null`() {
+    val metadata = metadataFor(makeTrack(id = "t", url = "https://example.com/s.mp3"))
+    assertNull(metadata.durationMs)
+  }
+
+  @Test
+  fun `MediaMetadata omits duration when zero`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      duration = 0.0
+    )
+    assertNull(metadataFor(track).durationMs)
+  }
+
+  @Test
+  fun `MediaMetadata omits duration when negative`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      duration = -3.0
+    )
+    assertNull(metadataFor(track).durationMs)
+  }
+
+  @Test
+  fun `buildMediaItems attaches MediaMetadata to every item`() {
+    val track = makeTrack(
+      id = "t",
+      url = "https://example.com/s.mp3",
+      title = "Song"
+    )
+    val items = MediaItemBuilder.buildMediaItems(context, listOf(track))
+    assertEquals("Song", items[0].mediaMetadata.title?.toString())
+  }
+
+  @Test
+  fun `resolveMimeTypeForBuild returns null for non-http schemes`() {
+    val resolved = MediaItemBuilder.resolveMimeTypeForBuild(
+      url = "asset:///bundle/song.m4a",
+      lookaheadCache = null
+    )
+    assertNull(resolved)
+  }
+
+  @Test
+  fun `resolveMimeTypeForBuild returns null for opaque http URLs without extension`() {
+    val resolved = MediaItemBuilder.resolveMimeTypeForBuild(
+      url = "https://example.com/api/stream?id=1",
+      lookaheadCache = null
+    )
+    assertNull(resolved)
+  }
+
+  // --- buildMediaSourceFactoryRaw
+
+  @Test
+  fun `buildMediaSourceFactoryRaw returns a non-null factory with no config`() {
+    val factory = MediaItemBuilder.buildMediaSourceFactoryRaw(
+      context = ApplicationProvider.getApplicationContext(),
+      headers = null,
+      userAgent = null
+    )
+    assertNotNull(factory)
+  }
+
+  @Test
+  fun `buildMediaSourceFactoryRaw returns a non-null factory with headers and UA`() {
+    val factory = MediaItemBuilder.buildMediaSourceFactoryRaw(
+      context = ApplicationProvider.getApplicationContext(),
+      headers = mapOf("Authorization" to "Bearer t"),
+      userAgent = "rnqp/test"
+    )
+    assertNotNull(factory)
+  }
+
+  private val context: Context
+    get() = ApplicationProvider.getApplicationContext()
+
+  private fun makeTrack(
+    id: String,
+    url: String,
+    title: String? = null,
+    artist: String? = null,
+    album: String? = null,
+    duration: Double? = null,
+    artworkUrl: String? = null,
+  ): TrackItem =
+    TrackItem(
+      id = id,
+      url = url,
+      title = title,
+      artist = artist,
+      album = album,
+      duration = duration,
+      artworkUrl = artworkUrl,
+      extras = null
+    )
+}