react-native-queue-player 1.1.1 → 1.2.0

package/ios/Tests/CastNowPlayingControllerTests.swift

@@ -177,6 +177,7 @@ final class ControllableRemoteSession: CastSessionRemotePlayer {
   var isPushSink: Bool { pushSink }
 
   var lastState: RemotePlaybackStateKind = .idle
+  var hasReportedState: Bool = false
   var lastPositionMs: Int64 = 0
   var lastDurationMs: Int64 = 0
   var lastBufferedMs: Int64 = 0
@@ -186,8 +187,12 @@ final class ControllableRemoteSession: CastSessionRemotePlayer {
   private var stateCb: ((RemotePlaybackStateKind) -> Void)?
   private var positionCb: ((Int64, Int64, Int64) -> Void)?
 
+  /// Drive the receiver state the way a live session does: a non-idle report
+  /// latches `hasReportedState`. Set `lastState` directly to stage a state the
+  /// receiver has not reported yet.
   func fireState(_ state: RemotePlaybackStateKind) {
     lastState = state
+    if state != .idle { hasReportedState = true }
     stateCb?(state)
   }
 

package/ios/Tests/GaplessEngineLifecycleTests.swift

@@ -30,6 +30,32 @@ final class GaplessEngineLifecycleTests: XCTestCase {
     XCTAssertNil(engine.delegate)
   }
 
+  // MARK: - Repeat mode
+
+  /// Repeat-one holds the current item at its end
+  /// (`actionAtItemEnd = .none`) so `TrackPlayer`'s end-of-track handler
+  /// can deterministically rewind + replay it; off / queue keep the
+  /// default `.advance`. Without the hold, the AVQueuePlayer advances
+  /// into the next enqueued item before the async rewind runs, so the
+  /// track skips forward instead of repeating.
+  func testRepeatTrackHoldsItemAtEndWhileOthersAdvance() {
+    let engine = GaplessEngine()
+    XCTAssertEqual(engine.player.actionAtItemEnd, .advance)
+
+    engine.setRepeatMode(.track)
+    XCTAssertEqual(engine.player.actionAtItemEnd, .none)
+
+    engine.setRepeatMode(.queue)
+    XCTAssertEqual(engine.player.actionAtItemEnd, .advance)
+
+    engine.setRepeatMode(.off)
+    XCTAssertEqual(engine.player.actionAtItemEnd, .advance)
+
+    // Re-entering repeat-one re-applies the hold.
+    engine.setRepeatMode(.track)
+    XCTAssertEqual(engine.player.actionAtItemEnd, .none)
+  }
+
   // MARK: - Queue-mutation surface
 
   /// `setItems` installs the slice from `startIndex` onward; items

package/ios/Tests/PlaybackStateRouterTests.swift

@@ -124,6 +124,7 @@ final class FakeRemoteSession: CastSessionRemotePlayer {
   var isPushSink: Bool { false }
 
   var lastState: RemotePlaybackStateKind = .idle
+  var hasReportedState: Bool = false
   var lastPositionMs: Int64 = 0
   var lastDurationMs: Int64 = 0
   var lastBufferedMs: Int64 = 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
@@ -3952,10 +3961,12 @@ class TrackPlayer: HybridTrackPlayerSpec {
   ///   pre-wrote.
   ///
   /// Repeat-track handling: when `repeatModeState == .track`, seek
-  /// the just-finished item back to zero + replay. The notification
-  /// fires BEFORE AVQueuePlayer auto-advances (per Apple docs), so
-  /// we get the chance to rewind without flashing through the next
-  /// item. We do NOT set `didPlayToEndPending` in this branch —
+  /// the just-finished item back to zero + replay. The gapless engine
+  /// holds the item at its end (`AVQueuePlayer.actionAtItemEnd = .none`
+  /// under `.track`, set in `GaplessEngine.setRepeatMode`), so the
+  /// player does not advance and `player.currentItem` is still the
+  /// finished item when this async block runs — the rewind is
+  /// deterministic. We do NOT set `didPlayToEndPending` in this branch —
   /// the seek-to-zero produces no `\.currentItem` change, so there
   /// is no auto-advance to gate.
   @objc private func handlePlayerItemDidPlayToEndTime(_ notification: Notification) {
@@ -3968,30 +3979,21 @@ class TrackPlayer: HybridTrackPlayerSpec {
       let sleepFired = self.sleepTimerCore.fireAtTrackEnd()
       if sleepFired.pauseNow { self.applySleepTimerResult(sleepFired) }
       // Branch on repeat-track FIRST, separately from the
-      // currentItem === item check. The notification dispatches
-      // async to main but AVQueuePlayer
-      // runs `actionAtItemEnd = .advance` synchronously on its own
-      // queue — under load, the player can have already advanced
-      // by the time our async block runs. Falling through to the
-      // auto-advance branch in repeat-track mode would incorrectly
-      // arm `didPlayToEndPending`; the resync would then run on
-      // the unintended-advance currentItem and clobber the user's
-      // expected repeat-track stay-on-current.
+      // currentItem === item check, and never arm `didPlayToEndPending`
+      // here — in repeat-track mode there is no auto-advance to gate.
       if self.repeatModeState == .track {
-        // Repeat-track: rewind the just-finished item + replay.
-        // Apple's docs note the notification fires BEFORE
-        // actionAtItemEnd is honoured, so the seek-to-zero +
-        // play normally beats the auto-advance.
+        // Repeat-track: rewind the just-finished item + replay. The
+        // gapless engine holds the item via `actionAtItemEnd = .none`
+        // under `.track`, so the player does not advance and
+        // `currentItem` is still the finished item here.
         if let player = self.player {
           // Repeat-one loop = a new milestone playthrough of the same track.
           // The gapless engine fires no track-change / delegate here, so
           // dispatchTrackChange's reset is skipped — reset directly, and
-          // UNCONDITIONALLY for the gapless engine (self.player non-nil), not
-          // only when the rewind race below is won: under load this async block
-          // can run AFTER AVQueuePlayer already chain-advanced, in which case
-          // the seek is skipped but the track still loops, so milestones must
-          // re-arm regardless. (CrossfadeEngine has self.player == nil here and
-          // resets via engineDidPlayItemToEnd instead — no double reset.)
+          // UNCONDITIONALLY for the gapless engine (self.player non-nil), so
+          // milestones re-arm for the new playthrough. (CrossfadeEngine has
+          // self.player == nil here and resets via engineDidPlayItemToEnd
+          // instead — no double reset.)
           self.milestoneTracker.reset()
           if let item = notification.object as? AVPlayerItem,
              player.currentItem === item {
@@ -4003,15 +4005,13 @@ class TrackPlayer: HybridTrackPlayerSpec {
             if !sleepFired.pauseNow { self.engine?.play() }
           }
         }
-        // If the rewind window was lost (player chain-advanced
-        // before our async block ran), accept that the
-        // KVO fire will re-sync currentTrackIndex via the next
-        // currentItem change — but DO NOT arm `didPlayToEndPending`
-        // here, because in repeat-track mode the auto-advance
-        // shouldn't have happened. The resync via KVO without
-        // didPlayToEndPending stays correct because user
-        // mutations pre-write the index; nothing overwrites the
-        // shadow index incorrectly.
+        // Defense in depth: if `currentItem` is somehow not the finished
+        // item (e.g. a mode change raced this fire before `.none` was
+        // applied), skip the rewind and let the `\.currentItem` KVO
+        // re-sync `currentTrackIndex` — WITHOUT arming
+        // `didPlayToEndPending`, since repeat-track should not advance.
+        // User mutations pre-write the index, so the shadow index stays
+        // correct.
         return
       }
       // Repeat-off / repeat-queue: arm the resync gate so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-queue-player",
-  "version": "1.1.1",
+  "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)
-                }
-            }
-        }
-    }
-}