react-native-queue-player 1.1.2 → 1.2.0

package/ios/Tests/TrackPlayerCastStateTests.swift

@@ -0,0 +1,78 @@
+import XCTest
+@testable import QueuePlayer
+
+/// `getState()` reports the receiver while a cast session owns playback. The
+/// local engine is parked and paused for the session's duration, so reading it
+/// would describe nothing the user can hear.
+final class TrackPlayerCastStateTests: XCTestCase {
+
+  private let router = PlaybackStateRouter.shared
+
+  override func setUp() {
+    super.setUp()
+    router._resetForTesting()
+  }
+
+  override func tearDown() {
+    router._resetForTesting()
+    super.tearDown()
+  }
+
+  /// Register a session that has already reported `state` to the receiver.
+  private func activateReporting(_ state: RemotePlaybackStateKind) throws {
+    let session = ControllableRemoteSession()
+    session.fireState(state)
+    try router.setActive(session)
+  }
+
+  func testReportsReceiverPlayingDuringCastSession() throws {
+    try activateReporting(.playing)
+    XCTAssertEqual(try TrackPlayer().getState(), .playing)
+  }
+
+  func testReportsReceiverPausedDuringCastSession() throws {
+    try activateReporting(.paused)
+    XCTAssertEqual(try TrackPlayer().getState(), .paused)
+  }
+
+  func testMapsBufferingReceiverToBuffering() throws {
+    try activateReporting(.buffering)
+    XCTAssertEqual(try TrackPlayer().getState(), .buffering)
+  }
+
+  func testMapsEndedReceiverToEnded() throws {
+    try activateReporting(.ended)
+    XCTAssertEqual(try TrackPlayer().getState(), .ended)
+  }
+
+  func testReportsIdleReceiverOnceItHasReported() throws {
+    // A receiver that has spoken stays authoritative: a later idle means it
+    // genuinely has nothing loaded, not that it is still activating.
+    let session = ControllableRemoteSession()
+    session.fireState(.playing)
+    session.fireState(.idle)
+    try router.setActive(session)
+
+    XCTAssertEqual(try TrackPlayer().getState(), PlayerState.none)
+  }
+
+  func testReadsLocalEngineUntilReceiverReports() throws {
+    // Session activating: the receiver holds a state it has not reported, so
+    // the local engine answers. Distinguishable from the receiver's `.playing`
+    // precisely because no engine is configured here.
+    let session = ControllableRemoteSession()
+    session.lastState = .playing
+    try router.setActive(session)
+
+    XCTAssertFalse(session.hasReportedState)
+    XCTAssertEqual(try TrackPlayer().getState(), PlayerState.none)
+  }
+
+  func testReadsLocalEngineWithNoCastSession() throws {
+    // An unregistered session must not be consulted, however it reports.
+    let session = ControllableRemoteSession()
+    session.fireState(.playing)
+
+    XCTAssertEqual(try TrackPlayer().getState(), PlayerState.none)
+  }
+}

package/ios/TrackPlayer.swift

@@ -2968,6 +2968,15 @@ class TrackPlayer: HybridTrackPlayerSpec {
   // hop for consistency. `onMainSync` short-circuits when already
   // on main, so callers that are on main don't deadlock.
   func getState() throws -> PlayerState {
+    // The receiver owns playback during a cast session — the local engine is
+    // parked and paused for its duration, so its derived state describes
+    // nothing the user can hear. Until the receiver has reported (session
+    // still activating, holding its initial `.idle`) the local read is the
+    // better answer; after that the receiver is authoritative, including a
+    // later `.idle`, which means it genuinely has nothing loaded.
+    if let remote = PlaybackStateRouter.shared.activeRemote(), remote.hasReportedState {
+      return remote.lastState.asPlayerState
+    }
     return onMainSync {
       // Both engines derive PlayerState from the same inputs via
       // `engine.timeControlStatus` (gapless returns its AVQueuePlayer's, which

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-queue-player",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Nitro Modules audio playback library for React Native — gapless, EQ, crossfade, automotive, voice, casting",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/index.d.ts",

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

@@ -1,189 +0,0 @@
-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)
-                }
-            }
-        }
-    }
-}