react-native-audio-browser 0.1.1 → 0.2.0-next.1

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

@@ -0,0 +1,28 @@
+package com.audiobrowser.util
+
+import android.net.Uri
+import java.security.MessageDigest
+
+/** Builds and parses the opaque `content://<pkg>.audiobrowser.artwork/art/<token>` URIs. */
+object ArtworkUris {
+  const val AUTHORITY_SUFFIX = "audiobrowser.artwork"
+  private const val PATH = "art"
+
+  fun authorityFor(packageName: String): String = "$packageName.$AUTHORITY_SUFFIX"
+
+  /** Stable, opaque token for a resolved artwork URL (SHA-256 hex). */
+  fun tokenFor(url: String): String {
+    val digest = MessageDigest.getInstance("SHA-256").digest(url.toByteArray(Charsets.UTF_8))
+    return digest.joinToString("") { "%02x".format(it) }
+  }
+
+  fun contentUri(authority: String, token: String): String = "content://$authority/$PATH/$token"
+
+  /** The `<token>` for a `…/art/<token>` content URI, or null if the shape is wrong. */
+  fun parseToken(uri: Uri): String? {
+    if (uri.scheme != "content") return null
+    val segments = uri.pathSegments
+    if (segments.size != 2 || segments[0] != PATH) return null
+    return segments[1].takeIf { it.isNotEmpty() }
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.audiobrowser.util
+
+import com.margelo.nitro.audiobrowser.Variant_String_ArtworkVariants
+
+/**
+ * Reading `Track.artwork`, which is either one URL or a URL per appearance.
+ *
+ * Android Auto is dark-only, so there is nothing here to choose: a pair always
+ * resolves to its dark URL, which is also what a single-URL track would have
+ * shipped. The per-appearance half of the feature is iOS/CarPlay only — see
+ * `ios/Extension/Variant+Artwork.swift`, where both URLs are kept so a
+ * `UIImageAsset` can swap them without a re-fetch.
+ */
+val Variant_String_ArtworkVariants.url: String
+  get() = match(first = { it }, second = { it.dark })
+
+/**
+ * Wraps a plain URL as the single-URL side of the union.
+ *
+ * For the places that build a `Track` from something that only ever has one
+ * image — restored persistence, a `MediaMetadata` handed back by the platform.
+ * Restoring collapses a pair to its dark URL, which costs nothing here: Android
+ * Auto would have rendered that one anyway.
+ */
+fun artworkOf(url: String?): Variant_String_ArtworkVariants? =
+  url?.let { Variant_String_ArtworkVariants.First(it) }

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

@@ -32,6 +32,12 @@ object BrowserPathHelper {
   /** Offline error placeholder media ID */
   const val OFFLINE_PATH = "/__offline"
 
+  /** Generic browse error placeholder media ID */
+  const val ERROR_PATH = "/__error"
+
+  /** Browse Gate placeholder media ID (subscription/login/region block) */
+  const val GATE_PATH = "/__gate"
+
   // Query parameter name for contextual track identifiers
   private const val CONTEXTUAL_TRACK_PARAM = "__trackId"
 
@@ -152,4 +158,22 @@ object BrowserPathHelper {
     val normalizedPath = path.trimStart('/')
     return "$normalizedBase$normalizedPath"
   }
+
+  /**
+   * True if [segment] appears in [path] as a complete path segment — bounded on the left by the
+   * string start or `/`, and on the right by the string end or one of `/`, `?`, `#`.
+   */
+  fun containsSegment(path: String, segment: String): Boolean {
+    if (segment.isEmpty()) return false
+    var from = 0
+    while (true) {
+      val idx = path.indexOf(segment, from)
+      if (idx < 0) return false
+      val beforeOk = idx == 0 || path[idx - 1] == '/'
+      val end = idx + segment.length
+      val afterOk = end == path.length || path[end] == '/' || path[end] == '?' || path[end] == '#'
+      if (beforeOk && afterOk) return true
+      from = idx + 1
+    }
+  }
 }

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

@@ -0,0 +1,49 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.graphics.Bitmap
+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
+
+/**
+ * Shared "resolved source → Bitmap" core. Used by both [CoilBitmapLoader] (now-playing) and
+ * [ArtworkContentProvider] (browse). Adds `.size()` so raster decodes are downsampled to the hint
+ * (the prior loadBitmap path decoded at full resolution). SVG is forced via [isSvg], carried from
+ * build time rather than re-derived from a possibly-suffixless transformed URL.
+ */
+class CoilArtworkLoader(
+  private val context: Context,
+  private val imageLoader: ImageLoader,
+  private val defaultSizePixels: Int = 512,
+) {
+  suspend fun load(
+    finalUrl: String,
+    headers: Map<String, String>?,
+    sizeHintPixels: Int?,
+    isSvg: Boolean,
+  ): Bitmap {
+    val builder =
+      ImageRequest.Builder(context)
+        .data(finalUrl)
+        .size(sizeHintPixels ?: defaultSizePixels)
+        .allowHardware(false) // required for Media3 notification compatibility
+
+    if (!headers.isNullOrEmpty()) {
+      val net = NetworkHeaders.Builder()
+      headers.forEach { (k, v) -> net.add(k, v) }
+      builder.httpHeaders(net.build())
+    }
+    if (isSvg) {
+      builder.decoderFactory { result, options, _ -> SvgDecoder(result.source, options) }
+    }
+
+    val result = imageLoader.execute(builder.build())
+    return result.image?.toBitmap()
+      ?: throw IllegalStateException("Failed to decode artwork from $finalUrl")
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.audiobrowser.util
+
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import kotlinx.coroutines.CoroutineScope
+
+/** Dependencies the exported [ArtworkContentProvider] needs, published by the media Service. */
+data class ArtworkProviderDeps(
+  val loader: CoilArtworkLoader,
+  val registry: BrowseArtworkRegistry,
+  val scope: CoroutineScope,
+  val artworkSizeHint: () -> Int? = { null },
+)
+
+/**
+ * Process-wide handoff between the media Service (which builds the deps) and the ContentProvider
+ * (which the OS may instantiate before the Service exists). `@Volatile` publishes the reference
+ * safely across the binder/main threads.
+ */
+object CoilArtworkLoaderHolder {
+  @Volatile private var deps: ArtworkProviderDeps? = null
+
+  fun set(deps: ArtworkProviderDeps) {
+    this.deps = deps
+  }
+
+  fun get(): ArtworkProviderDeps? = deps
+
+  /**
+   * Clears only if [deps] is still the current one — prevents a stale Service from blanking a
+   * newer.
+   */
+  @Synchronized
+  fun clearIf(deps: ArtworkProviderDeps) {
+    if (this.deps === deps) this.deps = null
+  }
+}

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

@@ -7,25 +7,12 @@ 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
 
 /**
@@ -40,7 +27,9 @@ import timber.log.Timber
  *
  * @param context Android context
  * @param imageLoader Coil ImageLoader instance (should be shared app-wide)
- * @param getArtworkConfig Callback to get artwork configuration for URL transformation
+ * @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 getArtworkSizeHint Callback to get the recommended artwork size in pixels from the media
  *   browser (e.g., Android Auto)
  */
@@ -48,20 +37,19 @@ import timber.log.Timber
 class CoilBitmapLoader(
   private val context: Context,
   private val imageLoader: ImageLoader,
-  private val getArtworkConfig: () -> ArtworkConfig?,
+  private val resolveDisplayArtwork: suspend (uri: String, sizeHintPixels: Int?) -> ImageSource?,
   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
 
-  /** Configuration for artwork requests including headers and URL transformation. */
-  data class ArtworkConfig(val baseConfig: RequestConfig?, val artworkConfig: ArtworkRequestConfig?)
+  private val core = CoilArtworkLoader(context, imageLoader, defaultArtworkSizePixels)
 
   override fun supportsMimeType(mimeType: String): Boolean {
     return mimeType.startsWith("image/") ||
@@ -89,46 +77,31 @@ class CoilBitmapLoader(
 
     scope.launch {
       try {
-        val artworkUrl = uri.toString()
+        val originalUrl = uri.toString()
         // Use hint from media browser (Android Auto), or fall back to screen-based size
         val sizeHint = getArtworkSizeHint() ?: defaultArtworkSizePixels
 
-        val (finalUrl, headers) = transformArtworkUrl(artworkUrl, sizeHint)
+        // 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()
 
         // 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 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"))
-        }
+        val bitmap = core.load(finalUrl, headers, sizeHint, isSvg)
+        Timber.d("Loaded bitmap: ${bitmap.width}x${bitmap.height} from $finalUrl")
+        future.set(bitmap)
       } catch (e: Exception) {
         Timber.e(e, "Exception loading artwork from $uri")
         future.setException(e)
@@ -137,254 +110,4 @@ 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,6 +1,7 @@
 package com.audiobrowser.util
 
 import android.media.audiofx.Equalizer
+import com.audiobrowser.player.EqualizerEffect
 import com.margelo.nitro.audiobrowser.EqualizerSettings
 import timber.log.Timber
 
@@ -10,7 +11,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.
  */
-class EqualizerManager(val audioSessionId: Int) {
+internal class EqualizerManager(override val audioSessionId: Int) : EqualizerEffect {
   private var equalizer: Equalizer? = null
   private var onSettingsChanged: ((EqualizerSettings) -> Unit)? = null
 
@@ -37,7 +38,7 @@ class EqualizerManager(val audioSessionId: Int) {
    *
    * @return Current settings or null if equalizer is not available
    */
-  fun getSettings(): EqualizerSettings? {
+  override fun getSettings(): EqualizerSettings? {
     val eq = equalizer ?: return null
 
     return try {
@@ -90,7 +91,7 @@ class EqualizerManager(val audioSessionId: Int) {
    *
    * @param enabled true to enable, false to disable
    */
-  fun setEnabled(enabled: Boolean) {
+  override fun setEnabled(enabled: Boolean) {
     val eq = equalizer ?: return
 
     // Only notify if state actually changed
@@ -105,18 +106,10 @@ class EqualizerManager(val audioSessionId: Int) {
    *
    * @param presetName Name of the preset to apply
    */
-  fun setPreset(presetName: String) {
+  override 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 ->
@@ -124,14 +117,11 @@ class EqualizerManager(val audioSessionId: Int) {
         }
 
       if (presetIndex != null) {
-        // 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")
-        }
+        // 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()
       } else {
         // Log available presets to help debug
         val availablePresets =
@@ -150,7 +140,7 @@ class EqualizerManager(val audioSessionId: Int) {
    *
    * @param levels Array of levels in millibels for each band
    */
-  fun setLevels(levels: DoubleArray) {
+  override fun setLevels(levels: DoubleArray) {
     val eq = equalizer ?: return
 
     try {
@@ -176,7 +166,7 @@ class EqualizerManager(val audioSessionId: Int) {
    *
    * @param callback Function to call with new settings
    */
-  fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
+  override fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
     onSettingsChanged = callback
   }
 
@@ -185,7 +175,7 @@ class EqualizerManager(val audioSessionId: Int) {
   }
 
   /** Releases the equalizer resources. Call this when the equalizer is no longer needed. */
-  fun release() {
+  override 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,
+      artwork = track.artwork?.url,
     )
 
   fun build(resolvedTrack: ResolvedTrack): Bundle =
@@ -47,7 +47,7 @@ object MediaExtrasBuilder {
       groupTitle = resolvedTrack.groupTitle,
       style = resolvedTrack.style,
       childrenStyle = resolvedTrack.childrenStyle,
-      artwork = resolvedTrack.artwork,
+      artwork = resolvedTrack.artwork?.url,
     )
 
   private fun build(