react-native-audio-browser 0.2.0-next.8 → 0.2.0

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

@@ -7,12 +7,25 @@ import android.net.Uri
 import androidx.media3.common.util.BitmapLoader
 import androidx.media3.common.util.UnstableApi
 import coil3.ImageLoader
+import coil3.network.NetworkHeaders
+import coil3.network.httpHeaders
+import coil3.request.ImageRequest
+import coil3.request.allowHardware
+import coil3.svg.SvgDecoder
+import coil3.toBitmap
+import com.audiobrowser.http.RequestConfigBuilder
 import com.google.common.util.concurrent.ListenableFuture
 import com.google.common.util.concurrent.SettableFuture
+import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
+import com.margelo.nitro.audiobrowser.ImageContext
 import com.margelo.nitro.audiobrowser.ImageSource
+import com.margelo.nitro.audiobrowser.MediaTransformParams
+import com.margelo.nitro.audiobrowser.RequestConfig
+import com.margelo.nitro.audiobrowser.Track
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import timber.log.Timber
 
 /**
@@ -27,9 +40,7 @@ import timber.log.Timber
  *
  * @param context Android context
  * @param imageLoader Coil ImageLoader instance (should be shared app-wide)
- * @param resolveDisplayArtwork Track-first display-time artwork resolution (see
- *   Player.resolveDisplayArtwork). Returns the fetchable ImageSource for a URI Media3 hands us, or
- *   null when the URI is not ours to transform (it is then fetched as-is).
+ * @param getArtworkConfig Callback to get artwork configuration for URL transformation
  * @param getArtworkSizeHint Callback to get the recommended artwork size in pixels from the media
  *   browser (e.g., Android Auto)
  */
@@ -37,19 +48,20 @@ import timber.log.Timber
 class CoilBitmapLoader(
   private val context: Context,
   private val imageLoader: ImageLoader,
-  private val resolveDisplayArtwork: suspend (uri: String, sizeHintPixels: Int?) -> ImageSource?,
+  private val getArtworkConfig: () -> ArtworkConfig?,
   private val getArtworkSizeHint: () -> Int? = { null },
 ) : BitmapLoader {
 
   private val scope = CoroutineScope(Dispatchers.IO)
 
   /**
-   * Default artwork size in pixels when no hint is provided by the media browser. Lock screen media
-   * controls are ~128dp, at 4x density (xxxhdpi) = 512px.
+   * Default artwork size in pixels when no hint is provided by the media browser.
+   * Lock screen media controls are ~128dp, at 4x density (xxxhdpi) = 512px.
    */
   private val defaultArtworkSizePixels = 512
 
-  private val core = CoilArtworkLoader(context, imageLoader, defaultArtworkSizePixels)
+  /** Configuration for artwork requests including headers and URL transformation. */
+  data class ArtworkConfig(val baseConfig: RequestConfig?, val artworkConfig: ArtworkRequestConfig?)
 
   override fun supportsMimeType(mimeType: String): Boolean {
     return mimeType.startsWith("image/") ||
@@ -77,31 +89,46 @@ class CoilBitmapLoader(
 
     scope.launch {
       try {
-        val originalUrl = uri.toString()
+        val artworkUrl = uri.toString()
         // Use hint from media browser (Android Auto), or fall back to screen-based size
         val sizeHint = getArtworkSizeHint() ?: defaultArtworkSizePixels
 
-        // Track-first resolution (registry / queue lookup). Null → the URI was not
-        // produced by us (or predates the registry): fetch it as-is, never
-        // re-transform a URL we cannot attribute.
-        val source =
-          try {
-            resolveDisplayArtwork(originalUrl, sizeHint)
-          } catch (e: Exception) {
-            Timber.e(e, "Display artwork resolution failed for $originalUrl")
-            null
-          }
-        val finalUrl = source?.uri ?: originalUrl
-        val headers = source?.headers?.toMap() ?: emptyMap()
+        val (finalUrl, headers) = transformArtworkUrl(artworkUrl, sizeHint)
 
         // Check if this is an SVG that needs special decoding
         val isSvg = SvgArtworkRenderer.isSvgUrl(finalUrl)
 
         Timber.d("Loading artwork: $finalUrl (headers: ${headers.keys}, svg: $isSvg)")
 
-        val bitmap = core.load(finalUrl, headers, sizeHint, isSvg)
-        Timber.d("Loaded bitmap: ${bitmap.width}x${bitmap.height} from $finalUrl")
-        future.set(bitmap)
+        val requestBuilder =
+          ImageRequest.Builder(context)
+            .data(finalUrl)
+            .allowHardware(false) // Required for Media3 notification compatibility
+
+        // Add custom headers if present
+        if (headers.isNotEmpty()) {
+          val networkHeaders = NetworkHeaders.Builder()
+          headers.forEach { (key, value) -> networkHeaders.add(key, value) }
+          requestBuilder.httpHeaders(networkHeaders.build())
+        }
+
+        // Force SVG decoder for .svg URLs (Coil's auto-detection can fail with some CDNs)
+        if (isSvg) {
+          requestBuilder.decoderFactory { result, options, _ ->
+            SvgDecoder(result.source, options)
+          }
+        }
+
+        val result = imageLoader.execute(requestBuilder.build())
+        val bitmap = result.image?.toBitmap()
+
+        if (bitmap != null) {
+          Timber.d("Loaded bitmap: ${bitmap.width}x${bitmap.height} from $finalUrl")
+          future.set(bitmap)
+        } else {
+          Timber.e("Failed to decode image from $finalUrl - result.image was null")
+          future.setException(IllegalStateException("Failed to load bitmap from $finalUrl"))
+        }
       } catch (e: Exception) {
         Timber.e(e, "Exception loading artwork from $uri")
         future.setException(e)
@@ -110,4 +137,254 @@ class CoilBitmapLoader(
 
     return future
   }
+
+  /**
+   * Transforms an artwork URL using the configured artwork request config.
+   *
+   * Applies:
+   * - Base URL transformation
+   * - Custom headers (e.g., Authorization, API keys)
+   * - Query parameters (e.g., signed tokens)
+   * - Size query parameters from imageQueryParams config (if sizeHintPixels provided)
+   *
+   * @param originalUrl The original artwork URL from track metadata
+   * @param sizeHintPixels Optional size hint in pixels from Android Auto
+   * @return Pair of (transformedUrl, headers)
+   */
+  private suspend fun transformArtworkUrl(
+    originalUrl: String,
+    sizeHintPixels: Int? = null,
+  ): Pair<String, Map<String, String>> {
+    val config = getArtworkConfig()
+
+    // No config - return original URL with no headers
+    if (config == null || config.artworkConfig == null) {
+      return originalUrl to emptyMap()
+    }
+
+    return try {
+      val artworkConfig = config.artworkConfig
+
+      // Create base config with original URL as path
+      val baseConfig =
+        config.baseConfig ?: RequestConfig(null, null, null, null, null, null, null, null)
+
+      val urlRequestConfig = RequestConfig(null, originalUrl, null, null, null, null, null, null)
+      var mergedBaseConfig = RequestConfigBuilder.mergeConfig(baseConfig, urlRequestConfig)
+
+      // Create ImageContext from size hint if available
+      val imageContext = sizeHintPixels?.takeIf { it > 0 }?.let {
+        ImageContext(it.toDouble(), it.toDouble())
+      }
+
+      // Apply image query params BEFORE transform (so transform can override)
+      val queryParams = artworkConfig.imageQueryParams
+      if (imageContext != null && queryParams != null) {
+        val contextQuery = mutableMapOf<String, String>()
+        queryParams.width?.let { key -> imageContext.width?.let { contextQuery[key] = it.toInt().toString() } }
+        queryParams.height?.let { key -> imageContext.height?.let { contextQuery[key] = it.toInt().toString() } }
+
+        if (contextQuery.isNotEmpty()) {
+          Timber.d("Adding image query params: $contextQuery")
+          val existingQuery = mergedBaseConfig.query?.toMutableMap() ?: mutableMapOf()
+          existingQuery.putAll(contextQuery)
+          mergedBaseConfig = mergedBaseConfig.copy(query = existingQuery)
+        }
+      }
+
+      // Apply artwork transformation (transform can override imageQueryParams)
+      val finalConfig = RequestConfigBuilder.mergeConfig(mergedBaseConfig, artworkConfig, imageContext)
+
+      // Build final URL
+      val finalUrl =
+        RequestConfigBuilder.buildUrl(RequestConfigBuilder.toRequestConfig(finalConfig))
+
+      // Extract headers
+      val headers = finalConfig.headers?.toMap() ?: emptyMap()
+
+      finalUrl to headers
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to transform artwork URL: $originalUrl")
+      originalUrl to emptyMap()
+    }
+  }
+
+  /**
+   * Transforms an artwork URL for a specific track, returning a complete ImageSource.
+   *
+   * Returns an ImageSource containing:
+   * - uri: Transformed URL with query parameters for authentication
+   * - method: HTTP method (if configured)
+   * - headers: Merged headers including User-Agent and Content-Type
+   * - body: Request body (if configured)
+   *
+   * @param track The track whose artwork URL should be transformed
+   * @param perRouteConfig Optional per-route artwork config that overrides global config
+   * @param imageContext Optional size context for CDN URL generation (null at browse-time)
+   * @return ImageSource ready for React Native's Image component, or null if no artwork
+   */
+  suspend fun transformArtworkUrlForTrack(
+    track: Track,
+    perRouteConfig: ArtworkRequestConfig? = null,
+    imageContext: ImageContext? = null,
+  ): ImageSource? {
+    val globalConfig = getArtworkConfig()
+
+    // Determine effective artwork config: per-route overrides global
+    val effectiveArtworkConfig = perRouteConfig ?: globalConfig?.artworkConfig
+
+    // Treat empty string as null for artwork
+    val trackArtwork = track.artwork?.takeIf { it.isNotEmpty() }
+
+    Timber.d("transformArtworkUrlForTrack: track='${track.title}', artwork='$trackArtwork', hasConfig=${effectiveArtworkConfig != null}")
+
+    // If no artwork config and no track.artwork, nothing to transform
+    if (effectiveArtworkConfig == null && trackArtwork == null) {
+      Timber.d("transformArtworkUrlForTrack: No config and no artwork, returning null")
+      return null
+    }
+
+    // If no artwork config, just return the original artwork URL as a simple ImageSource
+    if (effectiveArtworkConfig == null) {
+      return trackArtwork?.let {
+        Timber.d("transformArtworkUrlForTrack: No config, returning original artwork: $it")
+        ImageSource(uri = it, method = null, headers = null, body = null)
+      }
+    }
+
+    return try {
+      // Create base config
+      val baseConfig =
+        globalConfig?.baseConfig ?: RequestConfig(null, null, null, null, null, null, null, null)
+
+      // Start with base config, using track.artwork as the default path if present
+      var mergedConfig =
+        if (trackArtwork != null) {
+          val urlRequestConfig =
+            RequestConfig(null, trackArtwork, null, null, null, null, null, null)
+          RequestConfigBuilder.mergeConfig(baseConfig, urlRequestConfig)
+        } else {
+          baseConfig
+        }
+
+      // If there's a resolve callback, call it to get per-track config
+      // The resolve callback receives the track directly and can return:
+      // - RequestConfig with path/query/etc for URL generation
+      // - undefined to indicate no artwork
+      val resolvedConfig = effectiveArtworkConfig.resolve?.invoke(track)?.await()?.await()
+
+      // If resolve callback exists and returned null, that means no artwork
+      if (effectiveArtworkConfig.resolve != null && resolvedConfig == null) {
+        return null
+      }
+
+      // Apply artwork base config (static fields only, not resolve)
+      val artworkStaticConfig =
+        RequestConfig(
+          effectiveArtworkConfig.method,
+          effectiveArtworkConfig.path,
+          effectiveArtworkConfig.baseUrl,
+          effectiveArtworkConfig.headers,
+          effectiveArtworkConfig.query,
+          effectiveArtworkConfig.body,
+          effectiveArtworkConfig.contentType,
+          effectiveArtworkConfig.userAgent,
+        )
+      mergedConfig = RequestConfigBuilder.mergeConfig(mergedConfig, artworkStaticConfig)
+
+      // Apply resolved per-track config if present
+      if (resolvedConfig != null) {
+        mergedConfig = RequestConfigBuilder.mergeConfig(mergedConfig, resolvedConfig)
+      }
+
+      // Apply image query params BEFORE transform (so transform can override)
+      if (imageContext != null) {
+        val queryParams = effectiveArtworkConfig.imageQueryParams
+        if (queryParams != null) {
+          val contextQuery = mutableMapOf<String, String>()
+          queryParams.width?.let { key -> imageContext.width?.let { contextQuery[key] = it.toInt().toString() } }
+          queryParams.height?.let { key -> imageContext.height?.let { contextQuery[key] = it.toInt().toString() } }
+
+          if (contextQuery.isNotEmpty()) {
+            Timber.d("Adding image query params: $contextQuery")
+            val existingQuery = mergedConfig.query?.toMutableMap() ?: mutableMapOf()
+            existingQuery.putAll(contextQuery)
+            mergedConfig = mergedConfig.copy(query = existingQuery)
+          }
+        }
+      }
+
+      // Apply transform callback if present (can override imageQueryParams)
+      val transformedConfig =
+        if (effectiveArtworkConfig.transform != null) {
+          effectiveArtworkConfig.transform.invoke(MediaTransformParams(mergedConfig, imageContext))?.await()?.await()
+            ?: mergedConfig
+        } else {
+          mergedConfig
+        }
+
+      // Build final URL
+      val uri = RequestConfigBuilder.buildUrl(transformedConfig)
+
+      // If URI is empty, there's no valid artwork path
+      if (uri.isEmpty()) {
+        Timber.d("transformArtworkUrlForTrack: Built URI is empty, returning null")
+        return null
+      }
+
+      Timber.d("transformArtworkUrlForTrack: Built URI: $uri")
+
+      // Build headers map, merging explicit headers with userAgent and contentType
+      val headers =
+        buildHeadersMap(
+          transformedConfig.headers?.toMap(),
+          transformedConfig.userAgent,
+          transformedConfig.contentType,
+        )
+
+      ImageSource(
+        uri = uri,
+        method = transformedConfig.method,
+        headers = headers,
+        body = transformedConfig.body,
+      )
+    } catch (e: Exception) {
+      Timber.e(e, "Failed to transform artwork URL for track: ${track.title}")
+      // On error, return null to clear artwork and avoid broken images
+      null
+    }
+  }
+
+  /** Builds a headers map, merging explicit headers with userAgent and contentType. */
+  private fun buildHeadersMap(
+    headers: Map<String, String>?,
+    userAgent: String?,
+    contentType: String?,
+  ): Map<String, String>? {
+    val mergedHeaders = mutableMapOf<String, String>()
+
+    // Add explicit headers
+    headers?.let { mergedHeaders.putAll(it) }
+
+    // Add User-Agent if present and not already set
+    if (userAgent != null && !mergedHeaders.containsKey("User-Agent")) {
+      mergedHeaders["User-Agent"] = userAgent
+    }
+
+    // Add Content-Type if present and not already set
+    if (contentType != null && !mergedHeaders.containsKey("Content-Type")) {
+      mergedHeaders["Content-Type"] = contentType
+    }
+
+    return mergedHeaders.ifEmpty { null }
+  }
+
+  /** Blocking version of [transformArtworkUrlForTrack] for use in synchronous contexts. */
+  fun transformArtworkUrlForTrackBlocking(
+    track: Track,
+    perRouteConfig: ArtworkRequestConfig? = null,
+    imageContext: ImageContext? = null,
+  ): ImageSource? {
+    return runBlocking { transformArtworkUrlForTrack(track, perRouteConfig, imageContext) }
+  }
 }

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

@@ -1,7 +1,6 @@
 package com.audiobrowser.util
 
 import android.media.audiofx.Equalizer
-import com.audiobrowser.player.EqualizerEffect
 import com.margelo.nitro.audiobrowser.EqualizerSettings
 import timber.log.Timber
 
@@ -11,7 +10,7 @@ import timber.log.Timber
  * Provides access to equalizer presets, band levels, and enables/disables the effect. The equalizer
  * is attached to a specific audio session ID.
  */
-internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEffect {
+class EqualizerManager(val audioSessionId: Int) {
   private var equalizer: Equalizer? = null
   private var onSettingsChanged: ((EqualizerSettings) -> Unit)? = null
 
@@ -38,7 +37,7 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
    *
    * @return Current settings or null if equalizer is not available
    */
-  override fun getSettings(): EqualizerSettings? {
+  fun getSettings(): EqualizerSettings? {
     val eq = equalizer ?: return null
 
     return try {
@@ -91,7 +90,7 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
    *
    * @param enabled true to enable, false to disable
    */
-  override fun setEnabled(enabled: Boolean) {
+  fun setEnabled(enabled: Boolean) {
     val eq = equalizer ?: return
 
     // Only notify if state actually changed
@@ -106,10 +105,18 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
    *
    * @param presetName Name of the preset to apply
    */
-  override fun setPreset(presetName: String) {
+  fun setPreset(presetName: String) {
     val eq = equalizer ?: return
 
     try {
+      // Get current preset first
+      val currentPreset =
+        try {
+          eq.currentPreset.toInt()
+        } catch (e: Exception) {
+          -1
+        }
+
       // Find preset by case-insensitive name match
       val presetIndex =
         (0 until eq.numberOfPresets).firstOrNull { index ->
@@ -117,11 +124,14 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
         }
 
       if (presetIndex != null) {
-        // Applied even when it is already the current preset: usePreset costs nothing in that
-        // case, and the caller gets an event whatever the effect reports as current.
-        eq.usePreset(presetIndex.toShort())
-        Timber.d("Applied equalizer preset: $presetName")
-        notifySettingsChanged()
+        // Only apply if it's actually a different preset
+        if (currentPreset != presetIndex) {
+          eq.usePreset(presetIndex.toShort())
+          Timber.d("Applied equalizer preset: $presetName")
+          notifySettingsChanged()
+        } else {
+          Timber.d("Preset already active: $presetName")
+        }
       } else {
         // Log available presets to help debug
         val availablePresets =
@@ -140,7 +150,7 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
    *
    * @param levels Array of levels in millibels for each band
    */
-  override fun setLevels(levels: DoubleArray) {
+  fun setLevels(levels: DoubleArray) {
     val eq = equalizer ?: return
 
     try {
@@ -166,7 +176,7 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
    *
    * @param callback Function to call with new settings
    */
-  override fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
+  fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
     onSettingsChanged = callback
   }
 
@@ -175,7 +185,7 @@ internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEff
   }
 
   /** Releases the equalizer resources. Call this when the equalizer is no longer needed. */
-  override fun release() {
+  fun release() {
     try {
       equalizer?.release()
       equalizer = null

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

@@ -39,7 +39,7 @@ object MediaExtrasBuilder {
       groupTitle = track.groupTitle,
       style = track.style,
       childrenStyle = track.childrenStyle,
-      artwork = track.artwork?.url,
+      artwork = track.artwork,
     )
 
   fun build(resolvedTrack: ResolvedTrack): Bundle =
@@ -47,7 +47,7 @@ object MediaExtrasBuilder {
       groupTitle = resolvedTrack.groupTitle,
       style = resolvedTrack.style,
       childrenStyle = resolvedTrack.childrenStyle,
-      artwork = resolvedTrack.artwork?.url,
+      artwork = resolvedTrack.artwork,
     )
 
   private fun build(

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

@@ -11,8 +11,8 @@ import com.margelo.nitro.audiobrowser.TrackMetadata
 sealed class MetadataAdapter {
   companion object {
     /**
-     * Extracts chapter metadata from ID3 ChapterFrames. Returns a list of ChapterMetadata, one per
-     * chapter.
+     * Extracts chapter metadata from ID3 ChapterFrames.
+     * Returns a list of ChapterMetadata, one per chapter.
      */
     fun extractChapters(metadata: Metadata): List<ChapterMetadata> {
       val chapters = mutableListOf<ChapterMetadata>()
@@ -31,8 +31,7 @@ sealed class MetadataAdapter {
             when (val subFrame = entry.getSubFrame(j)) {
               is TextInformationFrame -> {
                 when (subFrame.id.uppercase()) {
-                  "TIT2",
-                  "TT2" -> title = subFrame.values.firstOrNull()
+                  "TIT2", "TT2" -> title = subFrame.values.firstOrNull()
                 }
               }
               is UrlLinkFrame -> {

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

@@ -16,8 +16,7 @@ object PlayingStateFactory {
       playWhenReady &&
         !(playbackState == PlaybackState.ERROR ||
           playbackState == PlaybackState.ENDED ||
-          playbackState == PlaybackState.NONE ||
-          playbackState == PlaybackState.STOPPED)
+          playbackState == PlaybackState.NONE)
     val buffering =
       playWhenReady &&
         (playbackState == PlaybackState.LOADING || playbackState == PlaybackState.BUFFERING)

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

@@ -0,0 +1,72 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating as Media3HeartRating
+import androidx.media3.common.PercentageRating as Media3PercentRating
+import androidx.media3.common.Rating
+import androidx.media3.common.StarRating as Media3StarRating
+import androidx.media3.common.ThumbRating as Media3ThumbRating
+import com.margelo.nitro.audiobrowser.HeartRating
+import com.margelo.nitro.audiobrowser.PercentageRating
+import com.margelo.nitro.audiobrowser.StarRating
+import com.margelo.nitro.audiobrowser.ThumbsRating
+import com.margelo.nitro.audiobrowser.Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
+
+object RatingFactory {
+  fun media3ToBridge(
+    rating: Rating
+  ): Variant_HeartRating_ThumbsRating_StarRating_PercentageRating? {
+    return when (rating) {
+      is Media3HeartRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            HeartRating(rating.isHeart)
+          )
+        } else null
+      }
+
+      is Media3ThumbRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            ThumbsRating(rating.isThumbsUp)
+          )
+        } else null
+      }
+
+      is Media3StarRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            StarRating(rating.starRating.toDouble())
+          )
+        } else null
+      }
+
+      is Media3PercentRating -> {
+        if (rating.isRated) {
+          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
+            PercentageRating(rating.percent.toDouble())
+          )
+        } else null
+      }
+
+      else -> null
+    }
+  }
+
+  fun bridgeToMedia3(
+    rating: Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
+  ): Rating? {
+    return when (rating) {
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.First ->
+        Media3HeartRating(rating.value.hasHeart)
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Second ->
+        Media3ThumbRating(rating.value.isThumbsUp)
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Third ->
+        Media3StarRating(5, rating.value.stars.toFloat())
+
+      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Fourth ->
+        Media3PercentRating(rating.value.percentage.toFloat())
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.audiobrowser.util
+
+import androidx.core.net.toUri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import com.margelo.nitro.audiobrowser.ResolvedTrack
+
+object ResolvedTrackFactory {
+
+  fun toMedia3(resolvedTrack: ResolvedTrack): MediaItem {
+    val extras = MediaExtrasBuilder.build(resolvedTrack)
+
+    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
+    val artworkUri = resolvedTrack.artworkSource?.uri ?: resolvedTrack.artwork
+
+    val mediaMetadata =
+      MediaMetadata.Builder()
+        .setTitle(resolvedTrack.title)
+        .setArtist(resolvedTrack.artist)
+        .setAlbumTitle(resolvedTrack.album)
+        .setDescription(resolvedTrack.description)
+        .setGenre(resolvedTrack.genre)
+        .setArtworkUri(artworkUri?.toUri())
+        .setIsBrowsable(resolvedTrack.src == null)
+        .setIsPlayable(resolvedTrack.src != null)
+        .setExtras(extras)
+        .build()
+
+    return MediaItem.Builder()
+      .setMediaId(resolvedTrack.url)
+      .setUri(resolvedTrack.src)
+      .setMediaMetadata(mediaMetadata)
+      .setTag(resolvedTrack)
+      .build()
+  }
+}