react-native-queue-player 1.0.0

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

@@ -0,0 +1,189 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import kotlinx.coroutines.*
+import java.io.ByteArrayOutputStream
+import java.net.URL
+
+/**
+ * Syncs ExoPlayer track metadata and playback progress to an [AirPlay2Session].
+ * Identical logic to [AirPlayMetadataSync] but targets the AP2 session.
+ */
+internal class AirPlay2MetadataSync(
+    private val context: Context,
+    private val session: AirPlay2Session,
+    private val player: Player,
+    private val scope: CoroutineScope,
+) {
+    companion object {
+        private const val TAG = "AP2MetadataSync"
+        private const val PROGRESS_INTERVAL_MS = 5000L
+        private const val MAX_ARTWORK_DIM = 600
+        private const val JPEG_QUALITY = 80
+    }
+
+    private var progressJob: Job? = null
+    private var artworkJob: Job? = null
+    private var lastArtworkUri: String? = null
+    private var started = 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
+    // user disconnect, the native drain thread on receiver death) — so the
+    // player touches are marshalled onto the player's looper, run inline when
+    // already on it.
+    private val playerHandler = Handler(player.applicationLooper)
+
+    private fun onPlayerLooper(block: () -> Unit) {
+        if (Looper.myLooper() == player.applicationLooper) block()
+        else playerHandler.post(block)
+    }
+
+    private val listener = object : Player.Listener {
+        override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+            sendCurrentMetadata()
+        }
+
+        override fun onPositionDiscontinuity(
+            oldPosition: Player.PositionInfo,
+            newPosition: Player.PositionInfo,
+            reason: Int,
+        ) {
+            if (reason == Player.DISCONTINUITY_REASON_SEEK) {
+                sendProgress()
+            }
+        }
+
+        override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+            if (playWhenReady) {
+                startProgressTimer()
+            } else {
+                progressJob?.cancel()
+                progressJob = null
+            }
+        }
+    }
+
+    fun start() {
+        if (started) return
+        started = true
+        onPlayerLooper {
+            player.addListener(listener)
+            sendCurrentMetadata()
+            if (player.playWhenReady) {
+                startProgressTimer()
+            }
+        }
+        Log.i(TAG, "Started metadata sync")
+    }
+
+    fun stop() {
+        if (!started) return
+        started = false
+        progressJob?.cancel()
+        progressJob = null
+        artworkJob?.cancel()
+        artworkJob = null
+        onPlayerLooper { player.removeListener(listener) }
+        Log.i(TAG, "Stopped metadata sync")
+    }
+
+    private fun sendCurrentMetadata() {
+        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)
+        sendProgress()
+
+        val artUri = meta.artworkUri?.toString()
+        if (artUri != null && artUri != lastArtworkUri) {
+            lastArtworkUri = artUri
+            fetchAndSendArtwork(artUri)
+        }
+    }
+
+    private fun sendProgress() {
+        val position = player.currentPosition.toInt()
+        val duration = player.duration.let { if (it > 0) it.toInt() else 0 }
+        if (duration > 0) {
+            session.setProgress(position, duration)
+        }
+    }
+
+    private fun startProgressTimer() {
+        progressJob?.cancel()
+        progressJob = scope.launch {
+            while (isActive) {
+                delay(PROGRESS_INTERVAL_MS)
+                if (player.isPlaying) {
+                    sendProgress()
+                }
+            }
+        }
+    }
+
+    private fun fetchAndSendArtwork(uriString: String) {
+        artworkJob?.cancel()
+        artworkJob = scope.launch(Dispatchers.IO) {
+            try {
+                val uri = Uri.parse(uriString)
+                val scheme = uri.scheme ?: return@launch
+
+                // Read raw bytes — use ContentResolver for content:// and
+                // android.resource://, URL for http(s), file for file://
+                val rawBytes: ByteArray = when (scheme) {
+                    "content", "android.resource" ->
+                        context.contentResolver.openInputStream(uri)
+                            ?.use { it.readBytes() } ?: return@launch
+                    "file" ->
+                        java.io.File(uri.path ?: return@launch).readBytes()
+                    "http", "https" ->
+                        URL(uriString).openStream().use { it.readBytes() }
+                    else -> {
+                        Log.w(TAG, "Unsupported artwork scheme: $scheme")
+                        return@launch
+                    }
+                }
+
+                val boundsOpts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+                BitmapFactory.decodeByteArray(rawBytes, 0, rawBytes.size, boundsOpts)
+
+                var sampleSize = 1
+                while (boundsOpts.outWidth / sampleSize > MAX_ARTWORK_DIM ||
+                       boundsOpts.outHeight / sampleSize > MAX_ARTWORK_DIM) {
+                    sampleSize *= 2
+                }
+
+                val decodeOpts = BitmapFactory.Options().apply { inSampleSize = sampleSize }
+                val bitmap = BitmapFactory.decodeByteArray(rawBytes, 0, rawBytes.size, decodeOpts)
+                    ?: return@launch
+
+                val baos = ByteArrayOutputStream()
+                bitmap.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, baos)
+                bitmap.recycle()
+
+                val bytes = baos.toByteArray()
+                if (isActive) {
+                    session.setArtwork(bytes, "image/jpeg")
+                    Log.i(TAG, "Sent artwork: ${bytes.size} bytes from $uriString")
+                }
+            } catch (e: Exception) {
+                if (e !is CancellationException) {
+                    Log.w(TAG, "Artwork fetch failed for $uriString", e)
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,123 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import android.util.Log
+import androidx.media3.common.Player
+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 kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * A live AirPlay 2 streaming session backed by libairplay2 via [AirPlay2JNI].
+ *
+ * Lifecycle: created by [AirPlayBackend.connect], which opens the native
+ * session, runs the full connection sequence (pair → SETUP → RECORD →
+ * start audio), and hands back this session. [audioSink] returns the
+ * [AirPlay2Sink] that ExoPlayer pushes decoded PCM into. [close] tears
+ * down the native session cleanly.
+ *
+ * @param handle opaque native session pointer from [AirPlay2JNI.nativeAp2Open]
+ * @param host receiver IP address
+ * @param port receiver RTSP port
+ */
+class AirPlay2Session(
+    private val context: android.content.Context,
+    private val handle: Long,
+    private val host: String,
+    private val port: Int,
+) : CastSession.PcmStream(), MetadataAwareSession {
+
+    companion object {
+        private const val TAG = "AirPlay2Session"
+    }
+
+    private val sink = AirPlay2Sink(handle)
+    @Volatile private var closed = false
+    private var metadataSync: AirPlay2MetadataSync? = null
+
+    /** Internal scope for fire-and-forget native teardown. */
+    private val teardownScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    init {
+        AirPlay2JNI.registerSession(handle) { reason -> onRemoteDied(reason) }
+    }
+
+    override fun audioSink(): AudioSink = sink
+
+    override fun setVolume(value: Float) {
+        if (closed) return
+        AirPlay2JNI.nativeAp2SetVolume(handle, value)
+    }
+
+    override fun onActivated(player: Player, scope: CoroutineScope) {
+        // Re-entrant safe: stop any prior sync before rebinding 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() }
+    }
+
+    override fun onDeactivated() {
+        metadataSync?.stop()
+        metadataSync = null
+    }
+
+    /**
+     * 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
+     * path — native TEARDOWN is skipped because the socket is dead.
+     */
+    private fun onRemoteDied(reason: Int) {
+        if (closed) return
+        Log.w(TAG, "Remote receiver died (reason=$reason) — tearing down session")
+        val label = when (reason) {
+            AirPlay2JNI.DIED_FEEDBACK_TIMEOUT -> "feedback-timeout"
+            else -> "unknown"
+        }
+        deathListener?.invoke(label)
+        close()
+    }
+
+    override fun close() {
+        if (closed) return
+        closed = true
+        onDeactivated()
+        Log.i(TAG, "Closing AirPlay 2 session to $host:$port")
+        sink.release()
+        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). */
+        val h = handle
+        teardownScope.launch {
+            try {
+                AirPlay2JNI.nativeAp2Disconnect(h)
+                AirPlay2JNI.nativeAp2Destroy(h)
+            } catch (t: Throwable) {
+                Log.e(TAG, "Native teardown failed", t)
+            }
+        }
+    }
+
+    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") {
+        if (closed) return
+        AirPlay2JNI.nativeAp2SetArtwork(handle, imageData, imageData.size)
+    }
+
+    fun setProgress(elapsedMs: Int, durationMs: Int) {
+        if (closed) return
+        AirPlay2JNI.nativeAp2SetProgressMs(handle, elapsedMs.toLong(), durationMs.toLong())
+    }
+
+    val isConnected: Boolean
+        get() = !closed && AirPlay2JNI.nativeAp2GetState(handle) >= AirPlay2JNI.STATE_STREAMING
+}

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

@@ -0,0 +1,205 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import android.media.AudioDeviceInfo
+import android.util.Log
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.Format
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.PlaybackParameters
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.audio.AudioOffloadSupport
+import androidx.media3.exoplayer.audio.AudioSink
+import java.nio.ByteBuffer
+
+/**
+ * [AudioSink] that pushes decoded PCM into a native AirPlay 2 session
+ * via [AirPlay2JNI]. Same ring-buffer + drain-thread architecture as
+ * [AirPlaySink], but uses the libairplay2 native library.
+ *
+ * @param handle opaque native session pointer from [AirPlay2JNI.nativeAp2Open]
+ */
+@UnstableApi
+class AirPlay2Sink(private val handle: Long) : AudioSink {
+
+    companion object {
+        private const val TAG = "AirPlay2Sink"
+        private const val BYTES_PER_SAMPLE_16BIT = 2
+    }
+
+    private var sampleRate = 0
+    private var channelCount = 0
+    private var bytesPerFrame = 0
+    private var configured = false
+
+    private var playing = false
+    private var endOfStreamSignaled = false
+    private var bufferCallCount = 0L
+    private var startPresentationTimeUs = Long.MIN_VALUE
+    private var bytesSentAtFlush = 0L
+
+    @Volatile
+    private var released = false
+
+    private var listener: AudioSink.Listener? = null
+
+    override fun setListener(listener: AudioSink.Listener) {
+        this.listener = listener
+    }
+
+    override fun supportsFormat(format: Format): Boolean {
+        return format.sampleMimeType == MimeTypes.AUDIO_RAW &&
+            format.pcmEncoding == android.media.AudioFormat.ENCODING_PCM_16BIT
+    }
+
+    override fun getFormatSupport(format: Format): Int {
+        return if (supportsFormat(format)) {
+            AudioSink.SINK_FORMAT_SUPPORTED_DIRECTLY
+        } else {
+            AudioSink.SINK_FORMAT_UNSUPPORTED
+        }
+    }
+
+    override fun configure(
+        inputFormat: Format,
+        specifiedBufferSize: Int,
+        outputChannels: IntArray?,
+    ) {
+        sampleRate = inputFormat.sampleRate
+        channelCount = inputFormat.channelCount
+        bytesPerFrame = channelCount * BYTES_PER_SAMPLE_16BIT
+        configured = true
+        endOfStreamSignaled = false
+        Log.i(TAG, "configure: ${sampleRate}Hz, ${channelCount}ch, pcm=${inputFormat.pcmEncoding}")
+    }
+
+    override fun play() {
+        playing = true
+    }
+
+    override fun pause() {
+        playing = false
+    }
+
+    override fun flush() {
+        Log.i(TAG, "flush()")
+        endOfStreamSignaled = false
+        startPresentationTimeUs = Long.MIN_VALUE
+        bytesSentAtFlush = AirPlay2JNI.nativeAp2GetBytesSent(handle)
+    }
+
+    override fun reset() {
+        Log.i(TAG, "reset()")
+        flush()
+        configured = false
+        playing = false
+    }
+
+    override fun release() {
+        // Idempotent: the dedicated AirPlay engine and the session's
+        // close() both release this sink. reset() calls JNI on the native
+        // handle (via flush), so a second release after the handle is torn
+        // down would crash — short-circuit once released.
+        if (released) return
+        Log.i(TAG, "release()")
+        released = true
+        reset()
+    }
+
+    override fun handleBuffer(
+        buffer: ByteBuffer,
+        presentationTimeUs: Long,
+        encodedAccessUnitCount: Int,
+    ): Boolean {
+        if (released || !configured) return false
+
+        val remaining = buffer.remaining()
+        if (remaining == 0) return true
+
+        val data: ByteArray
+        val offset: Int
+        if (buffer.hasArray()) {
+            data = buffer.array()
+            offset = buffer.arrayOffset() + buffer.position()
+        } else {
+            data = ByteArray(remaining)
+            buffer.duplicate().get(data)
+            offset = 0
+        }
+
+        val consumed = AirPlay2JNI.nativeAp2FeedPcm(handle, data, offset, remaining)
+
+        if (consumed > 0) {
+            buffer.position(buffer.position() + consumed)
+
+            if (startPresentationTimeUs == Long.MIN_VALUE) {
+                startPresentationTimeUs = presentationTimeUs
+                Log.i(TAG, "startPresentationTimeUs=$presentationTimeUs (${presentationTimeUs / 1_000_000}s into track)")
+            }
+
+            if (bufferCallCount++ % 1000 == 0L) {
+                val bytesSent = AirPlay2JNI.nativeAp2GetBytesSent(handle)
+                Log.d(TAG, "handleBuffer #$bufferCallCount: fed $consumed bytes, bytesSent=$bytesSent")
+            }
+            return consumed == remaining
+        }
+
+        if (bufferCallCount++ % 2000 == 0L) {
+            Log.d(TAG, "handleBuffer #$bufferCallCount: ring buffer full, back-pressure")
+        }
+        return false
+    }
+
+    override fun handleDiscontinuity() {}
+
+    override fun playToEndOfStream() {
+        if (released) return
+        if (!endOfStreamSignaled) {
+            Log.i(TAG, "playToEndOfStream: signaled, ringAvail=${AirPlay2JNI.nativeAp2RingAvailable(handle)}")
+        }
+        endOfStreamSignaled = true
+    }
+
+    override fun isEnded(): Boolean {
+        if (released) return true
+        val pending = hasPendingData()
+        val ended = endOfStreamSignaled && !pending
+        if (ended && endOfStreamSignaled) {
+            Log.i(TAG, "isEnded: true (ring drained)")
+        }
+        return ended
+    }
+
+    override fun hasPendingData(): Boolean {
+        if (released) return false
+        return AirPlay2JNI.nativeAp2RingAvailable(handle) > 0
+    }
+
+    override fun getCurrentPositionUs(sourceEnded: Boolean): Long {
+        if (released || !configured || sampleRate == 0 || bytesPerFrame == 0) {
+            return AudioSink.CURRENT_POSITION_NOT_SET
+        }
+        val baseUs = if (startPresentationTimeUs != Long.MIN_VALUE) startPresentationTimeUs else 0L
+        val bytesSent = AirPlay2JNI.nativeAp2GetBytesSent(handle) - bytesSentAtFlush
+        val framesSent = bytesSent / bytesPerFrame
+        return baseUs + framesSent * 1_000_000L / sampleRate
+    }
+
+    override fun setPlaybackParameters(playbackParameters: PlaybackParameters) {}
+    override fun getPlaybackParameters(): PlaybackParameters = PlaybackParameters.DEFAULT
+    override fun setSkipSilenceEnabled(skipSilenceEnabled: Boolean) {}
+    override fun getSkipSilenceEnabled(): Boolean = false
+    override fun setAudioAttributes(audioAttributes: AudioAttributes) {}
+    override fun getAudioAttributes(): AudioAttributes? = null
+    override fun setAudioSessionId(audioSessionId: Int) {}
+    override fun setAuxEffectInfo(auxEffectInfo: androidx.media3.common.AuxEffectInfo) {}
+    override fun setPreferredDevice(audioDeviceInfo: AudioDeviceInfo?) {}
+    override fun setVolume(volume: Float) {}
+    override fun enableTunnelingV21() {}
+    override fun disableTunneling() {}
+
+    override fun getFormatOffloadSupport(format: Format): AudioOffloadSupport {
+        return AudioOffloadSupport.DEFAULT_UNSUPPORTED
+    }
+
+    override fun getAudioTrackBufferSizeUs(): Long = 0
+}