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

package/android/src/main/java/com/audiobrowser/player/EqualizerController.kt

@@ -1,153 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.C
-import com.audiobrowser.util.EqualizerManager
-import com.margelo.nitro.audiobrowser.EqualizerSettings
-import timber.log.Timber
-
-/** The equalizer operations [EqualizerController] drives, so tests can stand in for the effect. */
-internal interface EqualizerEffect {
-  val audioSessionId: Int
-
-  fun getSettings(): EqualizerSettings?
-
-  fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit)
-
-  fun setEnabled(enabled: Boolean)
-
-  fun setPreset(presetName: String)
-
-  fun setLevels(levels: DoubleArray)
-
-  fun release()
-}
-
-/**
- * Owns the equalizer's lifecycle across audio sessions. Android's Equalizer effect binds to a
- * single audioSessionId, so there are stretches with no effect at all: startup has no session until
- * the first audio output, and a session change (new ExoPlayer instance) needs a fresh one. Callers
- * see none of that — settings requested during a gap land on whichever effect comes next, and every
- * new effect announces itself through [onSettingsChanged].
- */
-internal class EqualizerController(
-  private val onSettingsChanged: (EqualizerSettings) -> Unit,
-  private val createEffect: (Int) -> EqualizerEffect = { EqualizerManager(it) },
-) {
-
-  private var effect: EqualizerEffect? = null
-
-  // Settings to apply to the next effect: what the caller asked for during a gap, or what the
-  // outgoing effect held across a session change. A preset and custom levels are exclusive — the
-  // last one asked for wins, matching how the two setters behave on a live effect.
-  private var pendingPreset: String? = null
-  private var pendingLevels: DoubleArray? = null
-  private var pendingEnabled: Boolean? = null
-
-  /** Initializes for [audioSessionId]; deferred when the session is still unset. */
-  fun initialize(audioSessionId: Int) {
-    if (audioSessionId == C.AUDIO_SESSION_ID_UNSET) {
-      Timber.d("Skipping equalizer init - no audio session yet, will init on first playback")
-      return
-    }
-    install(audioSessionId)
-  }
-
-  /**
-   * Reacts to an audio session change: a no-op for the same session, otherwise a fresh effect that
-   * picks up the outgoing one's settings.
-   */
-  fun onAudioSessionChanged(newAudioSessionId: Int) {
-    val old = effect
-    if (old != null && old.audioSessionId == newAudioSessionId) return
-
-    old?.let {
-      it.getSettings()?.let(::remember)
-      it.release()
-      effect = null
-    }
-    install(newAudioSessionId)
-  }
-
-  fun release() {
-    effect?.release()
-    effect = null
-  }
-
-  fun getSettings(): EqualizerSettings? = effect?.getSettings()
-
-  fun setEnabled(enabled: Boolean) {
-    val effect = effect
-    if (effect == null) {
-      pendingEnabled = enabled
-      return
-    }
-    effect.setEnabled(enabled)
-  }
-
-  fun setPreset(preset: String) {
-    val effect = effect
-    if (effect == null) {
-      rememberPreset(preset)
-      return
-    }
-    effect.setPreset(preset)
-  }
-
-  fun setLevels(levels: DoubleArray) {
-    val effect = effect
-    if (effect == null) {
-      rememberLevels(levels)
-      return
-    }
-    effect.setLevels(levels)
-  }
-
-  /**
-   * Creates the effect for [audioSessionId] and hands it the pending settings before wiring the
-   * callback, so the restore stays silent and the caller gets one event describing the result. A
-   * failed create keeps the pending settings for the next attempt.
-   */
-  private fun install(audioSessionId: Int) {
-    val created =
-      try {
-        createEffect(audioSessionId)
-      } catch (e: Exception) {
-        Timber.e(e, "Failed to initialize equalizer")
-        return
-      }
-    effect = created
-    Timber.d("Equalizer initialized with session ID: $audioSessionId")
-
-    pendingPreset?.let(created::setPreset)
-    pendingLevels?.let(created::setLevels)
-    pendingEnabled?.let(created::setEnabled)
-    pendingPreset = null
-    pendingLevels = null
-    pendingEnabled = null
-
-    created.setOnSettingsChanged(onSettingsChanged)
-    // Announce unconditionally. The caller reads the settings once at startup, which is exactly
-    // when there may be no effect yet, and nothing else would tell it the equalizer now exists.
-    created.getSettings()?.let(onSettingsChanged)
-  }
-
-  private fun remember(settings: EqualizerSettings) {
-    val preset = settings.activePreset
-    if (preset != null) {
-      rememberPreset(preset)
-    } else {
-      rememberLevels(settings.bandLevels)
-    }
-    pendingEnabled = settings.enabled
-  }
-
-  private fun rememberPreset(preset: String) {
-    pendingPreset = preset
-    pendingLevels = null
-  }
-
-  private fun rememberLevels(levels: DoubleArray) {
-    pendingLevels = levels
-    pendingPreset = null
-  }
-}

package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt

@@ -1,141 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.ForwardingPlayer
-import androidx.media3.common.Player as MediaPlayer
-import com.audiobrowser.Callbacks
-import com.audiobrowser.model.PlayerUpdateOptions
-import com.margelo.nitro.audiobrowser.RemoteJumpBackwardEvent
-import com.margelo.nitro.audiobrowser.RemoteJumpForwardEvent
-import com.margelo.nitro.audiobrowser.RemoteSeekEvent
-
-/**
- * The session-error masking rules, pure so their truth table is testable: with
- * `keepSessionAliveOnError`, a terminal load error (ExoPlayer idle + error present) is reported to
- * the platform session as paused-but-ready instead of STATE_NONE — Android Auto reads STATE_NONE as
- * "nothing playing" and tears down the now-playing screen, losing the next/previous buttons.
- */
-internal object SessionErrorMask {
-  fun playbackState(state: Int, hasError: Boolean, keepAlive: Boolean): Int =
-    if (keepAlive && state == MediaPlayer.STATE_IDLE && hasError) MediaPlayer.STATE_READY else state
-
-  fun playWhenReady(raw: Boolean, state: Int, hasError: Boolean, keepAlive: Boolean): Boolean =
-    if (keepAlive && state == MediaPlayer.STATE_IDLE && hasError) false else raw
-}
-
-/**
- * The Remote-command seam: intercepts transport controls arriving from External surfaces (lock
- * screen, notification, Bluetooth, Android Auto — all via the MediaSession) and offers each to the
- * app's `handleRemote*` callback first; a callback returning true consumes the command, anything
- * else falls through to the default behavior. Also masks a terminal playback error from the
- * platform session (see [SessionErrorMask]) so the session stays alive and skippable; the error
- * still surfaces via `onPlaybackError` and `playbackState`.
- */
-internal class InterceptingPlayer(
-  player: MediaPlayer,
-  private val callbacksProvider: () -> Callbacks?,
-  private val optionsProvider: () -> PlayerUpdateOptions,
-  private val keepSessionAliveOnError: Boolean,
-) : ForwardingPlayer(player) {
-
-  // Hide playback errors from the platform session. Media3 builds the legacy PlaybackStateCompat
-  // from player.getPlayerError() (-> STATE_ERROR), which Android Auto and the notification render
-  // as a disruptive error. The error still surfaces via the onPlaybackError JS callback and
-  // `playbackState`, so a now-playing formatter can render it; playback context is preserved.
-  override fun getPlayerError(): androidx.media3.common.PlaybackException? = null
-
-  // Both masks read the real underlying error (super.getPlayerError()) so they're race-free with
-  // state-change listeners.
-  override fun getPlaybackState(): Int =
-    SessionErrorMask.playbackState(
-      super.getPlaybackState(),
-      hasError = super.getPlayerError() != null,
-      keepAlive = keepSessionAliveOnError,
-    )
-
-  override fun getPlayWhenReady(): Boolean =
-    SessionErrorMask.playWhenReady(
-      super.getPlayWhenReady(),
-      super.getPlaybackState(),
-      hasError = super.getPlayerError() != null,
-      keepAlive = keepSessionAliveOnError,
-    )
-
-  /**
-   * A terminal error leaves ExoPlayer idle; the default transport controls (super.play() /
-   * super.seekToNext()) then flip playWhenReady or move the queue index but never restart a stopped
-   * player. prepare() recovers it (and early-returns when not idle, so it's a no-op during normal
-   * playback) — so next/previous/play resume on the selected station from the masked error state
-   * instead of doing nothing.
-   */
-  private fun recoverFromErrorIfNeeded() {
-    if (keepSessionAliveOnError && super.getPlayerError() != null) {
-      // Through the forwarding chain (no override exists), reaching the wrapped player.
-      prepare()
-    }
-  }
-
-  /**
-   * One definition of the dispatch: offer the command to the app's handler; true consumes it,
-   * anything else runs the default (and, for the resuming commands, the idle-error recovery).
-   */
-  private inline fun intercept(
-    handler: (Callbacks) -> Boolean,
-    recover: Boolean = false,
-    fallback: () -> Unit,
-  ) {
-    if (callbacksProvider()?.let(handler) == true) return
-    fallback()
-    if (recover) recoverFromErrorIfNeeded()
-  }
-
-  override fun play() = intercept({ it.handleRemotePlay() }, recover = true) { super.play() }
-
-  override fun pause() = intercept({ it.handleRemotePause() }) { super.pause() }
-
-  // Media3 controllers may drive transport via setPlayWhenReady instead of play()/pause()
-  // (the documented ForwardingPlayer hazard); route it through the same interception so the
-  // remote handlers and the idle-error recovery aren't bypassed.
-  override fun setPlayWhenReady(playWhenReady: Boolean) = if (playWhenReady) play() else pause()
-
-  override fun stop() = intercept({ it.handleRemoteStop() }) { super.stop() }
-
-  override fun seekToNext() =
-    intercept({ it.handleRemoteNext() }, recover = true) { super.seekToNext() }
-
-  override fun seekToNextMediaItem() =
-    intercept({ it.handleRemoteNext() }, recover = true) { super.seekToNextMediaItem() }
-
-  override fun seekToPrevious() =
-    intercept({ it.handleRemotePrevious() }, recover = true) { super.seekToPrevious() }
-
-  override fun seekToPreviousMediaItem() =
-    intercept({ it.handleRemotePrevious() }, recover = true) { super.seekToPreviousMediaItem() }
-
-  override fun seekForward() =
-    intercept({
-      it.handleRemoteJumpForward(
-        RemoteJumpForwardEvent(interval = optionsProvider().forwardJumpInterval)
-      )
-    }) {
-      super.seekForward()
-    }
-
-  override fun seekBack() =
-    intercept({
-      it.handleRemoteJumpBackward(
-        RemoteJumpBackwardEvent(interval = optionsProvider().backwardJumpInterval)
-      )
-    }) {
-      super.seekBack()
-    }
-
-  override fun seekTo(mediaItemIndex: Int, positionMs: Long) =
-    intercept({ it.handleRemoteSeek(RemoteSeekEvent(position = positionMs.toDouble() / 1000.0)) }) {
-      super.seekTo(mediaItemIndex, positionMs)
-    }
-
-  override fun seekTo(positionMs: Long) =
-    intercept({ it.handleRemoteSeek(RemoteSeekEvent(position = positionMs.toDouble() / 1000.0)) }) {
-      super.seekTo(positionMs)
-    }
-}

package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt

@@ -1,347 +0,0 @@
-package com.audiobrowser.player
-
-import com.audiobrowser.util.url
-import com.margelo.nitro.audiobrowser.FormatNowPlayingParams
-import com.margelo.nitro.audiobrowser.NowPlayingMetadata
-import com.margelo.nitro.audiobrowser.NowPlayingUpdate
-import com.margelo.nitro.audiobrowser.PlaybackError
-import com.margelo.nitro.audiobrowser.PlaybackState
-import com.margelo.nitro.audiobrowser.StallReason
-import com.margelo.nitro.audiobrowser.TimedMetadata
-import com.margelo.nitro.audiobrowser.Track
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import timber.log.Timber
-
-/**
- * What the now-playing logic needs from the platform — implemented by [Player] (current playback
- * reads, MediaItem stamping via `replaceMediaItem`, artwork resolution through the browser).
- * Mirrors iOS's NowPlayingUpdater / NowPlayingInfoController split: this seam is what makes the
- * precedence/guard/dedupe logic testable with a fake.
- */
-interface NowPlayingSurface {
-  val currentIndex: Int?
-  val currentTrack: Track?
-  val playbackState: PlaybackState
-  val playbackError: PlaybackError?
-
-  /**
-   * MUST be the real play/pause intent read from the underlying ExoPlayer — not the
-   * InterceptingPlayer-masked value, which can report false through a masked terminal error to keep
-   * the session paused-but-alive. The formatter receives this; feeding it the masked value breaks
-   * its output exactly in the error case the mask exists for.
-   */
-  val playWhenReady: Boolean
-  val isRebuffering: Boolean
-
-  /** Device connectivity, used to classify a stall as offline vs a plain rebuffer. */
-  val isOnline: Boolean
-
-  val hasNowPlayingArtworkConfig: Boolean
-
-  /** Stamp title/secondary/album onto the playing item. */
-  fun stampFields(index: Int, track: Track, title: String?, secondaryLine: String?, album: String?)
-
-  /** Stamp a resolved artwork uri onto the playing item. */
-  fun stampArtwork(index: Int, track: Track, uri: String)
-
-  /**
-   * Resolve the now-playing artwork for [track] via the `nowPlayingArtwork` config kind. Returns
-   * the final uri, or null when resolution produced nothing (errors are logged inside).
-   */
-  suspend fun resolveNowPlayingArtwork(track: Track, sizePx: Double): String?
-
-  fun emitNowPlayingChanged(metadata: NowPlayingMetadata)
-}
-
-/**
- * Owns the Now Playing rendering pipeline: the flash > override > formatter > track precedence, the
- * publish dedupe, the stale-result guards (render generation + track-id keying), timed (ICY)
- * metadata, and the once-per-track artwork keying. Mirrors iOS's NowPlayingUpdater. The platform is
- * reached only through [NowPlayingSurface]; the JS formatter arrives as a plain suspend lambda
- * (wrapped at the Nitro boundary in Player.setup), so every guard here runs under JVM tests.
- */
-class NowPlayingUpdater(private val surface: NowPlayingSurface, private val scope: CoroutineScope) {
-
-  /** Whether now-playing rendering (override/flash/formatter) is enabled (PlayerSetupOptions). */
-  var enabled = true
-
-  /** The JS formatter, wrapped to a plain suspend call at the Nitro boundary (see Player.setup). */
-  var formatter: (suspend (FormatNowPlayingParams) -> NowPlayingUpdate?)? = null
-
-  /** Latest live timed (ICY/ID3) metadata; cleared on track change. */
-  @Volatile private var latestTimedMetadata: TimedMetadata? = null
-
-  /** Imperative override (from `updateNowPlaying()`); cleared on track change. */
-  private var override: NowPlayingUpdate? = null
-
-  /**
-   * Transient now-playing fields (e.g. feedback for a refused remote command). Outranks the
-   * formatter and the override while active, so live metadata can't stomp it mid-flash. Reverted by
-   * a coroutine delay on [scope] — NOT a JS timer, which pauses with a backgrounded host (and the
-   * lock screen is exactly the backgrounded case) — and cleared early on track change.
-   */
-  private var flash: NowPlayingUpdate? = null
-  private var flashRevert: Job? = null
-
-  /**
-   * Monotonic stamp for renders. An async formatter result applies only when no newer render —
-   * notably a flash — has superseded the one that launched it.
-   */
-  private var renderGeneration = 0L
-
-  /** The last fields actually published, to dedupe redundant stamps. */
-  private data class Published(
-    val index: Int,
-    val trackId: String?,
-    val title: String?,
-    val secondaryLine: String?,
-    val album: String?,
-  )
-
-  private var lastPublished: Published? = null
-
-  /**
-   * The track id whose now-playing artwork has been resolved (or is being resolved), so a
-   * `nowPlayingArtwork` resolve runs once per track instead of on every render.
-   */
-  private var artworkResolvedForTrackId: String? = null
-
-  /** Size hint (px, square) for now-playing artwork. Mirrors iOS (screen-width-capped to 1200). */
-  private val artworkSizePx = 1200.0
-
-  /** Cancels in-flight work. Called from Player.destroy. */
-  fun destroy() {
-    scope.cancel()
-  }
-
-  /** Sets/clears the imperative override (null reverts to track metadata) and re-renders. */
-  fun updateNowPlaying(update: NowPlayingUpdate?) {
-    override = update
-    render()
-  }
-
-  fun flashNowPlaying(update: NowPlayingUpdate, durationMs: Double) {
-    flashRevert?.cancel()
-    flash = update
-    flashRevert =
-      scope.launch {
-        delay(durationMs.toLong())
-        flash = null
-        flashRevert = null
-        render()
-      }
-    render()
-  }
-
-  /** Clears an active flash immediately, reverting to the live metadata. No-op when none. */
-  fun clearNowPlayingFlash() {
-    if (flash == null) return
-    cancelFlash()
-    render()
-  }
-
-  private fun cancelFlash() {
-    flashRevert?.cancel()
-    flashRevert = null
-    flash = null
-  }
-
-  /** Gets the current now playing metadata (flash/override if set, else track metadata). */
-  fun getNowPlaying(): NowPlayingMetadata? {
-    val track = surface.currentTrack ?: return null
-    val flash = flash
-    val override = override
-
-    return NowPlayingMetadata(
-      elapsedTime = null,
-      title = flash?.title ?: override?.title ?: track.title,
-      album = flash?.album ?: override?.album ?: track.album,
-      artist = flash?.artist ?: override?.artist ?: track.artist,
-      duration = track.duration,
-      artwork = track.artwork?.url,
-      description = track.description,
-      mediaId = track.src ?: track.url,
-      genre = track.genre,
-    )
-  }
-
-  /** Clears override, flash, and timed metadata on track change (PlayerListener transition). */
-  fun clearOverride() {
-    override = null
-    cancelFlash()
-    latestTimedMetadata = null
-  }
-
-  /**
-   * Records the latest live timed (ICY/ID3) metadata and, when a formatter is configured, re-runs
-   * it so the live song is reflected on the now-playing surface.
-   */
-  fun onTimedMetadataReceived(timed: TimedMetadata) {
-    latestTimedMetadata = timed
-    if (enabled && formatter != null) {
-      render()
-    }
-  }
-
-  /**
-   * Renders the current now playing metadata to the surface. Flash wins while active (formatter
-   * skipped entirely so its async result can't land on top); otherwise the override-or-track
-   * default is stamped immediately and a configured formatter customizes it asynchronously, guarded
-   * by track identity and [renderGeneration].
-   */
-  fun render() {
-    val index = surface.currentIndex ?: return
-    val track = surface.currentTrack ?: return
-    renderGeneration += 1
-    val generation = renderGeneration
-
-    // Metadata source. When metadata is disabled, use the raw track (ignore override + formatter);
-    // otherwise the imperative `updateNowPlaying` override wins over the track's own fields.
-    val activeOverride = if (enabled) override else null
-    val defaultTitle = activeOverride?.title ?: track.title
-    val defaultSecondary = activeOverride?.artist ?: track.artist
-    val defaultAlbum = activeOverride?.album ?: track.album
-
-    // A flash outranks both the formatter and the override; while one is active the formatter pass
-    // is skipped entirely so its async result can't land on top.
-    val activeFlash = if (enabled) flash else null
-    if (activeFlash != null) {
-      applyFields(
-        index,
-        track,
-        activeFlash.title ?: defaultTitle,
-        activeFlash.artist ?: defaultSecondary,
-        activeFlash.album ?: defaultAlbum,
-      )
-      return
-    }
-
-    // Apply the default immediately so the now-playing never lags a track/status change.
-    applyFields(index, track, defaultTitle, defaultSecondary, defaultAlbum)
-
-    // If a formatter is configured, let it customize the fields asynchronously. Falls back to the
-    // default on null/throw.
-    val activeFormatter = if (enabled) formatter else null
-    if (activeFormatter != null) {
-      val capturedId = track.src ?: track.url
-      // Gate the raw load-control signal to the buffering state so `stalled` is correct on its
-      // own: ExoPlayer's rebuffering flag is polled on a different cadence than state transitions
-      // and can linger true into the PLAYING transition as a rebuffer recovers. Classify by
-      // connectivity so the formatter can show "offline" vs a plain rebuffer; null when not
-      // stalled.
-      val isStalled = surface.playbackState == PlaybackState.BUFFERING && surface.isRebuffering
-      val stalled =
-        if (isStalled) {
-          if (surface.isOnline) StallReason.BUFFERING else StallReason.OFFLINE
-        } else {
-          null
-        }
-      val params =
-        FormatNowPlayingParams(
-          track,
-          latestTimedMetadata,
-          surface.playWhenReady,
-          stalled,
-          surface.playbackError,
-        )
-      scope.launch {
-        val formatted =
-          try {
-            activeFormatter(params)
-          } catch (e: Exception) {
-            Timber.e(e, "NowPlaying formatter threw; using default")
-            null
-          }
-        // Apply only if still the same track (a fast skip must not be overwritten by a stale
-        // result) AND no newer render superseded this one — without the generation check, a
-        // formatter round-trip in flight when a flash starts lands a beat later and overwrites
-        // the flash (mirrors the iOS renderGeneration guard).
-        val current = surface.currentTrack
-        val currentIdx = surface.currentIndex
-        if (
-          formatted != null &&
-            current != null &&
-            currentIdx != null &&
-            (current.src ?: current.url) == capturedId &&
-            renderGeneration == generation
-        ) {
-          applyFields(
-            currentIdx,
-            current,
-            formatted.title ?: defaultTitle,
-            formatted.artist ?: defaultSecondary,
-            formatted.album ?: defaultAlbum,
-          )
-        }
-      }
-    }
-  }
-
-  /** Stamps the fields via the surface, deduped on (index, track identity, fields). */
-  private fun applyFields(
-    index: Int,
-    track: Track,
-    title: String?,
-    secondaryLine: String?,
-    album: String?,
-  ) {
-    // Skip republishing identical fields. The formatter is re-invoked on every state change, so
-    // the same fields are recomputed often; an unconditional stamp would churn the MediaSession
-    // (and flicker Android Auto / now-playing) for no visible change. Keyed on the track identity
-    // so a new track with a coincidentally identical line still publishes.
-    val published = Published(index, track.src ?: track.url, title, secondaryLine, album)
-    if (published == lastPublished) return
-    lastPublished = published
-
-    surface.stampFields(index, track, title, secondaryLine, album)
-    getNowPlaying()?.let { surface.emitNowPlayingChanged(it) }
-
-    // Resolve the now-playing-only artwork (lock screen / notification / Android Auto
-    // now-playing), keyed on track id so it runs once per track and not on every render.
-    maybeResolveArtwork(track)
-  }
-
-  /**
-   * Resolves the playing track's now-playing artwork and stamps it onto the playing media item.
-   * Guarded exactly like iOS: only when `nowPlayingArtwork` is configured AND the track has a
-   * non-empty id (so the `{id}` token never resolves to an empty string). Otherwise the existing
-   * artworkUri — which came from `artwork` (browse list path) — is left in place.
-   */
-  private fun maybeResolveArtwork(track: Track) {
-    val trackId =
-      track.id?.takeIf { it.isNotEmpty() }
-        ?: run {
-          // No id → skip nowPlayingArtwork entirely; keep the existing (browse) artworkUri.
-          artworkResolvedForTrackId = null
-          return
-        }
-
-    if (!surface.hasNowPlayingArtworkConfig) {
-      // No now-playing artwork config (or no browser) → fall back to the existing artworkUri.
-      artworkResolvedForTrackId = null
-      return
-    }
-
-    // Already resolved (or resolving) for this track id — avoid a redundant resolve per render.
-    if (artworkResolvedForTrackId == trackId) return
-    artworkResolvedForTrackId = trackId
-
-    scope.launch {
-      val uri =
-        surface.resolveNowPlayingArtwork(track, artworkSizePx)?.takeIf { it.isNotEmpty() }
-          ?: return@launch
-
-      // Apply only if still the same track (a fast skip must not be overwritten by a stale
-      // result).
-      val currentIdx = surface.currentIndex ?: return@launch
-      val current = surface.currentTrack ?: return@launch
-      if (current.id != trackId) return@launch
-
-      surface.stampArtwork(currentIdx, current, uri)
-    }
-  }
-}