@rntp/player 5.0.0-beta.6 → 5.1.0

package/android/src/test/java/com/doublesymmetry/trackplayer/models/MetadataApplierTest.kt

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Double Symmetry GmbH
+ * Commercial use requires a license. See https://rntp.dev/pricing
+ */
+
+package com.doublesymmetry.trackplayer.models
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.exoplayer.ExoPlayer
+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.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+/**
+ * Exercises [MetadataApplier.applyToCurrentMediaItem] against a real
+ * [ExoPlayer] under Robolectric. We use [ExoPlayer] directly (rather than the
+ * [androidx.media3.session.MediaController] used at runtime) because both
+ * implement the [androidx.media3.common.Player] interface that the applier
+ * targets — and ExoPlayer is the only one we can stand up without a service.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class MetadataApplierTest {
+
+  private lateinit var player: ExoPlayer
+
+  @Before
+  fun setUp() {
+    val context = RuntimeEnvironment.getApplication()
+    player = ExoPlayer.Builder(context).build()
+  }
+
+  @After
+  fun tearDown() {
+    player.release()
+  }
+
+  private fun buildItem(
+    id: String,
+    title: String? = null,
+    artist: String? = null,
+    albumTitle: String? = null,
+    genre: String? = null,
+  ): MediaItem = MediaItem.Builder()
+    .setMediaId(id)
+    .setUri("https://example.com/$id.mp3")
+    .setMediaMetadata(
+      MediaMetadata.Builder().apply {
+        title?.let { setTitle(it) }
+        artist?.let { setArtist(it) }
+        albumTitle?.let { setAlbumTitle(it) }
+        genre?.let { setGenre(it) }
+      }.build()
+    )
+    .build()
+
+  // ---- Happy path: live ICY-style updates rewrite the current item ----
+
+  @Test
+  fun `applies title and artist to current item`() {
+    player.setMediaItems(listOf(buildItem("radio")))
+    val event = MetadataReceivedEvent(title = "Hoppípolla", artist = "Sigur Rós")
+
+    val applied = MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    assertTrue(applied)
+    val updated = player.getMediaItemAt(0).mediaMetadata
+    assertEquals("Hoppípolla", updated.title?.toString())
+    assertEquals("Sigur Rós", updated.artist?.toString())
+  }
+
+  @Test
+  fun `preserves existing user-supplied fields the event does not touch`() {
+    // Mirrors the real-world case: an app queues a radio station with a fixed
+    // `genre` / `albumTitle` and the stream subsequently sends new ICY titles
+    // without artwork/genre. Those originals must survive the rewrite.
+    player.setMediaItems(
+      listOf(
+        buildItem(
+          id = "radio",
+          title = "Static Station Title",
+          artist = null,
+          albumTitle = "My Radios",
+          genre = "Rock",
+        )
+      )
+    )
+    val event = MetadataReceivedEvent(title = "New Song", artist = "New Artist")
+
+    MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    val updated = player.getMediaItemAt(0).mediaMetadata
+    assertEquals("New Song", updated.title?.toString())
+    assertEquals("New Artist", updated.artist?.toString())
+    assertEquals("My Radios", updated.albumTitle?.toString())
+    assertEquals("Rock", updated.genre?.toString())
+  }
+
+  @Test
+  fun `overwrites previous stream-supplied title on next update`() {
+    // Two consecutive ICY updates: second one fully replaces the first's
+    // title + artist (same currentIndex, so the rewrite is in place).
+    player.setMediaItems(listOf(buildItem("radio")))
+
+    MetadataApplier.applyToCurrentMediaItem(
+      player,
+      MetadataReceivedEvent(title = "Song A", artist = "Artist A"),
+    )
+    MetadataApplier.applyToCurrentMediaItem(
+      player,
+      MetadataReceivedEvent(title = "Song B", artist = "Artist B"),
+    )
+
+    val updated = player.getMediaItemAt(0).mediaMetadata
+    assertEquals("Song B", updated.title?.toString())
+    assertEquals("Artist B", updated.artist?.toString())
+  }
+
+  @Test
+  fun `null fields in event do not clobber existing values (sticky semantics)`() {
+    // Match iOS withMetadata behavior: nil from stream means "leave alone",
+    // not "clear". Useful when a station sends artist on one update and only
+    // title on the next.
+    player.setMediaItems(listOf(buildItem(id = "radio", artist = "Existing Artist")))
+    val event = MetadataReceivedEvent(title = "Just a Title", artist = null)
+
+    MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    val updated = player.getMediaItemAt(0).mediaMetadata
+    assertEquals("Just a Title", updated.title?.toString())
+    assertEquals("Existing Artist", updated.artist?.toString())
+  }
+
+  // ---- URI preserved → playback uninterrupted ----
+
+  @Test
+  fun `preserves URI on rewrite`() {
+    player.setMediaItems(listOf(buildItem("radio")))
+    val originalUri = player.getMediaItemAt(0).localConfiguration?.uri.toString()
+
+    MetadataApplier.applyToCurrentMediaItem(
+      player,
+      MetadataReceivedEvent(title = "Song", artist = "Artist"),
+    )
+
+    val newUri = player.getMediaItemAt(0).localConfiguration?.uri.toString()
+    assertEquals(originalUri, newUri)
+  }
+
+  @Test
+  fun `preserves mediaId on rewrite`() {
+    player.setMediaItems(listOf(buildItem("my-radio-id", title = "Original")))
+
+    MetadataApplier.applyToCurrentMediaItem(
+      player,
+      MetadataReceivedEvent(title = "Live Title", artist = null),
+    )
+
+    assertEquals("my-radio-id", player.getMediaItemAt(0).mediaId)
+  }
+
+  // ---- artworkUri / albumTitle / genre coverage ----
+
+  @Test
+  fun `applies artworkUri and genre from event`() {
+    player.setMediaItems(listOf(buildItem("radio")))
+    val event = MetadataReceivedEvent(
+      title = "Song",
+      artist = "Artist",
+      albumTitle = "Album",
+      artworkUri = "https://art.example.com/cover.jpg",
+      genre = "Indie",
+    )
+
+    MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    val updated = player.getMediaItemAt(0).mediaMetadata
+    assertEquals("Album", updated.albumTitle?.toString())
+    assertEquals("https://art.example.com/cover.jpg", updated.artworkUri?.toString())
+    assertEquals("Indie", updated.genre?.toString())
+  }
+
+  // ---- No current item → no-op ----
+
+  @Test
+  fun `returns false when queue is empty`() {
+    val event = MetadataReceivedEvent(title = "Won't Apply", artist = null)
+
+    val applied = MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    assertFalse(applied)
+    assertEquals(0, player.mediaItemCount)
+  }
+
+  // ---- Affects only the current index, not siblings ----
+
+  @Test
+  fun `only mutates the current item, not the rest of the queue`() {
+    player.setMediaItems(
+      listOf(
+        buildItem("track-1", title = "Title 1"),
+        buildItem("track-2", title = "Title 2"),
+        buildItem("track-3", title = "Title 3"),
+      )
+    )
+    // currentIndex defaults to 0 — that's the one we expect to mutate.
+    val event = MetadataReceivedEvent(title = "Live Title 1", artist = null)
+
+    MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    assertEquals("Live Title 1", player.getMediaItemAt(0).mediaMetadata.title?.toString())
+    assertEquals("Title 2", player.getMediaItemAt(1).mediaMetadata.title?.toString())
+    assertEquals("Title 3", player.getMediaItemAt(2).mediaMetadata.title?.toString())
+  }
+
+  // ---- Edge case: event with all null fields contributes nothing ----
+
+  @Test
+  fun `event with all null fields leaves item unchanged but still reports applied`() {
+    // The applier doesn't gate on empty events — that's the caller's job
+    // (StreamMetadataExtractor.extract already returns null for empty
+    // metadata blocks, so this code path is mostly defensive).
+    player.setMediaItems(listOf(buildItem(id = "radio", title = "Original Title")))
+    val event = MetadataReceivedEvent(
+      title = null, artist = null, albumTitle = null, artworkUri = null, genre = null,
+    )
+
+    val applied = MetadataApplier.applyToCurrentMediaItem(player, event)
+
+    assertTrue(applied)
+    assertEquals("Original Title", player.getMediaItemAt(0).mediaMetadata.title?.toString())
+    assertNull(player.getMediaItemAt(0).mediaMetadata.artist)
+  }
+}

package/android/src/test/java/com/doublesymmetry/trackplayer/models/PlayerConfigTest.kt

@@ -22,6 +22,7 @@ class PlayerConfigTest {
 
         assertEquals("music", config.contentType)
         assertTrue(config.handleAudioBecomingNoisy)
+        assertTrue(config.autoUpdateMetadataFromStream)
         assertEquals(WakeMode.NONE, config.wakeMode)
         assertFalse(config.skipSilenceEnabled)
         assertEquals(listOf(PlayerCommand.PLAY_PAUSE), config.availableCommands)
@@ -48,6 +49,7 @@ class PlayerConfigTest {
         val config = PlayerConfig(
             contentType = "speech",
             handleAudioBecomingNoisy = false,
+            autoUpdateMetadataFromStream = false,
             wakeMode = WakeMode.NETWORK,
             skipSilenceEnabled = true,
             forwardInterval = 30L,
@@ -66,6 +68,7 @@ class PlayerConfigTest {
 
         assertEquals("speech", loaded.contentType)
         assertFalse(loaded.handleAudioBecomingNoisy)
+        assertFalse(loaded.autoUpdateMetadataFromStream)
         assertEquals(WakeMode.NETWORK, loaded.wakeMode)
         assertTrue(loaded.skipSilenceEnabled)
         assertEquals(30L, loaded.forwardInterval)
@@ -382,6 +385,36 @@ class PlayerConfigTest {
         assertEquals(RemoteControlHandling.JS, config.remoteControlHandling)
     }
 
+    @Test
+    fun `fromReadableMap defaults autoUpdateMetadataFromStream to true`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { getString("contentType") } returns null
+            every { getMap("android") } returns null
+            every { getMap("cache") } returns null
+            every { getMap("progressSync") } returns null
+            every { hasKey(any()) } returns false
+        }
+
+        val config = PlayerConfig.fromReadableMap(map)
+        assertTrue(config.autoUpdateMetadataFromStream)
+    }
+
+    @Test
+    fun `fromReadableMap parses autoUpdateMetadataFromStream when false`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { getString("contentType") } returns null
+            every { getMap("android") } returns null
+            every { getMap("cache") } returns null
+            every { getMap("progressSync") } returns null
+            every { hasKey(any()) } returns false
+            every { hasKey("autoUpdateMetadataFromStream") } returns true
+            every { getBoolean("autoUpdateMetadataFromStream") } returns false
+        }
+
+        val config = PlayerConfig.fromReadableMap(map)
+        assertFalse(config.autoUpdateMetadataFromStream)
+    }
+
     @Test
     fun `fromReadableMap with null android section defaults wakeMode to NONE`() {
         val map = mockk<ReadableMap>(relaxed = true) {

package/android/src/test/java/com/doublesymmetry/trackplayer/models/StreamMetadataExtractorTest.kt

@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) Double Symmetry GmbH
+ * Commercial use requires a license. See https://rntp.dev/pricing
+ */
+
+package com.doublesymmetry.trackplayer.models
+
+import androidx.media3.common.Format
+import androidx.media3.common.Metadata
+import androidx.media3.extractor.metadata.MetadataInputBuffer
+import androidx.media3.extractor.metadata.icy.IcyDecoder
+import androidx.media3.extractor.metadata.icy.IcyHeaders
+import androidx.media3.extractor.metadata.icy.IcyInfo
+import androidx.media3.extractor.metadata.id3.TextInformationFrame
+import com.google.common.collect.ImmutableList
+import java.nio.ByteBuffer
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Validates that the same parser path that ExoPlayer's
+ * [androidx.media3.exoplayer.source.ProgressiveMediaPeriod] uses for live ICY
+ * streams produces the metadata our JS layer expects. We feed the real
+ * [IcyDecoder] raw byte payloads in the exact wire format radio.co /
+ * klubradio.hu (Shoutcast/Icecast) emit, and assert the aggregated
+ * [MetadataReceivedEvent].
+ *
+ * Repro context — https://github.com/doublesymmetry/react-native-track-player/issues/2638
+ *  - https://streamer.radio.co/s51a438b13/listen
+ *  - https://stream.klubradio.hu:8443/
+ */
+@RunWith(RobolectricTestRunner::class)
+class StreamMetadataExtractorTest {
+
+  // ---- parseStreamTitle ----
+
+  @Test
+  fun `parseStreamTitle splits Artist - Title`() {
+    val (title, artist) = StreamMetadataExtractor.parseStreamTitle("Daft Punk - Get Lucky")
+    assertEquals("Get Lucky", title)
+    assertEquals("Daft Punk", artist)
+  }
+
+  @Test
+  fun `parseStreamTitle keeps single string as title`() {
+    val (title, artist) = StreamMetadataExtractor.parseStreamTitle("Morning News")
+    assertEquals("Morning News", title)
+    assertNull(artist)
+  }
+
+  @Test
+  fun `parseStreamTitle splits only on first separator`() {
+    val (title, artist) =
+      StreamMetadataExtractor.parseStreamTitle("Daft Punk - Get Lucky - Radio Edit")
+    assertEquals("Get Lucky - Radio Edit", title)
+    assertEquals("Daft Punk", artist)
+  }
+
+  @Test
+  fun `parseStreamTitle trims surrounding whitespace`() {
+    val (title, artist) = StreamMetadataExtractor.parseStreamTitle("  Artist  -  Song  ")
+    assertEquals("Song", title)
+    assertEquals("Artist", artist)
+  }
+
+  @Test
+  fun `parseStreamTitle returns nulls for blank input`() {
+    val (title, artist) = StreamMetadataExtractor.parseStreamTitle("   ")
+    assertNull(title)
+    assertNull(artist)
+  }
+
+  @Test
+  fun `parseStreamTitle does not split on dash without surrounding spaces`() {
+    // "U-Turn" should NOT be split — Shoutcast convention uses " - " (spaces).
+    val (title, artist) = StreamMetadataExtractor.parseStreamTitle("U-Turn")
+    assertEquals("U-Turn", title)
+    assertNull(artist)
+  }
+
+  // ---- extract: synthetic IcyInfo entries ----
+
+  @Test
+  fun `extract from IcyInfo with Artist - Title splits both fields`() {
+    val info = IcyInfo(ByteArray(0), "Daft Punk - Get Lucky", null)
+    val event = StreamMetadataExtractor.extract(Metadata(info))
+
+    assertNotNull(event)
+    assertEquals("Get Lucky", event!!.title)
+    assertEquals("Daft Punk", event.artist)
+    assertNull(event.albumTitle)
+    assertNull(event.artworkUri)
+    assertNull(event.genre)
+  }
+
+  @Test
+  fun `extract from IcyInfo with single title leaves artist null`() {
+    val info = IcyInfo(ByteArray(0), "Morning Talk Show", null)
+    val event = StreamMetadataExtractor.extract(Metadata(info))
+
+    assertNotNull(event)
+    assertEquals("Morning Talk Show", event!!.title)
+    assertNull(event.artist)
+  }
+
+  @Test
+  fun `extract from IcyInfo with null title returns null event`() {
+    val info = IcyInfo(ByteArray(0), null, null)
+    val event = StreamMetadataExtractor.extract(Metadata(info))
+    assertNull(event)
+  }
+
+  @Test
+  fun `extract from empty Metadata returns null`() {
+    val event = StreamMetadataExtractor.extract(Metadata())
+    assertNull(event)
+  }
+
+  @Test
+  fun `extract maps IcyInfo url into artworkUri`() {
+    val info = IcyInfo(ByteArray(0), "Artist - Song", "https://example.com/cover.jpg")
+    val event = StreamMetadataExtractor.extract(Metadata(info))
+
+    assertNotNull(event)
+    assertEquals("https://example.com/cover.jpg", event!!.artworkUri)
+  }
+
+  @Test
+  fun `extract ignores empty IcyInfo url`() {
+    val info = IcyInfo(ByteArray(0), "Artist - Song", "")
+    val event = StreamMetadataExtractor.extract(Metadata(info))
+
+    assertNotNull(event)
+    assertNull(event!!.artworkUri)
+  }
+
+  // ---- extract: combined IcyInfo + IcyHeaders ----
+
+  @Test
+  fun `extract pulls genre from IcyHeaders alongside IcyInfo title`() {
+    // ProgressiveMediaPeriod emits IcyHeaders + IcyInfo together on first metadata
+    // for radio.co / klubradio.hu (icy-genre header from the response).
+    val info = IcyInfo(ByteArray(0), "Radiohead - No Surprises", null)
+    val headers = IcyHeaders(
+      /* bitrate = */ 128_000,
+      /* genre = */ "Indie Rock",
+      /* name = */ "Test Radio",
+      /* url = */ null,
+      /* isPublic = */ true,
+      /* metadataInterval = */ 16_000,
+    )
+    val event = StreamMetadataExtractor.extract(Metadata(info, headers))
+
+    assertNotNull(event)
+    assertEquals("No Surprises", event!!.title)
+    assertEquals("Radiohead", event.artist)
+    assertEquals("Indie Rock", event.genre)
+  }
+
+  // ---- extract: ID3 frames (covers podcasts / MP3 streams w/ embedded ID3) ----
+
+  @Test
+  fun `extract from ID3 frames sets title and artist without splitting`() {
+    // TIT2 = title, TPE1 = lead artist. When both arrive populated, the
+    // Shoutcast " - " heuristic must NOT split the title.
+    val title = TextInformationFrame("TIT2", null, ImmutableList.of("Song - With Dash"))
+    val artist = TextInformationFrame("TPE1", null, ImmutableList.of("Artist Name"))
+    val event = StreamMetadataExtractor.extract(Metadata(title, artist))
+
+    assertNotNull(event)
+    assertEquals("Song - With Dash", event!!.title)
+    assertEquals("Artist Name", event.artist)
+  }
+
+  // ---- extract: real captured ICY payloads from the reported streams ----
+  //
+  // The strings below are NOT illustrative examples — they are the literal
+  // bytes returned by the two stations the original bug report links to,
+  // captured live from production endpoints.
+  //
+  // Capture procedure (reproducible from `scripts/capture_icy.py`):
+  //   $ scripts/capture_icy.py https://streamer.radio.co/s51a438b13/listen out.txt
+  //   $ scripts/capture_icy.py https://stream.klubradio.hu:8443/        out.txt
+  // Both servers respond with `icy-metaint: 16000` and emit Shoutcast-style
+  // `StreamTitle='…';` blocks. NUL padding to the 16-byte block boundary has
+  // been stripped (matching IcyDecoder's behavior on the real device).
+
+  @Test
+  fun `extract real radio_co track-change payload (Sonia Odisho - Eked D Bayet)`() {
+    // Captured 2026-05-20 from https://streamer.radio.co/s51a438b13/listen
+    // Raw bytes (hex): 53 74 72 65 61 6d 54 69 74 6c 65 3d 27 53 6f 6e 69 61 …
+    val event = decodeAndExtract("StreamTitle='Sonia Odisho - Eked D Bayet';")
+    assertNotNull(event)
+    assertEquals("Eked D Bayet", event!!.title)
+    assertEquals("Sonia Odisho", event.artist)
+    assertNull(event.artworkUri)
+  }
+
+  @Test
+  fun `extract real radio_co between-songs empty StreamTitle`() {
+    // Same source, captured immediately before the track-change block above.
+    // Servers commonly emit `StreamTitle='';` during silence/transitions —
+    // the extractor must NOT synthesize a bogus event in that case.
+    val event = decodeAndExtract("StreamTitle='';")
+    assertNull(event)
+  }
+
+  @Test
+  fun `extract real klubradio_hu talk-segment empty StreamTitle`() {
+    // Captured 2026-05-20 from https://stream.klubradio.hu:8443/ (redirects
+    // to hu-stream03.klubradio.hu:8443/bpstream). The Hungarian talk station
+    // sends ICY metadata frames but with empty StreamTitle during talk
+    // segments — over a 60s window only this empty payload was observed.
+    val event = decodeAndExtract("StreamTitle='';")
+    assertNull(event)
+  }
+
+  @Test
+  fun `extract handles UTF-8 multibyte chars in real-world StreamTitle`() {
+    // Both endpoints serve UTF-8; while the captured radio.co block above
+    // was pure ASCII, exercising the high-byte path is critical because
+    // IcyDecoder falls back to ISO-8859-1 on UTF-8 decode failure (would
+    // mangle Hungarian/Icelandic/etc characters).
+    val event = decodeAndExtract("StreamTitle='Sigur Rós - Hoppípolla';")
+    assertNotNull(event)
+    assertEquals("Hoppípolla", event!!.title)
+    assertEquals("Sigur Rós", event.artist)
+  }
+
+  // ---- helpers ----
+
+  /**
+   * Drives the real [IcyDecoder] used by ExoPlayer's [ProgressiveMediaPeriod]
+   * with the given Shoutcast metadata string, then runs the result through
+   * [StreamMetadataExtractor]. This exercises the same code path live streams
+   * hit at runtime.
+   */
+  private fun decodeAndExtract(icyString: String): MetadataReceivedEvent? {
+    val bytes = icyString.toByteArray(Charsets.UTF_8)
+    val buffer = MetadataInputBuffer().apply {
+      data = ByteBuffer.allocate(bytes.size).apply {
+        put(bytes)
+        flip()
+      }
+    }
+    val decoded = IcyDecoder().decode(buffer)
+    assertNotNull("IcyDecoder should produce a Metadata bundle", decoded)
+    return StreamMetadataExtractor.extract(decoded!!)
+  }
+}