react-native-queue-player 1.1.2 → 2.0.0

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/CastEventBridge.kt

@@ -70,7 +70,7 @@ internal class CastEventBridge(private val owner: TrackPlayer) {
         sessionJob = scope.launch {
           launch {
             session.state.collectLatest { remoteState ->
-              owner.emitRemoteState(mapState(remoteState), StateChangeReason.SYSTEM)
+              owner.emitRemoteState(mapRemotePlaybackState(remoteState), StateChangeReason.SYSTEM)
             }
           }
           launch {
@@ -110,13 +110,4 @@ internal class CastEventBridge(private val owner: TrackPlayer) {
     lastPositionMs = positionMs
   }
 
-  private fun mapState(state: RemotePlaybackState): PlayerState = when (state) {
-    RemotePlaybackState.PLAYING -> PlayerState.PLAYING
-    RemotePlaybackState.PAUSED -> PlayerState.PAUSED
-    RemotePlaybackState.LOADING -> PlayerState.BUFFERING
-    RemotePlaybackState.BUFFERING -> PlayerState.BUFFERING
-    RemotePlaybackState.IDLE -> PlayerState.NONE
-    RemotePlaybackState.ENDED -> PlayerState.ENDED
-    RemotePlaybackState.ERROR -> PlayerState.ERROR
-  }
 }

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
 
@@ -124,6 +125,19 @@ sealed class CastSession {
     /** Receiver-driven playback state for `PlaybackStateRouter`. */
     abstract val state: StateFlow<RemotePlaybackState>
 
+    /**
+     * `true` once the receiver has reported any state other than
+     * [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
+     * session that has just activated still holds its initial IDLE, and the
+     * local engine is the better answer until the receiver speaks. Once it
+     * has, the receiver is authoritative — including a later IDLE, which
+     * means it genuinely has nothing loaded.
+     */
+    abstract val hasReportedState: Boolean
+
     /** Receiver-driven position in ms. */
     abstract val positionMs: StateFlow<Long>
 

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

@@ -30,6 +30,25 @@ internal object CastTransportRouter {
     return true
   }
 
+  /**
+   * Flip the receiver's play state. The receiver's own state picks the
+   * direction — the local engine is parked and paused while casting, so its
+   * `playWhenReady` would resume the receiver on every press. Anything that
+   * represents "trying to play" toggles to pause, so a press during buffering
+   * stops rather than restarts.
+   */
+  fun routeTogglePlayPause(): Boolean {
+    val remote = PlaybackStateRouter.activeRemote() ?: return false
+    val active = when (remote.state.value) {
+      RemotePlaybackState.PLAYING,
+      RemotePlaybackState.BUFFERING,
+      RemotePlaybackState.LOADING -> true
+      else -> false
+    }
+    if (active) remote.pause() else remote.play()
+    return true
+  }
+
   fun routeStop(): Boolean {
     val remote = PlaybackStateRouter.activeRemote() ?: return false
     remote.stop()

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

@@ -0,0 +1,18 @@
+package com.margelo.nitro.queueplayer.cast
+
+import com.margelo.nitro.queueplayer.PlayerState
+
+/**
+ * Map the protocol-neutral receiver state to the JS-facing [PlayerState].
+ * Shared by the cast event fan-out and `TrackPlayer.getState`, so a state read
+ * and the event stream can't disagree about the same receiver.
+ */
+internal fun mapRemotePlaybackState(state: RemotePlaybackState): PlayerState = when (state) {
+  RemotePlaybackState.PLAYING -> PlayerState.PLAYING
+  RemotePlaybackState.PAUSED -> PlayerState.PAUSED
+  RemotePlaybackState.LOADING -> PlayerState.BUFFERING
+  RemotePlaybackState.BUFFERING -> PlayerState.BUFFERING
+  RemotePlaybackState.IDLE -> PlayerState.NONE
+  RemotePlaybackState.ENDED -> PlayerState.ENDED
+  RemotePlaybackState.ERROR -> PlayerState.ERROR
+}

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

@@ -9,6 +9,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import java.util.concurrent.atomic.AtomicReference
 
 /**
  * A live AirPlay 2 streaming session backed by libairplay2 via [AirPlay2JNI].
@@ -28,7 +29,7 @@ class AirPlay2Session(
     private val handle: Long,
     private val host: String,
     private val port: Int,
-) : CastSession.PcmStream(), MetadataAwareSession {
+) : CastSession.PcmStream(), MetadataAwareSession, MetadataSyncTarget {
 
     companion object {
         private const val TAG = "AirPlay2Session"
@@ -36,7 +37,10 @@ class AirPlay2Session(
 
     private val sink = AirPlay2Sink(handle)
     @Volatile private var closed = false
-    private var metadataSync: AirPlay2MetadataSync? = null
+    // Swapped on the player's looper by onActivated, read and cleared on the
+    // disconnecting thread — the exchange has to be atomic or a teardown can
+    // read a stale null and leave the previous sync running.
+    private val metadataSync = AtomicReference<AirPlayMetadataSync?>()
 
     /** Internal scope for fire-and-forget native teardown. */
     private val teardownScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
@@ -53,22 +57,27 @@ class AirPlay2Session(
     }
 
     override fun onActivated(player: Player, scope: CoroutineScope) {
-        // Re-entrant safe: stop any prior sync before rebinding so a repeat
+        if (closed) return
+        // Stop any prior sync before starting the replacement, so a repeat
         // activation (the player swaps under a still-connected session) never
         // leaves an orphaned sync running against the previous player.
-        metadataSync?.stop()
-        metadataSync = AirPlay2MetadataSync(context, this, player, scope).also { it.start() }
+        val next = AirPlayMetadataSync(context, this, player, scope)
+        metadataSync.getAndSet(next)?.stop()
+        next.start()
+        // A close() that ran while this was publishing exchanged out a null
+        // and tore down without seeing `next`, so re-check: otherwise a live
+        // sync stays bound to a closed session for the process lifetime.
+        if (closed) metadataSync.getAndSet(null)?.stop()
     }
 
     override fun onDeactivated() {
-        metadataSync?.stop()
-        metadataSync = null
+        metadataSync.getAndSet(null)?.stop()
     }
 
     /**
      * 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) {
@@ -91,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 {
@@ -103,17 +114,17 @@ class AirPlay2Session(
         }
     }
 
-    fun setMetadata(title: String?, artist: String?, album: String?) {
+    override fun setMetadata(title: String?, artist: String?, album: String?) {
         if (closed) return
         AirPlay2JNI.nativeAp2SetMetadata(handle, title, artist, album)
     }
 
-    fun setArtwork(imageData: ByteArray, contentType: String = "image/jpeg") {
+    override fun setArtwork(imageData: ByteArray, contentType: String) {
         if (closed) return
         AirPlay2JNI.nativeAp2SetArtwork(handle, imageData, imageData.size)
     }
 
-    fun setProgress(elapsedMs: Int, durationMs: Int) {
+    override fun setProgress(elapsedMs: Int, durationMs: Int) {
         if (closed) return
         AirPlay2JNI.nativeAp2SetProgressMs(handle, elapsedMs.toLong(), durationMs.toLong())
     }

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

@@ -14,19 +14,23 @@ import java.io.ByteArrayOutputStream
 import java.net.URL
 
 /**
- * Syncs ExoPlayer track metadata and playback progress to an [AirPlaySession].
+ * Syncs ExoPlayer track metadata and playback progress to an AirPlay
+ * receiver through [MetadataSyncTarget].
  *
- * - On activation and on every track transition: sends DAAP metadata
+ * - On activation and on every track transition: sends metadata
  *   (title/artist/album) and kicks off an async artwork fetch.
  * - Every 5 seconds while playing: sends progress (elapsed/duration).
  * - On seek: sends progress immediately.
  * - On stop: cancels all coroutines and removes the player listener.
+ *
+ * One instance covers one activation — [start] then [stop]. Starting again
+ * after a stop is a no-op; a new activation builds a new instance.
  */
 internal class AirPlayMetadataSync(
     private val context: Context,
-    private val session: AirPlaySession,
+    private val target: MetadataSyncTarget,
     private val player: Player,
-    private val scope: CoroutineScope,
+    scope: CoroutineScope,
 ) {
     companion object {
         private const val TAG = "AirPlayMetadataSync"
@@ -35,11 +39,32 @@ internal class AirPlayMetadataSync(
         private const val JPEG_QUALITY = 80
     }
 
+    /**
+     * Owns every coroutine this sync launches, so [stop] can cancel them as
+     * one atomic operation from any thread. Cancelling the scope needs no
+     * field read, so a teardown racing the player looper cannot miss a job,
+     * and a launch that loses the race starts already-cancelled rather than
+     * outliving the session it pushes into.
+     */
+    private val syncScope =
+        CoroutineScope(scope.coroutineContext + SupervisorJob(scope.coroutineContext[Job]))
+
+    // Touched only on the player's application looper.
     private var progressJob: Job? = null
     private var artworkJob: Job? = null
     private var lastArtworkUri: String? = null
+
+    // Written by start/stop on whichever thread activated or tore the
+    // session down; read on the looper and by the progress loop.
+    @Volatile
     private var started = false
 
+    // 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
+    private var stopped = false
+
     // ExoPlayer rejects add/removeListener + state reads off its application
     // looper. start()/stop() are driven by session activation/close, and
     // close() runs on whichever thread disconnected (the JS thread for a
@@ -48,6 +73,10 @@ internal class AirPlayMetadataSync(
     // already on it.
     private val playerHandler = Handler(player.applicationLooper)
 
+    // Both protocols log under one tag, so every line says which sender it
+    // came from.
+    private val targetName = target.javaClass.simpleName
+
     private fun onPlayerLooper(block: () -> Unit) {
         if (Looper.myLooper() == player.applicationLooper) block()
         else playerHandler.post(block)
@@ -69,6 +98,7 @@ internal class AirPlayMetadataSync(
         }
 
         override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+            if (!started) return
             if (playWhenReady) {
                 startProgressTimer()
             } else {
@@ -79,37 +109,43 @@ internal class AirPlayMetadataSync(
     }
 
     fun start() {
-        if (started) return
+        if (started || stopped) return
         started = true
         onPlayerLooper {
+            // A stop() between this post and its execution has already run its
+            // own removeListener, so attaching now would leave the listener on
+            // the player for its lifetime.
+            if (stopped) return@onPlayerLooper
             player.addListener(listener)
             sendCurrentMetadata()
-            if (player.playWhenReady) {
+            if (started && player.playWhenReady) {
                 startProgressTimer()
             }
         }
-        Log.i(TAG, "Started metadata sync")
+        Log.i(TAG, "Started metadata sync for $targetName")
     }
 
     fun stop() {
-        if (!started) return
+        if (stopped) return
+        stopped = true
         started = false
-        progressJob?.cancel()
-        progressJob = null
-        artworkJob?.cancel()
-        artworkJob = null
+        syncScope.cancel()
+        // Listener removal has to hop to the looper, so a callback queued
+        // ahead of it can still run; the `started` gate in the senders is
+        // what stops those from reaching a session that is being closed.
         onPlayerLooper { player.removeListener(listener) }
-        Log.i(TAG, "Stopped metadata sync")
+        Log.i(TAG, "Stopped metadata sync for $targetName")
     }
 
     private fun sendCurrentMetadata() {
+        if (!started) return
         val meta = player.currentMediaItem?.mediaMetadata ?: return
         val title = meta.title?.toString()
         val artist = meta.artist?.toString()
         val album = meta.albumTitle?.toString()
 
-        Log.i(TAG, "Sending metadata: title=$title, artist=$artist, album=$album")
-        session.setMetadata(title, artist, album)
+        Log.i(TAG, "$targetName sending metadata: title=$title, artist=$artist, album=$album")
+        target.setMetadata(title, artist, album)
 
         // Send initial progress for the new track
         sendProgress()
@@ -123,16 +159,17 @@ internal class AirPlayMetadataSync(
     }
 
     private fun sendProgress() {
+        if (!started) return
         val position = player.currentPosition.toInt()
         val duration = player.duration.let { if (it > 0) it.toInt() else 0 }
         if (duration > 0) {
-            session.setProgress(position, duration)
+            target.setProgress(position, duration)
         }
     }
 
     private fun startProgressTimer() {
         progressJob?.cancel()
-        progressJob = scope.launch {
+        progressJob = syncScope.launch {
             while (isActive) {
                 delay(PROGRESS_INTERVAL_MS)
                 if (player.isPlaying) {
@@ -144,7 +181,7 @@ internal class AirPlayMetadataSync(
 
     private fun fetchAndSendArtwork(uriString: String) {
         artworkJob?.cancel()
-        artworkJob = scope.launch(Dispatchers.IO) {
+        artworkJob = syncScope.launch(Dispatchers.IO) {
             try {
                 val uri = Uri.parse(uriString)
                 val scheme = uri.scheme ?: return@launch
@@ -185,9 +222,9 @@ internal class AirPlayMetadataSync(
                 bitmap.recycle()
 
                 val bytes = baos.toByteArray()
-                if (isActive) {
-                    session.setArtwork(bytes, "image/jpeg")
-                    Log.i(TAG, "Sent artwork: ${bytes.size} bytes from $uriString")
+                if (isActive && started) {
+                    target.setArtwork(bytes, "image/jpeg")
+                    Log.i(TAG, "$targetName sent artwork: ${bytes.size} bytes from $uriString")
                 }
             } catch (e: Exception) {
                 if (e !is CancellationException) {

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/AirPlaySession.kt

@@ -6,6 +6,7 @@ import androidx.media3.exoplayer.audio.AudioSink
 import com.margelo.nitro.queueplayer.cast.CastSession
 import com.margelo.nitro.queueplayer.cast.MetadataAwareSession
 import kotlinx.coroutines.CoroutineScope
+import java.util.concurrent.atomic.AtomicReference
 
 /**
  * A live AirPlay 1 streaming session backed by libraop via [AirplayJNI].
@@ -25,15 +26,22 @@ class AirPlaySession(
     private val handle: Long,
     private val host: String,
     private val port: Int,
-) : CastSession.PcmStream(), MetadataAwareSession {
+) : CastSession.PcmStream(), MetadataAwareSession, MetadataSyncTarget {
 
     companion object {
         private const val TAG = "AirPlaySession"
     }
 
     private val sink = AirPlaySink(handle)
+
+    // Read by every sender, set by close() on whichever thread disconnected.
+    @Volatile
     private var closed = false
-    private var metadataSync: AirPlayMetadataSync? = null
+
+    // Swapped on the player's looper by onActivated, read and cleared on the
+    // disconnecting thread — the exchange has to be atomic or a teardown can
+    // read a stale null and leave the previous sync running.
+    private val metadataSync = AtomicReference<AirPlayMetadataSync?>()
 
     override fun audioSink(): AudioSink = sink
 
@@ -46,22 +54,29 @@ class AirPlaySession(
     }
 
     override fun onActivated(player: Player, scope: CoroutineScope) {
-        // Re-entrant safe: stop any prior sync before rebinding so a repeat
+        if (closed) return
+        // Stop any prior sync before starting the replacement, so a repeat
         // activation (the player swaps under a still-connected session) never
         // leaves an orphaned sync running against the previous player.
-        metadataSync?.stop()
-        metadataSync = AirPlayMetadataSync(context, this, player, scope).also { it.start() }
+        val next = AirPlayMetadataSync(context, this, player, scope)
+        metadataSync.getAndSet(next)?.stop()
+        next.start()
+        // A close() that ran while this was publishing exchanged out a null
+        // and tore down without seeing `next`, so re-check: otherwise a live
+        // sync stays bound to a closed session for the process lifetime.
+        if (closed) metadataSync.getAndSet(null)?.stop()
     }
 
     override fun onDeactivated() {
-        metadataSync?.stop()
-        metadataSync = null
+        metadataSync.getAndSet(null)?.stop()
     }
 
     override fun close() {
         if (closed) return
-        onDeactivated()
+        // Closed before the sync is torn down so an in-flight sender bails at
+        // its own guard rather than reaching a handle nativeDestroy has freed.
         closed = true
+        onDeactivated()
         Log.i(TAG, "Closing AirPlay session to $host:$port")
         // Release the sink BEFORE the native handle is torn down: this sets
         // the sink's volatile `released` flag so the renderer thread stops
@@ -73,20 +88,17 @@ class AirPlaySession(
         AirplayJNI.nativeDestroy(handle)
     }
 
-    /** Send DAAP metadata (title/artist/album) to the receiver. */
-    fun setMetadata(title: String?, artist: String?, album: String?) {
+    override fun setMetadata(title: String?, artist: String?, album: String?) {
         if (closed) return
         AirplayJNI.nativeSetDaap(handle, title, artist, album)
     }
 
-    /** Send artwork image to the receiver. */
-    fun setArtwork(imageData: ByteArray, contentType: String = "image/jpeg") {
+    override fun setArtwork(imageData: ByteArray, contentType: String) {
         if (closed) return
         AirplayJNI.nativeSetArtwork(handle, imageData, imageData.size, contentType)
     }
 
-    /** Update the progress bar on the receiver. */
-    fun setProgress(elapsedMs: Int, durationMs: Int) {
+    override fun setProgress(elapsedMs: Int, durationMs: Int) {
         if (closed) return
         AirplayJNI.nativeSetProgressMs(handle, elapsedMs, durationMs)
     }

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
 }