react-native-audio-browser 0.0.1 → 0.1.0-next.2

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,63 @@
+package com.audiobrowser.browser
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+// TODO: Most tests disabled — BrowserConfig API changed (routes is now Array<NativeRouteEntry>).
+// Tests that used BrowserSource/BrowserList need to be rewritten.
+
+@RunWith(RobolectricTestRunner::class)
+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 throws ContentNotFoundException`() {
+    runBlocking {
+      browserManager.config = BrowserConfig()
+      try {
+        browserManager.navigate("/test")
+        fail("Expected ContentNotFoundException")
+      } catch (e: ContentNotFoundException) {
+        assertEquals("/test", e.path)
+      }
+    }
+  }
+
+  @Test
+  fun `navigate updates current path`() {
+    runBlocking {
+      browserManager.config = BrowserConfig()
+      try {
+        browserManager.navigate("/artists/123")
+      } catch (_: ContentNotFoundException) {}
+
+      assertEquals("/artists/123", browserManager.getPath())
+    }
+  }
+
+  @Test
+  fun `navigate with empty path throws ContentNotFoundException`() {
+    runBlocking {
+      browserManager.config = BrowserConfig()
+      try {
+        browserManager.navigate("")
+        fail("Expected ContentNotFoundException")
+      } catch (_: ContentNotFoundException) {}
+    }
+  }
+}

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

@@ -0,0 +1,38 @@
+package com.audiobrowser.browser
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+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 throws ContentNotFoundException`() {
+    runBlocking {
+      val browserManager = BrowserManager()
+      browserManager.config = BrowserConfig()
+      try {
+        browserManager.navigate("/test")
+        fail("Expected ContentNotFoundException")
+      } catch (_: ContentNotFoundException) {}
+    }
+  }
+}

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

@@ -0,0 +1,165 @@
+package com.audiobrowser.browser
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class SimpleRouterTest {
+
+  private val router = SimpleRouter()
+
+  // -- exact matches --
+
+  @Test
+  fun `matches a simple path`() {
+    val result = router.findBestMatch("/artists", mapOf("/artists" to true))
+    assertNotNull(result)
+    assertEquals("/artists", result!!.first)
+    assertTrue(result.second.params.isEmpty())
+  }
+
+  @Test
+  fun `matches multi-segment paths`() {
+    val result = router.findBestMatch("/artists/top/rated", mapOf("/artists/top/rated" to true))
+    assertNotNull(result)
+    assertEquals("/artists/top/rated", result!!.first)
+  }
+
+  @Test
+  fun `returns null when no route matches`() {
+    assertNull(router.findBestMatch("/unknown", mapOf("/artists" to true)))
+  }
+
+  @Test
+  fun `returns null when segment count differs`() {
+    assertNull(router.findBestMatch("/artists/123", mapOf("/artists" to true)))
+  }
+
+  @Test
+  fun `returns null when routes are empty`() {
+    assertNull(router.findBestMatch("/artists", emptyMap<String, Boolean>()))
+  }
+
+  @Test
+  fun `treats trailing slashes the same as without`() {
+    val result = router.findBestMatch("/artists/", mapOf("/artists" to true))
+    assertNotNull(result)
+    assertEquals("/artists", result!!.first)
+  }
+
+  // -- parameter extraction --
+
+  @Test
+  fun `extracts a single parameter`() {
+    val result = router.findBestMatch("/artists/123", mapOf("/artists/{id}" to true))
+    assertNotNull(result)
+    assertEquals(mapOf("id" to "123"), result!!.second.params)
+  }
+
+  @Test
+  fun `extracts multiple parameters`() {
+    val result =
+      router.findBestMatch(
+        "/artists/123/albums/456",
+        mapOf("/artists/{artistId}/albums/{albumId}" to true),
+      )
+    assertNotNull(result)
+    assertEquals(mapOf("artistId" to "123", "albumId" to "456"), result!!.second.params)
+  }
+
+  // -- single wildcard --
+
+  @Test
+  fun `matches any single segment`() {
+    assertNotNull(router.findBestMatch("/artists/anything", mapOf("/artists/*" to true)))
+  }
+
+  @Test
+  fun `does not extract wildcard value into params`() {
+    val result = router.findBestMatch("/artists/anything", mapOf("/artists/*" to true))
+    assertTrue(result!!.second.params.isEmpty())
+  }
+
+  // -- tail wildcard --
+
+  @Test
+  fun `matches with no remaining segments and has no tail param`() {
+    val result = router.findBestMatch("/files", mapOf("/files/**" to true))
+    assertNotNull(result)
+    assertTrue(result!!.second.params.isEmpty())
+  }
+
+  @Test
+  fun `matches with remaining segments and captures tail`() {
+    val result = router.findBestMatch("/files/a/b/c", mapOf("/files/**" to true))
+    assertNotNull(result)
+    assertEquals(mapOf("tail" to "a/b/c"), result!!.second.params)
+  }
+
+  @Test
+  fun `matches with a single remaining segment`() {
+    val result = router.findBestMatch("/files/readme.txt", mapOf("/files/**" to true))
+    assertNotNull(result)
+    assertEquals(mapOf("tail" to "readme.txt"), result!!.second.params)
+  }
+
+  @Test
+  fun `returns null when prefix segments do not match`() {
+    assertNull(router.findBestMatch("/other/a/b", mapOf("/files/**" to true)))
+  }
+
+  @Test
+  fun `works with parameters before tail wildcard`() {
+    val result =
+      router.findBestMatch("/api/v1/users/list", mapOf("/api/{version}/**" to true))
+    assertNotNull(result)
+    assertEquals(mapOf("version" to "v1", "tail" to "users/list"), result!!.second.params)
+  }
+
+  @Test
+  fun `matches any path with bare tail wildcard pattern`() {
+    val result = router.findBestMatch("/any/path/here", mapOf("/**" to true))
+    assertNotNull(result)
+    assertEquals(mapOf("tail" to "any/path/here"), result!!.second.params)
+  }
+
+  // -- specificity --
+
+  @Test
+  fun `prefers constant segments over parameters`() {
+    val routes = mapOf("/artists/{id}" to true, "/artists/top" to true)
+    val result = router.findBestMatch("/artists/top", routes)
+    assertEquals("/artists/top", result!!.first)
+  }
+
+  @Test
+  fun `prefers parameters over wildcards`() {
+    val routes = mapOf("/artists/*" to true, "/artists/{id}" to true)
+    val result = router.findBestMatch("/artists/123", routes)
+    assertEquals("/artists/{id}", result!!.first)
+  }
+
+  @Test
+  fun `prefers exact match over tail wildcard`() {
+    val routes = mapOf("/api/**" to true, "/api/{version}" to true)
+    val result = router.findBestMatch("/api/v1", routes)
+    assertEquals("/api/{version}", result!!.first)
+  }
+
+  @Test
+  fun `computes correct specificity for tail wildcard patterns`() {
+    // Regression test for issue #27: specificity must account for
+    // segment types before the ** wildcard.
+    val result = router.findBestMatch("/api/v1/users", mapOf("/api/v1/**" to true))
+    // constant "api" (1000) + constant "v1" (1000) + tail(1) + 3 segments = 2004
+    assertEquals(2004, result!!.second.specificity)
+  }
+
+  @Test
+  fun `prefers constant prefix over parameter prefix in tail wildcards`() {
+    // Second part of issue #27: with correct specificity, the constant
+    // prefix should beat the parameter prefix.
+    val routes = mapOf("/api/{version}/**" to true, "/api/v1/**" to true)
+    val result = router.findBestMatch("/api/v1/users", routes)
+    assertEquals("/api/v1/**", result!!.first)
+  }
+}