@rntp/player 5.0.0-beta.3 → 5.0.0-beta.5

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

@@ -0,0 +1,380 @@
+package com.doublesymmetry.trackplayer.models
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import com.facebook.react.bridge.ReadableType
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkStatic
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class TrackPlayerMediaItemTest {
+
+    @Before
+    fun setUp() {
+        // Arguments.createMap() and createArray() call into native code; replace with JavaOnlyMap.
+        mockkStatic(Arguments::class)
+        every { Arguments.createMap() } answers { JavaOnlyMap() }
+    }
+
+    @After
+    fun tearDown() {
+        unmockkStatic(Arguments::class)
+    }
+
+    // ---- fromReadableMap ----
+
+    @Test
+    fun `fromReadableMap parses basic fields`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "String" }
+            every { getString("url") } returns "https://example.com/track.mp3"
+            every { hasKey("mediaId") } returns true
+            every { getString("mediaId") } returns "track-123"
+            every { hasKey("title") } returns true
+            every { getString("title") } returns "My Track"
+            every { hasKey("artist") } returns true
+            every { getString("artist") } returns "My Artist"
+            every { hasKey("albumTitle") } returns true
+            every { getString("albumTitle") } returns "My Album"
+            every { hasKey("artworkUrl") } returns true
+            every { getString("artworkUrl") } returns "https://example.com/art.jpg"
+            every { hasKey("duration") } returns true
+            every { getDouble("duration") } returns 180.5
+            every { hasKey("isLive") } returns true
+            every { getBoolean("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertEquals("track-123", item.mediaId)
+        assertEquals("https://example.com/track.mp3", item.url)
+        assertEquals("My Track", item.title)
+        assertEquals("My Artist", item.artist)
+        assertEquals("My Album", item.albumTitle)
+        assertEquals("https://example.com/art.jpg", item.artworkUrl)
+        assertEquals(180.5, item.duration!!, 0.001)
+        assertEquals(false, item.isLive)
+        assertNull(item.mimeType)
+        assertNull(item.headers)
+    }
+
+    @Test
+    fun `fromReadableMap with missing optional fields uses null`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "String" }
+            every { getString("url") } returns "https://example.com/track.mp3"
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertNull(item.mediaId)
+        assertEquals("https://example.com/track.mp3", item.url)
+        assertNull(item.title)
+        assertNull(item.artist)
+        assertNull(item.albumTitle)
+        assertNull(item.artworkUrl)
+        assertNull(item.duration)
+        assertNull(item.isLive)
+        assertNull(item.headers)
+    }
+
+    @Test
+    fun `fromReadableMap with url as object parses uri and headers`() {
+        val headersIterator = mockk<ReadableMapKeySetIterator> {
+            every { hasNextKey() } returnsMany listOf(true, true, false)
+            every { nextKey() } returnsMany listOf("Authorization", "X-Custom")
+        }
+        val headersMap = mockk<ReadableMap>(relaxed = true) {
+            every { keySetIterator() } returns headersIterator
+            every { getString("Authorization") } returns "Bearer token123"
+            every { getString("X-Custom") } returns "custom-value"
+        }
+        val urlMap = mockk<ReadableMap>(relaxed = true) {
+            every { getString("uri") } returns "https://example.com/secure.mp3"
+            every { getString("url") } returns null
+            every { getMap("headers") } returns headersMap
+        }
+
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "Map" }
+            every { getMap("url") } returns urlMap
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertEquals("https://example.com/secure.mp3", item.url)
+        assertNotNull(item.headers)
+        assertEquals("Bearer token123", item.headers!!["Authorization"])
+        assertEquals("custom-value", item.headers!!["X-Custom"])
+    }
+
+    @Test
+    fun `fromReadableMap with url object falls back to url key when uri absent`() {
+        val urlMap = mockk<ReadableMap>(relaxed = true) {
+            every { getString("uri") } returns null
+            every { getString("url") } returns "https://example.com/fallback.mp3"
+            every { getMap("headers") } returns null
+        }
+
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "Map" }
+            every { getMap("url") } returns urlMap
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+        assertEquals("https://example.com/fallback.mp3", item.url)
+    }
+
+    // ---- asMediaItem ----
+
+    @Test
+    fun `asMediaItem produces correct Media3 MediaItem`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = "track-abc",
+            url = "https://example.com/track.mp3",
+            title = "Test Track",
+            artist = "Test Artist",
+            albumTitle = "Test Album",
+            artworkUrl = "https://example.com/art.jpg",
+        )
+
+        val mediaItem = item.asMediaItem()
+
+        assertEquals("track-abc", mediaItem.mediaId)
+        assertNotNull(mediaItem.localConfiguration)
+        assertEquals("https://example.com/track.mp3", mediaItem.localConfiguration!!.uri.toString())
+        assertEquals("Test Track", mediaItem.mediaMetadata.title.toString())
+        assertEquals("Test Artist", mediaItem.mediaMetadata.artist.toString())
+        assertEquals("Test Album", mediaItem.mediaMetadata.albumTitle.toString())
+        assertEquals("https://example.com/art.jpg", mediaItem.mediaMetadata.artworkUri.toString())
+    }
+
+    @Test
+    fun `asMediaItem uses url as mediaId when mediaId is null`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = null,
+            url = "https://example.com/track.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        assertEquals("https://example.com/track.mp3", mediaItem.mediaId)
+    }
+
+    @Test
+    fun `asMediaItem stores duration and isLive in extras`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            duration = 240.0,
+            isLive = true,
+        )
+
+        val mediaItem = item.asMediaItem()
+        val extras = mediaItem.mediaMetadata.extras
+
+        assertNotNull(extras)
+        assertEquals(240.0, extras!!.getDouble("duration"), 0.001)
+        assertTrue(extras.getBoolean("isLive"))
+        assertNotNull(mediaItem.liveConfiguration)
+    }
+
+    @Test
+    fun `asMediaItem with headers stores headers in request extras`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            headers = mapOf("Authorization" to "Bearer xyz", "Accept" to "audio/*"),
+        )
+
+        val mediaItem = item.asMediaItem()
+        val requestExtras = mediaItem.requestMetadata.extras
+        assertNotNull(requestExtras)
+        val headerBundle = requestExtras!!.getBundle("headers")
+        assertNotNull(headerBundle)
+        assertEquals("Bearer xyz", headerBundle!!.getString("Authorization"))
+        assertEquals("audio/*", headerBundle.getString("Accept"))
+    }
+
+    @Test
+    fun `asMediaItem sets mediaUri in requestMetadata for http urls`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        // HTTP URIs should be set as mediaUri for Cast support
+        assertNotNull(mediaItem.requestMetadata.mediaUri)
+        assertEquals("https://example.com/track.mp3", mediaItem.requestMetadata.mediaUri.toString())
+    }
+
+    @Test
+    fun `asMediaItem does not set mediaUri for file urls`() {
+        val item = TrackPlayerMediaItem(
+            url = "file:///storage/music/local.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        // Local file URIs should not be set as mediaUri (inaccessible from Chromecast)
+        assertNull(mediaItem.requestMetadata.mediaUri)
+    }
+
+    @Test
+    fun `asMediaItem sets mimeType when provided`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            mimeType = "audio/mpeg",
+        )
+
+        val mediaItem = item.asMediaItem()
+        assertEquals("audio/mpeg", mediaItem.localConfiguration?.mimeType)
+    }
+
+    // ---- toWritableMap ----
+
+    @Test
+    fun `toWritableMap includes all fields`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = "t1",
+            url = "https://example.com/track.mp3",
+            title = "Track",
+            artist = "Artist",
+            albumTitle = "Album",
+            artworkUrl = "https://example.com/art.jpg",
+            duration = 120.0,
+            isLive = false,
+        )
+
+        val map = item.toWritableMap()
+        // WritableMap from Arguments.createMap() — verify no exception thrown and key existence
+        // (JavaOnlyMap in Robolectric supports getString/getDouble/getBoolean)
+        assertEquals("t1", map.getString("mediaId"))
+        assertEquals("https://example.com/track.mp3", map.getString("url"))
+        assertEquals("Track", map.getString("title"))
+        assertEquals("Artist", map.getString("artist"))
+        assertEquals("Album", map.getString("albumTitle"))
+        assertEquals("https://example.com/art.jpg", map.getString("artworkUrl"))
+        assertEquals(120.0, map.getDouble("duration"), 0.001)
+        assertFalse(map.getBoolean("isLive"))
+    }
+
+    @Test
+    fun `toWritableMap uses url as mediaId when mediaId is null`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = null,
+            url = "https://example.com/track.mp3",
+        )
+
+        val map = item.toWritableMap()
+        assertEquals("https://example.com/track.mp3", map.getString("mediaId"))
+    }
+
+    @Test
+    fun `toWritableMap omits null optional fields`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+        )
+
+        val map = item.toWritableMap()
+        assertFalse(map.hasKey("title"))
+        assertFalse(map.hasKey("artist"))
+        assertFalse(map.hasKey("albumTitle"))
+        assertFalse(map.hasKey("artworkUrl"))
+        assertFalse(map.hasKey("duration"))
+        assertFalse(map.hasKey("isLive"))
+    }
+
+    // ---- fromMediaItem round-trip ----
+
+    @Test
+    fun `fromMediaItem round-trips correctly`() {
+        val original = TrackPlayerMediaItem(
+            mediaId = "round-trip-id",
+            url = "https://example.com/track.mp3",
+            title = "Round Trip",
+            artist = "Artist",
+            albumTitle = "Album",
+            artworkUrl = "https://example.com/art.jpg",
+            duration = 90.0,
+        )
+
+        val mediaItem = original.asMediaItem()
+        val restored = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals("round-trip-id", restored.mediaId)
+        assertEquals("https://example.com/track.mp3", restored.url)
+        assertEquals("Round Trip", restored.title)
+        assertEquals("Artist", restored.artist)
+        assertEquals("Album", restored.albumTitle)
+        assertEquals("https://example.com/art.jpg", restored.artworkUrl)
+        assertEquals(90.0, restored.duration!!, 0.001)
+        assertNull(restored.isLive) // not set so extras won't contain "isLive"
+    }
+
+    @Test
+    fun `fromMediaItem preserves isLive true`() {
+        val original = TrackPlayerMediaItem(
+            url = "https://example.com/live.mp3",
+            isLive = true,
+        )
+
+        val mediaItem = original.asMediaItem()
+        val restored = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals(true, restored.isLive)
+    }
+
+    @Test
+    fun `fromMediaItem with no localConfiguration falls back to mediaId as url`() {
+        // Build a Media3 MediaItem without a URI (e.g., cast-only item)
+        val mediaItem = MediaItem.Builder()
+            .setMediaId("cast-item-id")
+            .setMediaMetadata(MediaMetadata.Builder().setTitle("Cast Track").build())
+            .build()
+
+        val item = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals("cast-item-id", item.mediaId)
+        // Falls back to mediaId when no localConfiguration
+        assertEquals("cast-item-id", item.url)
+        assertEquals("Cast Track", item.title)
+    }
+}

package/android/src/test/resources/robolectric.properties

@@ -0,0 +1 @@
+sdk=33

package/ios/CarPlay/RNTPCarPlaySceneDelegate.swift

@@ -115,7 +115,7 @@ class RNTPCarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDelegate
         let truncated = maxItems > 0 ? Array(items.prefix(maxItems)) : items
 
         let listItems: [CPListItem] = truncated.enumerated().map { (itemIndex, item) in
-            buildListItem(item: item, categoryIndex: categoryIndex, itemIndex: itemIndex)
+            buildListItem(item: item, parentItems: items, itemIndex: itemIndex)
         }
 
         let section = CPListSection(items: listItems)
@@ -151,15 +151,26 @@ class RNTPCarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDelegate
 
     // MARK: - List Item Builder
 
-    private func buildListItem(item: [String: Any], categoryIndex: Int, itemIndex: Int) -> CPListItem {
+    private func buildListItem(item: [String: Any], parentItems: [[String: Any]], itemIndex: Int) -> CPListItem {
         let title = item["title"] as? String ?? "Untitled"
         let artist = item["artist"] as? String
         let listItem = CPListItem(text: title, detailText: artist)
 
-        listItem.userInfo = ["categoryIndex": categoryIndex, "itemIndex": itemIndex]
-        listItem.handler = { [weak self] _, completion in
-            self?.handleItemSelected(categoryIndex: categoryIndex, itemIndex: itemIndex)
-            completion()
+        let hasUrl = item["url"] != nil
+        let children = item["children"] as? [[String: Any]]
+        let isBrowsable = children != nil && !hasUrl
+
+        if isBrowsable {
+            listItem.accessoryType = .disclosureIndicator
+            listItem.handler = { [weak self] _, completion in
+                self?.handleBrowsableSelected(item: item)
+                completion()
+            }
+        } else {
+            listItem.handler = { [weak self] _, completion in
+                self?.handlePlayableSelected(parentItems: parentItems, itemIndex: itemIndex)
+                completion()
+            }
         }
 
         // Track by mediaId for now-playing state updates
@@ -184,6 +195,22 @@ class RNTPCarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDelegate
         return listItem
     }
 
+    private func handleBrowsableSelected(item: [String: Any]) {
+        let title = item["title"] as? String ?? "Untitled"
+        let children = item["children"] as? [[String: Any]] ?? []
+
+        let maxItems = CPListTemplate.maximumItemCount
+        let truncated = maxItems > 0 ? Array(children.prefix(maxItems)) : children
+
+        let listItems = truncated.enumerated().map { (idx, child) in
+            buildListItem(item: child, parentItems: children, itemIndex: idx)
+        }
+
+        let section = CPListSection(items: listItems)
+        let template = CPListTemplate(title: title, sections: [section])
+        interfaceController?.pushTemplate(template, animated: true, completion: nil)
+    }
+
     // MARK: - Now Playing State
 
     private func updateNowPlayingState() {
@@ -198,20 +225,22 @@ class RNTPCarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDelegate
 
     // MARK: - Playback
 
-    private func handleItemSelected(categoryIndex: Int, itemIndex: Int) {
+    private func handlePlayableSelected(parentItems: [[String: Any]], itemIndex: Int) {
         guard let player = BrowseTreeStore.shared.player else { return }
-        let categories = BrowseTreeStore.shared.categories
-        guard categoryIndex < categories.count,
-              let items = categories[categoryIndex]["items"] as? [[String: Any]] else { return }
 
-        let mediaItems = items.compactMap { MediaItem(data: $0) }
+        // Collect only playable siblings (items with a url)
+        let playableItems = parentItems.filter { $0["url"] != nil }
+        let mediaItems = playableItems.compactMap { MediaItem(data: $0) }
         guard !mediaItems.isEmpty else { return }
 
+        // Find the index of the selected item among playable siblings
+        let selectedMediaId = parentItems[itemIndex]["mediaId"] as? String
+        let playableIndex = playableItems.firstIndex { ($0["mediaId"] as? String) == selectedMediaId } ?? 0
+
         player.clear()
         player.add(items: mediaItems)
-        let idx = min(itemIndex, mediaItems.count - 1)
-        if idx > 0 {
-            player.skipTo(index: idx)
+        if playableIndex > 0 {
+            player.skipTo(index: playableIndex)
         }
         player.play()
     }