react-native-queue-player 1.0.4 → 1.0.7

package/ios/CarPlaySceneDelegate.swift

@@ -52,11 +52,19 @@ internal class CarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDele
   /// delegate doesn't leak past its scene's lifetime.
   private var snapshotObserver: NSObjectProtocol?
 
+  /// Queue-mirror observer. Fires when the play queue or current index
+  /// changes so the Up Next button's enabled state re-evaluates.
+  /// Removed on scene disconnect.
+  private var queueObserver: NSObjectProtocol?
+
   /// Cached scene-construction template builder. Stateless; the
   /// live tab-bar reference above is what survives across snapshot
   /// updates.
   private let builder = CarPlayBrowseBuilder()
 
+  /// Stateless builder for the Up Next queue list template.
+  private let queueBuilder = CarPlayQueueBuilder()
+
   // MARK: - CPTemplateApplicationSceneDelegate
 
   public func templateApplicationScene(
@@ -122,6 +130,14 @@ internal class CarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDele
       self?.refreshRootTemplate()
     }
 
+    queueObserver = NotificationCenter.default.addObserver(
+      forName: CarPlayQueueProvider.didUpdateNotification,
+      object: coordinator.queueProvider,
+      queue: .main
+    ) { [weak self] _ in
+      self?.refreshUpNextButton()
+    }
+
     coordinator.setCarConnected(true)
     coordinator.bridge.carConnectCallback()?()
   }
@@ -138,6 +154,11 @@ internal class CarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDele
       NotificationCenter.default.removeObserver(observer)
       snapshotObserver = nil
     }
+    if let observer = queueObserver {
+      NotificationCenter.default.removeObserver(observer)
+      queueObserver = nil
+    }
+    CPNowPlayingTemplate.shared.remove(self)
     self.interfaceController = nil
     self.rootTabBar = nil
     CarPlayCoordinator.shared.setCarConnected(false)
@@ -188,14 +209,65 @@ internal class CarPlaySceneDelegate: UIResponder, CPTemplateApplicationSceneDele
   /// nav stack via `pushTemplate(CPNowPlayingTemplate.shared, ...)`
   /// is the supported path for `com.apple.developer.carplay-audio`
   /// apps; embedding the same template in a `CPTabBarTemplate` root
-  /// is NOT — that raises `NSInvalidArgumentException`. Property
-  /// mutation here is intentionally avoided — earlier iOS 26 sim
-  /// experiments setting `isUpNextButtonEnabled = false` /
-  /// `isAlbumArtistButtonEnabled = false` left the template rendering
-  /// blank; baseline defaults work.
+  /// is NOT — that raises `NSInvalidArgumentException`.
+  ///
+  /// Registers self as a `CPNowPlayingTemplateObserver` so the Up Next
+  /// button tap routes into [nowPlayingTemplateUpNextButtonTapped].
+  /// Enables only the Up Next flag + title (when the mirrored queue is
+  /// non-empty); every other Now Playing button keeps baseline defaults.
   private func configureNowPlayingTemplate() {
-    _ = CPNowPlayingTemplate.shared
-    NSLog("[RNQP-CarPlay] CPNowPlayingTemplate.shared touched")
+    CPNowPlayingTemplate.shared.add(self)
+    refreshUpNextButton()
+    NSLog("[RNQP-CarPlay] CPNowPlayingTemplate.shared configured")
+  }
+
+  /// Enable the Up Next button when the mirrored queue has entries.
+  /// Re-run from the queue-mirror observer so the button reflects the
+  /// live queue.
+  private func refreshUpNextButton() {
+    let hasQueue = !(
+      CarPlayCoordinator.shared.queueProvider.getSnapshot()?.entries.isEmpty ?? true
+    )
+    CPNowPlayingTemplate.shared.isUpNextButtonEnabled = hasQueue
+    CPNowPlayingTemplate.shared.upNextTitle = upNextTitle
+  }
+
+  private var upNextTitle: String {
+    NSLocalizedString("Up Next", comment: "CarPlay queue button title")
   }
 
 }
+
+// MARK: - CPNowPlayingTemplateObserver
+
+@available(iOS 14.0, *)
+extension CarPlaySceneDelegate: CPNowPlayingTemplateObserver {
+
+  /// Build the Up Next list from the mirrored queue snapshot and push
+  /// it. Each row taps back to Now Playing after routing the skip
+  /// through the coordinator's `skipToIndexHandler`, which `TrackPlayer`
+  /// registers. No-op when no queue is mirrored yet.
+  func nowPlayingTemplateUpNextButtonTapped(
+    _ nowPlayingTemplate: CPNowPlayingTemplate
+  ) {
+    guard let controller = interfaceController else { return }
+    // Only push from the Now Playing surface — guards against a
+    // spurious double-push if the tap re-fires while the list is up.
+    guard controller.topTemplate === CPNowPlayingTemplate.shared else { return }
+    guard let snapshot = CarPlayCoordinator.shared.queueProvider.getSnapshot(),
+          !snapshot.entries.isEmpty else {
+      return
+    }
+    let list = queueBuilder.buildQueueTemplate(
+      snapshot: snapshot,
+      loader: CarPlayCoordinator.shared.loader,
+      skip: { [weak self] index in
+        CarPlayCoordinator.shared.skipToIndexHandler?(index)
+        // Return to Now Playing — pop the Up Next list off the nav
+        // stack; the Now Playing surface is already beneath it.
+        self?.interfaceController?.popTemplate(animated: true) { _, _ in }
+      }
+    )
+    controller.pushTemplate(list, animated: true) { _, _ in }
+  }
+}

package/ios/Tests/CarPlayQueueBuilderTests.swift

@@ -0,0 +1,145 @@
+import CarPlay
+import XCTest
+@testable import QueuePlayer
+
+/// Coverage for [CarPlayQueueBuilder] — snapshot → Up Next template
+/// conversion, row count + title/detail mapping, truncation at
+/// `CPListTemplate.maximumItemCount`, current-index marking, and the
+/// row-tap skip closure — plus a [CarPlayQueueProvider] round-trip.
+final class CarPlayQueueBuilderTests: XCTestCase {
+
+  private func entry(
+    _ title: String,
+    subtitle: String? = nil,
+    artworkUrl: String? = nil
+  ) -> CarPlayQueueEntry {
+    CarPlayQueueEntry(title: title, subtitle: subtitle, artworkUrl: artworkUrl)
+  }
+
+  private func snapshot(
+    _ entries: [CarPlayQueueEntry],
+    currentIndex: Int
+  ) -> CarPlayQueueSnapshot {
+    CarPlayQueueSnapshot(entries: entries, currentIndex: currentIndex)
+  }
+
+  // MARK: - Template construction
+
+  func testBuildQueueTemplateMapsEntriesToRows() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(
+        [
+          entry("Everlong", subtitle: "Foo Fighters"),
+          entry("Monkey Wrench", subtitle: "Foo Fighters"),
+        ],
+        currentIndex: 0
+      ),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertEqual(items.count, 2)
+    XCTAssertEqual(items[0].text, "Everlong")
+    XCTAssertEqual(items[0].detailText, "Foo Fighters")
+    XCTAssertEqual(items[1].text, "Monkey Wrench")
+  }
+
+  func testBuildQueueTemplateCapsRowsAtMaximumItemCount() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let cap = 5
+    let entries = (0..<cap + 4).map { entry("T-\($0)") }
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(entries, currentIndex: 0),
+      loader: loader,
+      maximumItemCount: cap,
+      skip: { _ in }
+    )
+    let items = template.sections.first?.items ?? []
+    XCTAssertEqual(items.count, cap)
+  }
+
+  func testBuildQueueTemplateMarksCurrentIndex() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(
+        [entry("A"), entry("B"), entry("C")],
+        currentIndex: 1
+      ),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertFalse(items[0].isPlaying)
+    XCTAssertTrue(items[1].isPlaying)
+    XCTAssertFalse(items[2].isPlaying)
+  }
+
+  func testBuildQueueTemplateMarksNothingWhenIndexOutOfRange() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot([entry("A"), entry("B")], currentIndex: -1),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertTrue(items.allSatisfy { !$0.isPlaying })
+  }
+
+  // MARK: - Row-tap skip
+
+  func testRowTapInvokesSkipWithRowIndex() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    var skippedTo: Int?
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot([entry("A"), entry("B"), entry("C")], currentIndex: 0),
+      loader: loader,
+      skip: { skippedTo = $0 }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    let exp = expectation(description: "row handler completes")
+    items[2].handler?(items[2]) { exp.fulfill() }
+    wait(for: [exp], timeout: 2)
+    XCTAssertEqual(skippedTo, 2)
+  }
+
+  // MARK: - Provider round-trip
+
+  func testProviderSetSnapshotMakesSnapshotReadable() {
+    let provider = CarPlayQueueProvider()
+    XCTAssertNil(provider.getSnapshot())
+    provider.setSnapshot(
+      snapshot([entry("A", subtitle: "sub")], currentIndex: 0)
+    )
+    let read = provider.getSnapshot()
+    XCTAssertEqual(read?.entries.count, 1)
+    XCTAssertEqual(read?.entries.first?.title, "A")
+    XCTAssertEqual(read?.entries.first?.subtitle, "sub")
+    XCTAssertEqual(read?.currentIndex, 0)
+  }
+
+  func testProviderSetSnapshotNilClearsCache() {
+    let provider = CarPlayQueueProvider()
+    provider.setSnapshot(snapshot([entry("A")], currentIndex: 0))
+    provider.setSnapshot(nil)
+    XCTAssertNil(provider.getSnapshot())
+  }
+
+  func testProviderSetSnapshotPostsDidUpdateNotification() {
+    let provider = CarPlayQueueProvider()
+    let exp = expectation(
+      forNotification: CarPlayQueueProvider.didUpdateNotification,
+      object: provider,
+      handler: nil
+    )
+    DispatchQueue.global().async {
+      provider.setSnapshot(self.snapshot([self.entry("A")], currentIndex: 0))
+    }
+    wait(for: [exp], timeout: 2)
+  }
+}

package/ios/Tests/FFTProcessorTests.swift

@@ -33,7 +33,7 @@ final class FFTProcessorTests: XCTestCase {
     samples.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: n, sampleRate: 48000)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     XCTAssertEqual(capturedSampleRate, 48000, accuracy: 0.001)
   }
 
@@ -57,7 +57,7 @@ final class FFTProcessorTests: XCTestCase {
     rest.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 256, sampleRate: 44100)
     }
-    wait(for: [emitted], timeout: 1.0)
+    wait(for: [emitted], timeout: 5.0)
     XCTAssertEqual(calls, 1)
   }
 
@@ -74,7 +74,7 @@ final class FFTProcessorTests: XCTestCase {
     buffer.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 128, sampleRate: 44100)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let samples = try XCTUnwrap(capturedSamples)
     XCTAssertEqual(samples.size, 128 * MemoryLayout<Float>.size)
   }
@@ -94,7 +94,7 @@ final class FFTProcessorTests: XCTestCase {
     buffer.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 128, sampleRate: 44100)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     XCTAssertTrue(captured)
     XCTAssertNil(capturedSamples)
   }
@@ -117,7 +117,7 @@ final class FFTProcessorTests: XCTestCase {
     samples.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: n, sampleRate: 48000)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let fft = try XCTUnwrap(capturedFft)
     let mags = arrayBufferToFloats(fft)
     let peakBin = mags.indices.max(by: { mags[$0] < mags[$1] }) ?? -1
@@ -205,7 +205,7 @@ final class FFTProcessorTests: XCTestCase {
     closure(leftIn, leftOut, n, 1, 0, 2)
     closure(rightIn, rightOut, n, 1, 1, 2)
 
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let samples = try XCTUnwrap(capturedSamples)
     XCTAssertEqual(samples.size, n * MemoryLayout<Float>.size)
 
@@ -233,7 +233,9 @@ final class FFTProcessorTests: XCTestCase {
     }
     let exp = expectation(description: "drained")
     DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { exp.fulfill() }
-    wait(for: [exp], timeout: 1.0)
+    // Generous timeout: the 0.1s drain only needs to outlast the 1000ms
+    // throttle window; the ceiling is headroom for a loaded CI main queue.
+    wait(for: [exp], timeout: 10.0)
     XCTAssertEqual(calls, 1, "second back-to-back call must be throttled")
   }
 

package/ios/TrackPlayer.swift

@@ -587,6 +587,22 @@ class TrackPlayer: HybridTrackPlayerSpec {
           canSkipNext: self.cachedSkipCapability.canSkipNext,
           canSkipPrevious: self.cachedSkipCapability.canSkipPrevious
         )
+        // Route CarPlay Up Next row taps through the same steps the
+        // `skipToIndex` Hybrid runs — engine guard, index validation,
+        // and cast routing (a tap during an active cast session jumps
+        // the RECEIVER; the local engine stays paused, so a local index
+        // write would desync from it) — then the local index write.
+        // Set + invoked on main; the scene delegate calls it from the
+        // Up Next row handler.
+        CarPlayCoordinator.shared.skipToIndexHandler = { [weak self] index in
+          guard let self = self else { return }
+          guard self.engine != nil else { return }
+          guard let target = InputGuards.validQueueIndex(
+            Double(index), count: self.tracks.count
+          ) else { return }
+          if CastTransportRouter.routeSkipToIndex(index: target) { return }
+          self.applyNewCurrentIndex(newIndex: target, reason: .userSkipToIndex)
+        }
         // Refresh on every configure() so a header / UA update lands
         // on the next artwork resolve. Live config — read fresh on
         // each track-change resolve.
@@ -891,6 +907,8 @@ class TrackPlayer: HybridTrackPlayerSpec {
     // configure cycle.
     let coordinator = CarPlayCoordinator.shared
     coordinator.dataProvider.setSnapshot(nil)
+    coordinator.queueProvider.setSnapshot(nil)
+    coordinator.skipToIndexHandler = nil
     coordinator.pending.clear()
     coordinator.loader.clearCache()
     // engine.release() drains the underlying AVQueuePlayer's items +
@@ -2089,6 +2107,11 @@ class TrackPlayer: HybridTrackPlayerSpec {
   /// - `destroy` (resets to (false, false) so a final emit lets
   ///   subscribers know the player is gone)
   internal func recomputeCapabilities() {
+    // Every queue / current-index / repeat-mode change funnels through here,
+    // so it's the single point that keeps the CarPlay Up Next mirror current
+    // — done before the skip-capability dedup guard below so reorder/metadata
+    // changes (which don't flip skip capability) still refresh the mirror.
+    syncCarPlayQueueMirror()
     let mode = repeatModeAsSkipMode()
     let count = tracks.count
     let cur = currentTrackIndex
@@ -2109,6 +2132,30 @@ class TrackPlayer: HybridTrackPlayerSpec {
     )
   }
 
+  /// Mirror the live queue + current index into the process-wide
+  /// [CarPlayQueueProvider] so the CarPlay Up Next surface renders the
+  /// current playback queue without round-tripping through JS. Driven
+  /// from `recomputeCapabilities()`, which every queue / current-index /
+  /// repeat-mode change funnels through. An empty queue clears the
+  /// mirror to `nil` so the Up Next button hides. Main-thread only
+  /// (queue state is main-bound).
+  internal func syncCarPlayQueueMirror() {
+    guard !self.tracks.isEmpty else {
+      CarPlayCoordinator.shared.queueProvider.setSnapshot(nil)
+      return
+    }
+    let entries = self.tracks.map { track in
+      CarPlayQueueEntry(
+        title: track.title ?? "",
+        subtitle: track.artist ?? track.album,
+        artworkUrl: track.artworkUrl
+      )
+    }
+    CarPlayCoordinator.shared.queueProvider.setSnapshot(
+      CarPlayQueueSnapshot(entries: entries, currentIndex: self.currentTrackIndex)
+    )
+  }
+
   /// Apply a new `currentTrackIndex` and sync the AVQueuePlayer.
   ///
   /// **Forward skip** (newIndex > oldIndex) — surgical trim of items

package/package.json

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