react-native-queue-player 1.2.0 → 2.0.1

package/android/src/main/java/com/margelo/nitro/queueplayer/Visualizer.kt

@@ -222,14 +222,10 @@ class Visualizer : HybridVisualizerSpec() {
    * fftSize=2048 should expect proportionally higher GC pressure on
    * the audio render thread.
    *
-   * Write each float directly via `bb.putFloat()` advancing bb's
-   * own position. The derived `bb.asFloatBuffer().put(values)` form
-   * appears to write to bb's underlying storage on JVM but does not
-   * propagate the bytes through `ArrayBuffer.wrap` on Android's
-   * emulator backend — observed empirically: post-FFT magnitudes
-   * surface as all-zero on the JS side, even though `bb.getFloat(0)`
-   * reads back the right value on the Kotlin side. The explicit
-   * putFloat loop sidesteps the whole class of issue.
+   * Writes with `putFloat` rather than `bb.asFloatBuffer().put(values)`:
+   * the view form delivered all-zero buffers to JS through
+   * `ArrayBuffer.wrap` while `bb.getFloat(0)` read back correctly in
+   * Kotlin. Cause not established.
    */
   private fun floatArrayToArrayBuffer(values: FloatArray): ArrayBuffer {
     val bb = ByteBuffer.allocateDirect(values.size * 4).order(ByteOrder.nativeOrder())

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/CastBackend.kt

@@ -6,9 +6,10 @@ package com.margelo.nitro.queueplayer.cast
  * `ChromecastBackend` for Cast, future DLNA / Sonos similarly. The
  * core module never knows which backends are present.
  *
- * The interface is intentionally tiny. Anything richer (volume,
- * pairing PIN flow, capability discovery) lives on the [CastSession]
- * subtype that [connect] returns. Keeps the registry pluggable + the
+ * The interface is intentionally tiny. Anything richer lives on the
+ * concrete backend or on the [CastSession] subtype that [connect]
+ * returns — volume on the session, the AirPlay 2 pairing-PIN flow on
+ * `AirPlayBackend.submitPairingPin`. Keeps the registry pluggable + the
  * routing layer protocol-agnostic.
  */
 interface CastBackend {

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/CastSession.kt

@@ -61,9 +61,10 @@ sealed class CastSession {
 
     /**
      * Optional `Player` implementation for `MediaSession`. When
-     * non-null, `MusicService` swaps `mediaSession.player` to this on
-     * cast connect and back on disconnect. Chromecast returns a
-     * `RemoteCastPlayer` from `media3-cast`. Default null.
+     * non-null, `PlaybackService` retargets the session's forwarding
+     * player to this on cast connect and back to the local engine on
+     * disconnect. Chromecast returns a `RemoteCastPlayer` from
+     * `media3-cast`. Default null.
      */
     open val mediaSessionPlayer: Player? = null
 
@@ -126,7 +127,7 @@ sealed class CastSession {
 
     /**
      * `true` once the receiver has reported any state other than
-     * [RemotePlaybackState.IDLE]. Latches on the first such report and stays
+     * [RemotePlaybackState.IDLE]. Set by the first such report and stays
      * set for the session's lifetime.
      *
      * State reads use this to decide whether the receiver can answer yet: a

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlay2JNI.kt

@@ -91,10 +91,8 @@ object AirPlay2JNI {
 
     // -- Pairing --
 
-    @JvmStatic external fun nativeAp2NeedsPairing(handle: Long): Boolean
     @JvmStatic external fun nativeAp2PairPinStart(handle: Long): Boolean
     @JvmStatic external fun nativeAp2PairSetup(handle: Long, credential: String): String?
-    @JvmStatic external fun nativeAp2GetPairingState(handle: Long): Int
     @JvmStatic external fun nativeAp2GetAuthMode(handle: Long): Int
     @JvmStatic external fun nativeAp2GetDeviceId(handle: Long): String?
     @JvmStatic external fun nativeAp2SetPassword(handle: Long, password: String)

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlay2Session.kt

@@ -77,7 +77,7 @@ class AirPlay2Session(
     /**
      * Invoked from the native drain thread (via [AirPlay2JNI.onNativeSessionDied])
      * when the receiver has stopped responding. Notifies any [deathListener]
-     * so CastModule can revert routing to local, then runs the normal close
+     * so `CastManager` can revert routing to local, then runs the normal close
      * path — native TEARDOWN is skipped because the socket is dead.
      */
     private fun onRemoteDied(reason: Int) {
@@ -100,7 +100,9 @@ class AirPlay2Session(
         AirPlay2JNI.unregisterSession(handle)
 
         /* Native TEARDOWN can block on a dead socket — never run it on the
-         * caller's thread (typically the main/UI thread via CastModule). */
+         * caller's thread (`CastManager.disconnect()` on the JS thread, a
+         * replacing `connect()` or `submitPairingPin()` on `Dispatchers.IO`,
+         * `onRemoteDied` on the native drain thread). */
         val h = handle
         teardownScope.launch {
             try {

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlayBackend.kt

@@ -97,22 +97,28 @@ internal class AirPlayBackend(private val context: Context) : CastBackend {
 
     /**
      * Complete a deferred AP2 pairing by supplying the PIN / password the
-     * receiver demanded. Returns the active session on success; throws on
-     * pairing failure or when no pending pair exists.
+     * receiver demanded. Returns the session and the receiver it was
+     * paired with; throws on pairing failure or when no pending pair
+     * exists.
      *
      * Callers use this when `CastManager.submitPairingPin(pin)` is invoked
      * out-of-band of a follow-up `connect(receiverId, {password})` call.
      */
-    suspend fun submitPairingPin(pin: String): CastSession = withContext(Dispatchers.IO) {
+    suspend fun submitPairingPin(pin: String): PairedSession = withContext(Dispatchers.IO) {
         val pending = synchronized(this@AirPlayBackend) { pendingPairState }
             ?: throw IllegalStateException("No pending AirPlay 2 pairing")
         val receiver = discovery.findReceiver(pending.receiverId)
             ?: throw IllegalStateException(
                 "Receiver ${pending.receiverId} no longer visible — restart the connect flow"
             )
+        // resumeAp2Pairing reports the id of the pair it consumed and
+        // validated against `receiver`; the read above only locates it.
         resumeAp2Pairing(receiver, pin)
     }
 
+    /** A session established by [submitPairingPin] and the receiver it was paired with. */
+    data class PairedSession(val session: CastSession, val receiverId: String)
+
     /**
      * Persistent store for AirPlay 2 pair-setup auth keys + passwords,
      * keyed by the receiver's mDNS `deviceid` (MAC address).
@@ -306,7 +312,7 @@ internal class AirPlayBackend(private val context: Context) : CastBackend {
 
         // --- Phase 2: credential supplied → resume pending pairing ---
         if (credential != null) {
-            return resumeAp2Pairing(receiver, credential)
+            return resumeAp2Pairing(receiver, credential).session
         }
 
         // --- Phase 1: initial connection attempt ---
@@ -423,11 +429,12 @@ internal class AirPlayBackend(private val context: Context) : CastBackend {
     }
 
     /**
-     * Resume a pending AP2 pairing with user-provided credential.
-     * Called when the UI re-invokes connect() with a password/PIN after
-     * [AuthRequiredException] was thrown.
+     * Resume a pending AP2 pairing with user-provided credential, from
+     * either `connect()` re-invoked with a password or [submitPairingPin].
+     * Consumes the pending pair, validates it is for [receiver], and
+     * returns the session together with that receiver's id.
      */
-    private fun resumeAp2Pairing(receiver: Receiver, credential: String): CastSession {
+    private fun resumeAp2Pairing(receiver: Receiver, credential: String): PairedSession {
         val pending = synchronized(this) {
             val p = pendingPairState
             pendingPairState = null
@@ -506,7 +513,7 @@ internal class AirPlayBackend(private val context: Context) : CastBackend {
         }
 
         Log.i(TAG, "Connected AP2 to ${receiver.name} via pair-verify")
-        return AirPlay2Session(context, newHandle, host, port)
+        return PairedSession(AirPlay2Session(context, newHandle, host, port), pending.receiverId)
     }
 
     /** Destroy any stale pending pairing handle. */

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlayMetadataSync.kt

@@ -59,7 +59,7 @@ internal class AirPlayMetadataSync(
     @Volatile
     private var started = false
 
-    // Latches on stop so a restart cannot half-revive a spent instance: the
+    // Set on stop and never cleared, so a restart cannot half-revive a spent instance: the
     // scope is already cancelled, so the listener would still push metadata
     // while the progress loop and artwork fetch stay dead.
     @Volatile

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlayRenderersFactory.kt

@@ -10,12 +10,12 @@ import androidx.media3.exoplayer.audio.AudioSink
  * [AudioSink] IS the AirPlay session's sink ([AirPlay2Sink] / [AirPlaySink]).
  *
  * Deliberately a bare [DefaultRenderersFactory]: no `setEnableAudioFloatOutput`,
- * no audio processors. The AirPlay sinks only accept `AUDIO_RAW` +
- * `ENCODING_PCM_16BIT`, and the default factory decodes to Int16 PCM — so the
- * renderer negotiates a format the sink accepts and the PCM reaches the
- * receiver clean. (Forcing float output or inserting a processor chain is what
- * corrupted the AirPlay stream on the shared local engine; this engine is kept
- * dedicated and clean precisely to avoid that.)
+ * no audio processors, no extension-renderer preference. The AirPlay sinks
+ * only accept `AUDIO_RAW` + `ENCODING_PCM_16BIT`, and the default factory
+ * decodes to Int16 PCM — so the renderer negotiates a format the sink accepts
+ * and the PCM reaches the receiver clean. Float output or a processor chain
+ * in front of the sink corrupts the AirPlay stream, which is why this engine
+ * has its own factory instead of sharing the local pipeline's.
  *
  * One sink per factory instance — the AirPlay engine is built fresh for each
  * session and released when the session ends, so the sink is never swapped at
@@ -27,14 +27,6 @@ internal class AirPlayRenderersFactory(
   private val airplaySink: AudioSink,
 ) : DefaultRenderersFactory(context) {
 
-  init {
-    // Match the known-good fork AirPlay config: prefer extension decoders.
-    // No-op when no extension renderers are bundled, but it keeps the
-    // decoder-selection behaviour identical to the reference that streams
-    // clean PCM to these sinks.
-    setExtensionRendererMode(EXTENSION_RENDERER_MODE_PREFER)
-  }
-
   override fun buildAudioSink(
     context: Context,
     enableFloatOutput: Boolean,

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirplayJNI.kt

@@ -40,11 +40,6 @@ object AirplayJNI {
       false
     }
 
-    // -- Library info --
-
-    @JvmStatic external fun nativeVersion(): String
-    @JvmStatic external fun nativeInitSsl(): Boolean
-
     // -- Session lifecycle --
 
     /**
@@ -73,10 +68,8 @@ object AirplayJNI {
     /** Bytes waiting in the ring buffer, not yet sent. Used for hasPendingData(). */
     @JvmStatic external fun nativeRingAvailable(handle: Long): Int
 
-    // -- Audio streaming (legacy, kept for compatibility) --
+    // -- Transport control --
 
-    @JvmStatic external fun nativeAcceptFrames(handle: Long): Boolean
-    @JvmStatic external fun nativeSendChunk(handle: Long, data: ByteArray, offset: Int, length: Int): Boolean
     @JvmStatic external fun nativePause(handle: Long)
     @JvmStatic external fun nativeStop(handle: Long)
     @JvmStatic external fun nativeFlush(handle: Long): Boolean
@@ -91,16 +84,11 @@ object AirplayJNI {
 
     @JvmStatic external fun nativeSetVolume(handle: Long, volume: Float): Boolean
     @JvmStatic external fun nativeSetProgressMs(handle: Long, elapsed: Int, duration: Int): Boolean
-    @JvmStatic external fun nativeGetProgressMs(handle: Long): Long
     @JvmStatic external fun nativeSetDaap(handle: Long, title: String?, artist: String?, album: String?): Boolean
     @JvmStatic external fun nativeSetArtwork(handle: Long, imageData: ByteArray, length: Int, contentType: String): Boolean
 
     // -- State queries --
 
     @JvmStatic external fun nativeIsConnected(handle: Long): Boolean
-    @JvmStatic external fun nativeIsPlaying(handle: Long): Boolean
-    @JvmStatic external fun nativeGetState(handle: Long): Int
-    @JvmStatic external fun nativeGetLatency(handle: Long): Int
-    @JvmStatic external fun nativeGetSampleRate(handle: Long): Int
     @JvmStatic external fun nativeKeepalive(handle: Long): Boolean
 }

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/MulticastLockHolder.kt

@@ -70,6 +70,6 @@ internal class MulticastLockHolder(context: Context) {
     fun isHeld(): Boolean = lock?.isHeld == true
 
     private companion object {
-        const val LOCK_TAG = "rntp-airplay-discovery"
+        const val LOCK_TAG = "QueuePlayer.AirPlayDiscovery"
     }
 }

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/chromecast/ChromecastBackend.kt

@@ -14,9 +14,9 @@ import com.margelo.nitro.queueplayer.CastReceiver
 
 /**
  * Chromecast backend — owns discovery via MediaRouter and session
- * lifecycle via GMS SessionManager. Surfaces discovery, connect, and
- * disconnect today; queue load + transport-state translation arrive
- * with the cast engine-swap work.
+ * lifecycle via GMS SessionManager, plus the transport calls that
+ * address the SDK session directly. Queue load and transport-state
+ * translation live in [ChromecastSession] and [RemoteMediaCallbacks].
  */
 internal class ChromecastBackend(
   private val context: Context,

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/http/LocalMediaServer.kt

@@ -32,7 +32,7 @@ import kotlinx.coroutines.runBlocking
  *
  * Binds to `0.0.0.0` on an OS-assigned port. Range / HEAD /
  * Content-Length fall out of Ktor's `LocalFileContent` + `PartialContent`
- * plugin. Refcounted via `acquire(sessionId)` / `release()`.
+ * plugin. Refcounted via `acquire(sessionId, context)` / `release(sessionId)`.
  */
 class LocalMediaServer {
   private val lock = Any()
@@ -51,38 +51,26 @@ class LocalMediaServer {
   var serverPort: Int = -1
     private set
 
-  @Volatile
-  var lifecycleListener: LocalMediaServerLifecycle? = null
-
   @Volatile
   private var addressMonitor: LocalAddressMonitor? = null
 
   val currentLanAddress: String?
     get() = addressMonitor?.currentAddress
 
-  fun attachAddressMonitor(monitor: LocalAddressMonitor) {
-    addressMonitor = monitor
-  }
-
-  fun addAddressChangeListener(
-    listener: LocalAddressMonitor.Listener,
-  ): LocalAddressMonitor.Subscription? = addressMonitor?.addListener(listener)
-
   fun acquire(sessionId: String, context: Context): MediaServerHandle {
     val first = refCount.getAndIncrement() == 0
     if (first) {
       ensureStarted()
       ensureAddressMonitor(context)
-      lifecycleListener?.onActiveStateChanged(true)
     }
     return MediaServerHandle(this, sessionId)
   }
 
   // Lazily create + start the LAN-address monitor the first time the
   // server is acquired. `start()` seeds `currentAddress` synchronously
-  // from the active network, so the address is available to the very
-  // first `currentLanAddress` read (the cast handoff loads immediately
-  // on connect, before any async network callback would land).
+  // when the active network is Wi-Fi, so the address is available to
+  // the very first `currentLanAddress` read (the cast handoff loads
+  // immediately on connect, before any async network callback lands).
   private fun ensureAddressMonitor(context: Context) {
     synchronized(lock) {
       if (addressMonitor != null) return
@@ -93,29 +81,21 @@ class LocalMediaServer {
   internal fun release(sessionId: String) {
     registry.revokeAll(sessionId)
     val last = refCount.decrementAndGet() == 0
-    if (last) {
-      stop()
-      lifecycleListener?.onActiveStateChanged(false)
-    }
+    if (last) stop()
   }
 
   internal fun register(sessionId: String, file: File, contentType: String?): String =
     registry.register(sessionId, file, contentType)
 
-  internal fun revoke(token: String) = registry.revoke(token)
-
-  internal fun resolve(token: String): RegisteredMedia? = registry.resolve(token)
-
   private fun ensureStarted() {
     synchronized(lock) {
       if (engine != null) return
-      // Bind on every interface (Wi-Fi LAN, cellular, VPN) — Chromecast
-      // receivers pull from the phone's LAN IP, and we cannot
-      // pre-determine which interface the receiver will use. URLs
-      // handed back to receivers go through `MediaServerHandle.url`,
-      // which scopes hosts to the active Wi-Fi address via
-      // `LocalAddressMonitor`. Tokens are 32 hex chars (high entropy);
-      // unauthorized callers cannot enumerate served media.
+      // Listen on every interface; the URL host selects the Wi-Fi one.
+      // URLs handed back to receivers go through
+      // `MediaServerHandle.register(file, lanAddress, contentType)` with the
+      // host from `currentLanAddress` (`LocalAddressMonitor.currentAddress`,
+      // the Wi-Fi network's address). Tokens are 32 hex chars (high
+      // entropy); unauthorized callers cannot enumerate served media.
       val started = embeddedServer(CIO, port = 0, host = "0.0.0.0") {
         install(PartialContent)
         install(AutoHeadResponse)
@@ -153,8 +133,4 @@ class LocalMediaServer {
       addressMonitor = null
     }
   }
-
-  internal fun stopForTest() {
-    stop()
-  }
 }

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/http/MediaServerHandle.kt

@@ -31,11 +31,6 @@ class MediaServerHandle internal constructor(
     return "http://$lanAddress:$port/media/$token"
   }
 
-  fun revoke(token: String) {
-    if (closed.get()) return
-    server.revoke(token)
-  }
-
   fun close() {
     if (closed.compareAndSet(false, true)) {
       server.release(sessionId)

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/http/MediaTokenRegistry.kt

@@ -22,16 +22,10 @@ internal class MediaTokenRegistry {
 
   fun resolve(token: String): RegisteredMedia? = tokens[token]
 
-  fun revoke(token: String) {
-    tokens.remove(token)
-  }
-
   fun revokeAll(sessionId: String) {
     val iter = tokens.entries.iterator()
     while (iter.hasNext()) {
       if (iter.next().value.sessionId == sessionId) iter.remove()
     }
   }
-
-  fun size(): Int = tokens.size
 }

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/net/LocalAddressMonitor.kt

@@ -7,37 +7,38 @@ import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import java.net.Inet4Address
-import java.util.concurrent.CopyOnWriteArrayList
 
 /**
- * Surfaces the host's primary LAN IPv4 address and notifies listeners
- * on change. Owned by `LocalMediaServer`; backends consume via the
- * server's `addAddressChangeListener`.
+ * Surfaces the host's Wi-Fi IPv4 address. Owned by `LocalMediaServer`,
+ * which exposes it to backends as `currentLanAddress`.
  *
  * Detection via [ConnectivityManager.NetworkCallback] on a request for
- * `TRANSPORT_WIFI | TRANSPORT_CELLULAR`. Cellular included so mobile-
- * hotspot setups (phone hotspot fed to a Chromecast) work.
+ * `TRANSPORT_WIFI` (the request's default capabilities exclude VPNs), so
+ * only a Wi-Fi network's address is ever served, and a cellular network
+ * coming or going neither replaces nor clears it.
  */
 class LocalAddressMonitor(private val context: Context) {
 
-  fun interface Listener {
-    fun onAddressChanged(newAddress: String?)
-  }
-
-  private val listeners = CopyOnWriteArrayList<Listener>()
-
   @Volatile
   var currentAddress: String? = null
     private set
 
+  /**
+   * The network whose link properties supplied [currentAddress]. Two Wi-Fi
+   * networks overlap during a handover — the new one reports its link before
+   * the old one is lost — so a loss clears the address only when it is the
+   * network the address came from.
+   */
+  private var addressNetwork: Network? = null
+
   private var registered = false
   private val callback = object : ConnectivityManager.NetworkCallback() {
     override fun onLinkPropertiesChanged(network: Network, linkProperties: LinkProperties) {
-      updateAddress(linkProperties)
+      updateAddress(network, linkProperties)
     }
 
     override fun onLost(network: Network) {
-      updateAddress(null)
+      if (network == addressNetwork) updateAddress(null, null)
     }
   }
 
@@ -47,14 +48,23 @@ class LocalAddressMonitor(private val context: Context) {
       ?: return
     val request = NetworkRequest.Builder()
       .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
-      .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
       .build()
     cm.registerNetworkCallback(request, callback)
     registered = true
-    // Seed synchronously from the active network so `currentAddress` is
-    // populated immediately — the cast handoff reads it right after
-    // connect, before the first async onLinkPropertiesChanged lands.
-    updateAddress(cm.activeNetwork?.let { cm.getLinkProperties(it) })
+    // Seed synchronously so `currentAddress` is populated immediately —
+    // the cast handoff reads it right after connect, before the first
+    // async onLinkPropertiesChanged lands. The active network is used
+    // only when it passes the request's own filter (Wi-Fi, not a VPN:
+    // a VPN over Wi-Fi carries the Wi-Fi transport but a tunnel address).
+    // When Wi-Fi is up but not the default network, the address arrives
+    // with that network's first onLinkPropertiesChanged instead.
+    val active = cm.activeNetwork ?: return
+    val caps = cm.getNetworkCapabilities(active) ?: return
+    if (caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) &&
+      caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
+    ) {
+      updateAddress(active, cm.getLinkProperties(active))
+    }
   }
 
   fun stop() {
@@ -65,22 +75,11 @@ class LocalAddressMonitor(private val context: Context) {
     registered = false
   }
 
-  fun addListener(listener: Listener): Subscription {
-    listeners.add(listener)
-    return Subscription { listeners.remove(listener) }
-  }
-
-  private fun updateAddress(linkProperties: LinkProperties?) {
+  private fun updateAddress(network: Network?, linkProperties: LinkProperties?) {
     val ipv4 = linkProperties?.linkAddresses
       ?.firstOrNull { it.address is Inet4Address && !it.address.isLoopbackAddress }
       ?.address?.hostAddress
-    if (ipv4 != currentAddress) {
-      currentAddress = ipv4
-      listeners.forEach { it.onAddressChanged(ipv4) }
-    }
-  }
-
-  fun interface Subscription {
-    fun remove()
+    addressNetwork = if (ipv4 != null) network else null
+    currentAddress = ipv4
   }
 }

package/android/src/test/java/androidx/media3/session/{MediaSessionControllerRequestTestSeam.kt → MediaSessionControllerRequestTestSupport.kt}

@@ -3,7 +3,7 @@ package androidx.media3.session
 import androidx.media3.common.util.UnstableApi
 
 /**
- * Test-only seam into Media3's controller-request scope.
+ * Test-only access to Media3's controller-request scope.
  *
  * `MediaSession.getControllerForCurrentRequest()` is non-null only for
  * the duration of a controller-originated `Player` call, set by Media3

package/android/src/test/java/com/margelo/nitro/queueplayer/AvrcpMetadataTest.kt

@@ -80,6 +80,8 @@ class AvrcpMetadataTest {
       duration = null,
       artworkUrl = null,
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
     setQueueOnSession(listOf(track))
 
@@ -100,6 +102,8 @@ class AvrcpMetadataTest {
       duration = null,
       artworkUrl = "https://example.com/cover.jpg",
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
     setQueueOnSession(listOf(track))
 
@@ -120,6 +124,8 @@ class AvrcpMetadataTest {
       duration = 42.0,
       artworkUrl = null,
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
     setQueueOnSession(listOf(track))
 
@@ -137,6 +143,8 @@ class AvrcpMetadataTest {
       duration = null,
       artworkUrl = null,
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
     val second = TrackItem(
       id = "second",
@@ -147,6 +155,8 @@ class AvrcpMetadataTest {
       duration = null,
       artworkUrl = null,
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
 
     setQueueOnSession(listOf(first))
@@ -170,6 +180,8 @@ class AvrcpMetadataTest {
       duration = null,
       artworkUrl = null,
       extras = null,
+      replayGainTrackGain = null, replayGainTrackPeak = null,
+      replayGainAlbumGain = null, replayGainAlbumPeak = null,
     )
     setQueueOnSession(listOf(track))
     assertEquals(1, session.player.mediaItemCount)