@5stones/react-native-audio-browser 0.1.0

package/android/src/main/java/com/audiobrowser/util/SvgArtworkRenderer.kt

@@ -0,0 +1,130 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import androidx.media3.common.MediaMetadata
+import coil3.ImageLoader
+import coil3.request.ImageRequest
+import coil3.request.allowHardware
+import coil3.svg.SvgDecoder
+import coil3.toBitmap
+import java.io.ByteArrayOutputStream
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+
+/**
+ * Utility for pre-rendering SVG artwork to bitmaps for Android Auto compatibility.
+ *
+ * Android Auto loads artwork from URLs directly and doesn't support SVG format.
+ * This class pre-renders SVG images to PNG bitmaps that can be embedded in MediaMetadata
+ * using setArtworkData().
+ *
+ * Note: SVGs are rendered as-is without tinting. Content providers should provide
+ * appropriately colored icons for Android Auto's dark UI (e.g., white icons).
+ */
+object SvgArtworkRenderer {
+
+  private const val DEFAULT_SIZE = 256 // Default size for rendered SVGs
+
+  /**
+   * Checks if a URL points to an SVG image.
+   */
+  fun isSvgUrl(url: String?): Boolean {
+    if (url == null) return false
+    return try {
+      val uri = Uri.parse(url)
+      uri.path?.lowercase()?.endsWith(".svg") == true
+    } catch (e: Exception) {
+      false
+    }
+  }
+
+  /**
+   * Pre-renders an SVG URL to PNG bitmap bytes.
+   *
+   * The SVG is rendered as-is without color modification. Content providers
+   * should provide icons in the appropriate color for the target UI (e.g.,
+   * white icons for Android Auto's dark background).
+   *
+   * @param context Android context
+   * @param imageLoader Coil ImageLoader instance
+   * @param url The SVG URL to render
+   * @param size Target size in pixels (width and height)
+   * @return PNG bitmap bytes, or null if rendering fails
+   */
+  suspend fun renderSvgToBytes(
+    context: Context,
+    imageLoader: ImageLoader,
+    url: String,
+    size: Int = DEFAULT_SIZE,
+  ): ByteArray? = withContext(Dispatchers.IO) {
+    try {
+      Timber.d("Pre-rendering SVG: $url")
+
+      val request = ImageRequest.Builder(context)
+        .data(url)
+        .size(size)
+        .allowHardware(false)
+        .decoderFactory { result, options, _ ->
+          SvgDecoder(result.source, options)
+        }
+        .build()
+
+      val result = imageLoader.execute(request)
+      val bitmap = result.image?.toBitmap()
+
+      if (bitmap != null) {
+        Timber.d("SVG rendered successfully: ${bitmap.width}x${bitmap.height}")
+
+        val stream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+        stream.toByteArray()
+      } else {
+        Timber.e("Failed to render SVG: result.image was null")
+        null
+      }
+    } catch (e: Exception) {
+      Timber.e(e, "Error pre-rendering SVG: $url")
+      null
+    }
+  }
+
+  /**
+   * Applies artwork to MediaMetadata.Builder, pre-rendering SVGs as needed.
+   *
+   * For SVG URLs, this renders the image to PNG and uses setArtworkData().
+   * For other URLs, this uses setArtworkUri() as normal.
+   *
+   * @param builder The MediaMetadata.Builder to modify
+   * @param artworkUrl The artwork URL (may be SVG or other format)
+   * @param context Android context (required for SVG rendering)
+   * @param imageLoader Coil ImageLoader (required for SVG rendering)
+   * @return The modified builder
+   */
+  suspend fun applyArtwork(
+    builder: MediaMetadata.Builder,
+    artworkUrl: String?,
+    context: Context?,
+    imageLoader: ImageLoader?,
+  ): MediaMetadata.Builder {
+    if (artworkUrl == null) {
+      return builder
+    }
+
+    // Check if this is an SVG that needs pre-rendering
+    if (isSvgUrl(artworkUrl) && context != null && imageLoader != null) {
+      val bytes = renderSvgToBytes(context, imageLoader, artworkUrl)
+      if (bytes != null) {
+        Timber.d("Using pre-rendered SVG artwork (${bytes.size} bytes)")
+        return builder.setArtworkData(bytes, MediaMetadata.PICTURE_TYPE_FRONT_COVER)
+      }
+      // Fall through to setArtworkUri if rendering fails
+      Timber.w("SVG pre-rendering failed, falling back to URI")
+    }
+
+    // Use URI for non-SVG or if SVG rendering failed
+    return builder.setArtworkUri(Uri.parse(artworkUrl))
+  }
+}

package/android/src/main/java/com/audiobrowser/util/SystemVolumeMonitor.kt

@@ -0,0 +1,50 @@
+package com.audiobrowser.util
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+
+/**
+ * Monitors system volume state and notifies listeners when the volume changes.
+ *
+ * Uses a BroadcastReceiver for VOLUME_CHANGED_ACTION to detect volume changes.
+ * Reports volume as a normalized value between 0.0 and 1.0.
+ */
+class SystemVolumeMonitor(private val context: Context) {
+  private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+  private var onVolumeChanged: ((Double) -> Unit)? = null
+
+  fun getVolume(): Double = getCurrentVolume()
+
+  fun setVolume(volume: Double) {
+    val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
+    val newVolume = (volume.coerceIn(0.0, 1.0) * maxVolume).toInt()
+    audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, newVolume, 0)
+  }
+
+  fun setOnVolumeChanged(callback: (Double) -> Unit) {
+    onVolumeChanged = callback
+  }
+
+  private fun getCurrentVolume(): Double {
+    val currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
+    val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
+    return if (maxVolume > 0) currentVolume.toDouble() / maxVolume else 0.0
+  }
+
+  private val volumeReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      val streamType = intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1)
+      if (streamType == AudioManager.STREAM_MUSIC) {
+        onVolumeChanged?.invoke(getCurrentVolume())
+      }
+    }
+  }
+
+  init {
+    context.registerReceiver(volumeReceiver, IntentFilter("android.media.VOLUME_CHANGED_ACTION"))
+  }
+}

package/android/src/main/java/com/audiobrowser/util/TrackFactory.kt

@@ -0,0 +1,125 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import androidx.core.net.toUri
+import androidx.media3.common.HeartRating
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import coil3.ImageLoader
+import com.margelo.nitro.audiobrowser.Track
+
+object TrackFactory {
+  fun fromMedia3(mediaItem: MediaItem): Track {
+    return mediaItem.localConfiguration!!.tag as Track
+  }
+
+  fun toMedia3(tracks: Array<Track>): List<MediaItem> {
+    return tracks.map { toMedia3(it) }
+  }
+
+  /**
+   * Converts a Track to a Media3 MediaItem.
+   *
+   * Note: This synchronous version uses setArtworkUri() which doesn't support SVG.
+   * For Android Auto browse items with SVG artwork, use [toMedia3WithSvgSupport] instead.
+   */
+  fun toMedia3(track: Track): MediaItem {
+    val extras = MediaExtrasBuilder.build(track)
+
+    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
+    val artworkUri = track.artworkSource?.uri ?: track.artwork
+
+    val mediaMetadata =
+      MediaMetadata.Builder()
+        .setTitle(track.title)
+        .setArtist(track.artist)
+        .setAlbumTitle(track.album)
+        .setDescription(track.description)
+        .setGenre(track.genre)
+        .setArtworkUri(artworkUri?.toUri())
+        .setIsBrowsable(track.src == null)
+        .setIsPlayable(track.src != null)
+        .setExtras(extras)
+        .apply { track.favorited?.let { setUserRating(HeartRating(it)) } }
+        .build()
+
+    val mediaId =
+      track.url
+        ?: track.src
+        ?: throw IllegalArgumentException(
+          "Track must have either url or src defined. Track: title='${track.title}', artist='${track.artist}'"
+        )
+
+    return MediaItem.Builder()
+      .setMediaId(mediaId)
+      .setUri(track.src)
+      .setMediaMetadata(mediaMetadata)
+      .setTag(track)
+      .build()
+  }
+
+  /**
+   * Converts a Track to a Media3 MediaItem with SVG artwork support.
+   *
+   * For SVG artwork URLs, this pre-renders the image to PNG and embeds it
+   * using setArtworkData(). This is necessary for Android Auto which doesn't
+   * support loading SVG images from URLs.
+   *
+   * @param track The track to convert
+   * @param context Android context for image loading
+   * @param imageLoader Coil ImageLoader for SVG rendering
+   * @return MediaItem with embedded artwork for SVGs, or URI-based artwork for other formats
+   */
+  suspend fun toMedia3WithSvgSupport(
+    track: Track,
+    context: Context,
+    imageLoader: ImageLoader,
+  ): MediaItem {
+    val extras = MediaExtrasBuilder.build(track)
+
+    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
+    val artworkUrl = track.artworkSource?.uri ?: track.artwork
+
+    // Build metadata with SVG support
+    val metadataBuilder = MediaMetadata.Builder()
+      .setTitle(track.title)
+      .setArtist(track.artist)
+      .setAlbumTitle(track.album)
+      .setDescription(track.description)
+      .setGenre(track.genre)
+      .setIsBrowsable(track.src == null)
+      .setIsPlayable(track.src != null)
+      .setExtras(extras)
+      .apply { track.favorited?.let { setUserRating(HeartRating(it)) } }
+
+    // Apply artwork with SVG pre-rendering if needed
+    SvgArtworkRenderer.applyArtwork(metadataBuilder, artworkUrl, context, imageLoader)
+
+    val mediaMetadata = metadataBuilder.build()
+
+    val mediaId =
+      track.url
+        ?: track.src
+        ?: throw IllegalArgumentException(
+          "Track must have either url or src defined. Track: title='${track.title}', artist='${track.artist}'"
+        )
+
+    return MediaItem.Builder()
+      .setMediaId(mediaId)
+      .setUri(track.src)
+      .setMediaMetadata(mediaMetadata)
+      .setTag(track)
+      .build()
+  }
+
+  /**
+   * Converts multiple Tracks to Media3 MediaItems with SVG artwork support.
+   */
+  suspend fun toMedia3WithSvgSupport(
+    tracks: Array<Track>,
+    context: Context,
+    imageLoader: ImageLoader,
+  ): List<MediaItem> {
+    return tracks.map { toMedia3WithSvgSupport(it, context, imageLoader) }
+  }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Error message shown in Android Auto when network is offline -->
+    <string name="audio_browser_offline_error">No internet connection</string>
+    <string name="audio_browser_offline_error_subtitle">Check your connection and try again</string>
+</resources>

package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt

@@ -0,0 +1,273 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.BrowserList
+import com.margelo.nitro.audiobrowser.BrowserSource
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+
+class BrowserManagerTest {
+
+  private lateinit var browserManager: BrowserManager
+
+  @Before
+  fun setup() {
+    browserManager = BrowserManager()
+  }
+
+  @Test
+  fun `getPath returns default path initially`() {
+    assertEquals("/", browserManager.getPath())
+  }
+
+  @Test
+  fun `navigate with no routes and no browse fallback returns empty list`() = runBlocking {
+    browserManager.config = BrowserConfig()
+    val result = browserManager.navigate("/test")
+
+    assertEquals("No content configured for this path", result.title)
+    assertEquals("/test", result.url)
+    assertTrue(result.children.isEmpty())
+  }
+
+  @Test
+  fun `navigate updates current path`() = runBlocking {
+    browserManager.config = BrowserConfig()
+    browserManager.navigate("/artists/123")
+
+    assertEquals("/artists/123", browserManager.getPath())
+  }
+
+  @Test
+  fun `navigate with route match uses route source`() = runBlocking {
+    // Create a mock static BrowserList
+    val staticList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/artists/123",
+        title = "Artist 123",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val routes = mapOf("/artists/{id}" to BrowserSource.create(staticList))
+
+    browserManager.config = BrowserConfig(routes = routes)
+    val result = browserManager.navigate("/artists/123")
+
+    assertEquals("Artist 123", result.title)
+    assertEquals("/artists/123", result.url)
+  }
+
+  @Test
+  fun `navigate with browse fallback when no route matches`() = runBlocking {
+    // Create a mock static BrowserList for browse
+    val browseList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/unknown",
+        title = "Browse Fallback",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val browse =
+      com.margelo.nitro.audiobrowser
+        .Variant__param__BrowserSourceCallbackParam_____Promise_Promise_BrowserList___TransformableRequestConfig_BrowserList
+        .create(browseList)
+
+    browserManager.config = BrowserConfig(browse = browse)
+    val result = browserManager.navigate("/unknown")
+
+    assertEquals("Browse Fallback", result.title)
+  }
+
+  @Test
+  fun `search with no search source returns empty array`() = runBlocking {
+    browserManager.config = BrowserConfig()
+    val result = browserManager.search("test query")
+
+    assertTrue(result.children.isNullOrEmpty())
+  }
+
+  @Test
+  fun `route matching respects specificity`() = runBlocking {
+    val genericList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/artists/popular",
+        title = "Generic Artist",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val specificList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/artists/popular",
+        title = "Popular Artists",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val routes =
+      mapOf(
+        "/artists/{id}" to BrowserSource.create(genericList),
+        "/artists/popular" to BrowserSource.create(specificList),
+      )
+
+    browserManager.config = BrowserConfig(routes = routes)
+    val result = browserManager.navigate("/artists/popular")
+
+    // Should match the more specific route
+    assertEquals("Popular Artists", result.title)
+  }
+
+  @Test
+  fun `route parameters are extracted correctly`() = runBlocking {
+    // Create a mock static BrowserList instead of using callbacks
+    val testList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/artists/123/albums/456",
+        title = "Test Result",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val routes = mapOf("/artists/{id}/albums/{albumId}" to BrowserSource.create(testList))
+
+    browserManager.config = BrowserConfig(routes = routes)
+    val result = browserManager.navigate("/artists/123/albums/456")
+
+    // Verify the route was matched and static content returned
+    assertEquals("Test Result", result.title)
+    assertEquals("/artists/123/albums/456", result.url)
+
+    // Also verify the SimpleRouter extracted params correctly
+    val router = SimpleRouter()
+    val match = router.findBestMatch("/artists/123/albums/456", routes)
+    assertNotNull(match)
+    assertEquals("123", match!!.second.params["id"])
+    assertEquals("456", match.second.params["albumId"])
+  }
+
+  @Test
+  fun `wildcard routes work correctly`() = runBlocking {
+    val wildcardList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/files/anything",
+        title = "Wildcard Match",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val routes = mapOf("/files/*" to BrowserSource.create(wildcardList))
+
+    browserManager.config = BrowserConfig(routes = routes)
+    val result = browserManager.navigate("/files/document.pdf")
+
+    assertEquals("Wildcard Match", result.title)
+  }
+
+  @Test
+  fun `tail wildcard routes work correctly`() = runBlocking {
+    // Create a mock static BrowserList
+    val testList =
+      BrowserList(
+        children = arrayOf(),
+        style = null,
+        playable = null,
+        url = "/files/docs/readme.md",
+        title = "File Browser",
+        subtitle = null,
+        icon = null,
+        artwork = null,
+        artist = null,
+        album = null,
+        description = null,
+        genre = null,
+        duration = null,
+      )
+
+    val routes = mapOf("/files/**" to BrowserSource.create(testList))
+
+    browserManager.config = BrowserConfig(routes = routes)
+    val result = browserManager.navigate("/files/docs/readme.md")
+
+    // Verify the route was matched
+    assertEquals("File Browser", result.title)
+
+    // Also verify the SimpleRouter captured tail correctly
+    val router = SimpleRouter()
+    val match = router.findBestMatch("/files/docs/readme.md", routes)
+    assertNotNull(match)
+    assertEquals("/files/**", match!!.first)
+    assertEquals("docs/readme.md", match.second.params["tail"])
+  }
+
+  @Test
+  fun `error handling can be tested with invalid config`() = runBlocking {
+    // Test error handling by creating an invalid scenario
+    // Since we can't easily create throwing callbacks, we can test other error scenarios
+    val browserManager = BrowserManager()
+
+    // This should not throw but handle gracefully
+    browserManager.config = BrowserConfig()
+    val result = browserManager.navigate("")
+
+    // Should return a valid response even for empty path
+    assertNotNull(result)
+    assertNotNull(result.title)
+  }
+}

package/android/src/test/java/com/audiobrowser/browser/SimpleBrowserTest.kt

@@ -0,0 +1,33 @@
+package com.audiobrowser.browser
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.*
+import org.junit.Test
+
+class SimpleBrowserTest {
+
+  @Test
+  fun `basic test without promises`() {
+    val browserManager = BrowserManager()
+    assertEquals("/", browserManager.getPath())
+  }
+
+  @Test
+  fun `simple router test`() {
+    val router = SimpleRouter()
+    val routes = mapOf("/test" to "value")
+    val match = router.findBestMatch("/test", routes)
+    assertNotNull(match)
+    assertEquals("/test", match!!.first)
+  }
+
+  @Test
+  fun `navigate with empty config returns empty list`() = runBlocking {
+    val browserManager = BrowserManager()
+    browserManager.config = BrowserConfig()
+    val result = browserManager.navigate("/test")
+
+    assertEquals("No content configured for this path", result.title)
+    assertEquals("/test", result.url)
+  }
+}