react-native-audio-browser 0.2.0-next.76 → 0.2.0-next.78

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +1 -1
  2. package/android/src/main/java/com/audiobrowser/player/EnginePlayback.kt +9 -5
  3. package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +71 -39
  4. package/android/src/main/java/com/audiobrowser/player/LiveStreamExtractor.kt +65 -0
  5. package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +12 -3
  6. package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +5 -0
  7. package/android/src/main/java/com/audiobrowser/player/Player.kt +78 -36
  8. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +6 -0
  9. package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +1 -1
  10. package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +48 -2
  11. package/android/src/test/java/androidx/media3/session/SessionViews.kt +10 -0
  12. package/android/src/test/java/com/audiobrowser/player/LiveStreamEndTest.kt +372 -0
  13. package/android/src/test/java/com/audiobrowser/player/PlayerSetupEndedTest.kt +221 -0
  14. package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +17 -7
  15. package/android/src/test/java/com/audiobrowser/player/PlayerSuppressionTest.kt +183 -7
  16. package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +48 -0
  17. package/android/src/test/java/com/audiobrowser/player/SessionPlayTest.kt +236 -0
  18. package/android/src/test/java/com/audiobrowser/player/SessionViewRulesTest.kt +62 -0
  19. package/android/src/test/java/com/audiobrowser/player/SessionViewTest.kt +188 -0
  20. package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +23 -0
  21. package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +74 -0
  22. package/ios/AVPlayerEngine.swift +5 -1
  23. package/ios/Browser/BrowserManager.swift +2 -2
  24. package/ios/Browser/PageResolver.swift +14 -19
  25. package/ios/Browser/RequestPipeline.swift +6 -4
  26. package/ios/CarPlay/CarPlayNowPlayingManager.swift +1 -1
  27. package/ios/CarPlay/CarPlaySession+PageLoader.swift +1 -0
  28. package/ios/CarPlay/CarPlaySession+TabBar.swift +2 -0
  29. package/ios/Extension/Promise+AwaitCallback.swift +33 -0
  30. package/ios/HybridAudioBrowser+Player.swift +1 -1
  31. package/ios/HybridAudioBrowser.swift +1 -1
  32. package/ios/Player/MediaLoader.swift +1 -1
  33. package/ios/Player/PlaybackFailure.swift +3 -3
  34. package/ios/Player/Player.swift +67 -49
  35. package/ios/Player/PlayerEngine.swift +2 -0
  36. package/ios/Player/RetryLoop.swift +72 -12
  37. package/ios/Tests/AwaitCallbackTests.swift +210 -0
  38. package/ios/Tests/GenerationMemoTests.swift +57 -0
  39. package/ios/Tests/PlaybackFailureTests.swift +7 -0
  40. package/ios/Tests/PlayerPolicyTests.swift +346 -6
  41. package/ios/Tests/PlayerTests.swift +79 -1
  42. package/ios/Tests/RetryLoopTests.swift +30 -5
  43. package/ios/Tests/Support/TestTypes.swift +15 -7
  44. package/ios/Tests/Support/TimeLimit.swift +43 -0
  45. package/ios/Util/AwaitCallback.swift +80 -0
  46. package/ios/Util/GenerationMemo.swift +11 -4
  47. package/package.json +1 -1
  48. package/android/src/test/java/com/audiobrowser/player/SessionErrorMaskTest.kt +0 -63
  49. package/ios/Player/EndOfTrackJudgement.swift +0 -25
  50. package/ios/Tests/EndOfTrackJudgementTests.swift +0 -30
@@ -0,0 +1,188 @@
1
+ package com.audiobrowser.player
2
+
3
+ import android.net.Uri
4
+ import android.os.Looper
5
+ import androidx.media3.common.C
6
+ import androidx.media3.common.Player as MediaPlayer
7
+ import androidx.media3.session.MediaSession
8
+ import androidx.media3.session.controllerTitle
9
+ import androidx.media3.session.legacy.PlaybackStateCompat
10
+ import androidx.media3.session.legacyState
11
+ import com.audiobrowser.Callbacks
12
+ import com.audiobrowser.TestFixtures
13
+ import com.audiobrowser.model.PlayerSetupOptions
14
+ import com.audiobrowser.model.RetryPolicy
15
+ import com.audiobrowser.util.TrackFactory
16
+ import com.margelo.nitro.audiobrowser.PlaybackState
17
+ import java.io.File
18
+ import java.nio.ByteBuffer
19
+ import java.nio.ByteOrder
20
+ import java.time.Duration
21
+ import org.junit.After
22
+ import org.junit.Assert.assertEquals
23
+ import org.junit.Assert.fail
24
+ import org.junit.Rule
25
+ import org.junit.Test
26
+ import org.junit.rules.TemporaryFolder
27
+ import org.junit.runner.RunWith
28
+ import org.mockito.Mockito.mock
29
+ import org.robolectric.RobolectricTestRunner
30
+ import org.robolectric.RuntimeEnvironment
31
+ import org.robolectric.Shadows.shadowOf
32
+ import org.robolectric.annotation.Config
33
+ import org.robolectric.shadows.ShadowSystemClock
34
+
35
+ /**
36
+ * What the session tells legacy controllers (Android Auto, Bluetooth, the system UI) for each state
37
+ * on an idle engine.
38
+ */
39
+ @RunWith(RobolectricTestRunner::class)
40
+ @Config(sdk = [28])
41
+ class SessionViewTest {
42
+
43
+ @get:Rule val folder = TemporaryFolder()
44
+
45
+ private val context = RuntimeEnvironment.getApplication()
46
+ private val player = Player(context)
47
+ private val callbacks = mock(Callbacks::class.java)
48
+ private lateinit var session: MediaSession
49
+
50
+ private val paused = PlaybackStateCompat.STATE_PAUSED
51
+ private val idle = PlaybackStateCompat.STATE_NONE
52
+
53
+ @After
54
+ fun release() {
55
+ session.release()
56
+ player.networkMonitor.destroy()
57
+ player.exoPlayer.release()
58
+ }
59
+
60
+ @Test
61
+ fun `a cancelled retry reads paused`() {
62
+ play(RetryPolicy.Infinite())
63
+ idleUntil("a pending retry") { player.playbackError?.retrying == true }
64
+
65
+ player.pause()
66
+ idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
67
+
68
+ assertEquals(PlaybackState.PAUSED, player.playbackState)
69
+ assertEquals(paused, session.legacyState())
70
+ }
71
+
72
+ @Test
73
+ fun `a terminal error reads paused`() {
74
+ failTerminally()
75
+
76
+ assertEquals(paused, session.legacyState())
77
+ }
78
+
79
+ @Test
80
+ fun `an error a rebuild dropped reads paused`() {
81
+ failTerminally()
82
+
83
+ player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
84
+ shadowOf(Looper.getMainLooper()).idle()
85
+
86
+ assertEquals(PlaybackState.ERROR, player.playbackState)
87
+ assertEquals(paused, session.legacyState())
88
+ }
89
+
90
+ @Test
91
+ fun `a stop after a terminal error reads idle`() {
92
+ failTerminally()
93
+
94
+ player.stop()
95
+ shadowOf(Looper.getMainLooper()).idle()
96
+
97
+ assertEquals(idle, session.legacyState())
98
+ }
99
+
100
+ @Test
101
+ fun `a stop after a cancelled retry reads idle`() {
102
+ play(RetryPolicy.Infinite())
103
+ idleUntil("a pending retry") { player.playbackError?.retrying == true }
104
+ player.pause()
105
+ idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
106
+
107
+ player.stop()
108
+ shadowOf(Looper.getMainLooper()).idle()
109
+
110
+ assertEquals(idle, session.legacyState())
111
+ }
112
+
113
+ @Test
114
+ fun `an ended queue a rebuild carried idle reads ended`() {
115
+ play(RetryPolicy.Default, Uri.fromFile(silentWav()).toString())
116
+ idleUntil("ENDED") { player.playbackState == PlaybackState.ENDED }
117
+
118
+ player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
119
+ shadowOf(Looper.getMainLooper()).idle()
120
+
121
+ assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
122
+ assertEquals(PlaybackStateCompat.STATE_STOPPED, session.legacyState())
123
+ }
124
+
125
+ @Test
126
+ fun `the session hears the current track's title`() {
127
+ play(RetryPolicy.Default, Uri.fromFile(silentWav()).toString())
128
+ idleUntil("ENDED") { player.playbackState == PlaybackState.ENDED }
129
+
130
+ assertEquals("T", session.controllerTitle())
131
+ }
132
+
133
+ private fun failTerminally() {
134
+ play(RetryPolicy.Limited(maxRetries = 0))
135
+ idleUntil("a terminal error") { player.playbackState == PlaybackState.ERROR }
136
+ }
137
+
138
+ private fun play(retryPolicy: RetryPolicy, src: String = "https://127.0.0.1:9/stream") {
139
+ player.setup(PlayerSetupOptions(retryPolicy = retryPolicy))
140
+ player.setCallbacks(callbacks)
141
+ session = MediaSession.Builder(context, player.forwardingPlayer).build()
142
+ player.setMediaSession(session)
143
+ player.exoPlayer.trackSelectionParameters =
144
+ player.exoPlayer.trackSelectionParameters
145
+ .buildUpon()
146
+ .setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, true)
147
+ .build()
148
+ player.exoPlayer.setMediaItems(listOf(TrackFactory.toMedia3(TestFixtures.track(src = src))))
149
+ player.exoPlayer.prepare()
150
+ player.play()
151
+ }
152
+
153
+ private fun idleUntil(what: String, condition: () -> Boolean) {
154
+ val deadline = System.currentTimeMillis() + 5_000
155
+ while (!condition()) {
156
+ if (System.currentTimeMillis() > deadline)
157
+ fail(
158
+ "timed out waiting for $what: ${player.playbackState}, exo ${player.exoPlayer.playbackState}"
159
+ )
160
+ ShadowSystemClock.advanceBy(Duration.ofMillis(100))
161
+ Thread.sleep(10)
162
+ shadowOf(Looper.getMainLooper()).idle()
163
+ }
164
+ }
165
+
166
+ /** Half a second of 8 kHz mono 8-bit silence. */
167
+ private fun silentWav(): File {
168
+ val samples = 4_000
169
+ val header =
170
+ ByteBuffer.allocate(44).order(ByteOrder.LITTLE_ENDIAN).apply {
171
+ put("RIFF".toByteArray())
172
+ putInt(36 + samples)
173
+ put("WAVEfmt ".toByteArray())
174
+ putInt(16)
175
+ putShort(1)
176
+ putShort(1)
177
+ putInt(8_000)
178
+ putInt(8_000)
179
+ putShort(1)
180
+ putShort(8)
181
+ put("data".toByteArray())
182
+ putInt(samples)
183
+ }
184
+ return folder.newFile("silence.wav").apply {
185
+ writeBytes(header.array() + ByteArray(samples) { 0x80.toByte() })
186
+ }
187
+ }
188
+ }
@@ -4,12 +4,14 @@ import android.os.Looper
4
4
  import androidx.media3.common.C
5
5
  import androidx.media3.common.DeviceInfo
6
6
  import androidx.media3.common.MediaItem
7
+ import androidx.media3.common.Metadata
7
8
  import androidx.media3.common.PlaybackException
8
9
  import androidx.media3.common.PlaybackParameters
9
10
  import androidx.media3.common.Player as MediaPlayer
10
11
  import androidx.media3.common.SimpleBasePlayer
11
12
  import androidx.media3.common.TrackSelectionParameters
12
13
  import androidx.media3.common.util.Util
14
+ import androidx.media3.extractor.metadata.icy.IcyInfo
13
15
  import com.google.common.util.concurrent.Futures
14
16
  import com.google.common.util.concurrent.ListenableFuture
15
17
 
@@ -24,6 +26,16 @@ internal class FakeLocalPlayer(looper: Looper) : SimpleBasePlayer(looper) {
24
26
  private var repeat = REPEAT_MODE_OFF
25
27
  private var shuffle = false
26
28
  private val uids = mutableListOf<Any>()
29
+ private var metadata = Metadata(C.TIME_UNSET)
30
+
31
+ /**
32
+ * Sends a stream title. ExoPlayer sends each one it decodes; this state emits only a change, so a
33
+ * stop clears it for the stream's first title after a reconnect to go out again.
34
+ */
35
+ fun title(title: String) {
36
+ metadata = Metadata(0, IcyInfo(title.toByteArray(), title, null))
37
+ invalidateState()
38
+ }
27
39
 
28
40
  override fun getState(): State =
29
41
  State.Builder()
@@ -42,6 +54,7 @@ internal class FakeLocalPlayer(looper: Looper) : SimpleBasePlayer(looper) {
42
54
  .setPlaybackState(if (items.isEmpty()) STATE_IDLE else readiness)
43
55
  .setRepeatMode(repeat)
44
56
  .setShuffleModeEnabled(shuffle)
57
+ .setTimedMetadata(metadata)
45
58
  .build()
46
59
 
47
60
  /** Moves to [index] without a seek, as the player does at an item's end. */
@@ -84,6 +97,7 @@ internal class FakeLocalPlayer(looper: Looper) : SimpleBasePlayer(looper) {
84
97
 
85
98
  override fun handleStop(): ListenableFuture<*> {
86
99
  readiness = STATE_IDLE
100
+ metadata = Metadata(C.TIME_UNSET)
87
101
  stops++
88
102
  return done()
89
103
  }
@@ -140,6 +154,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
140
154
  var lagging = false
141
155
  private var held: MediaItem? = null
142
156
  private var uid = Any()
157
+ private var metadata: Metadata? = null
143
158
 
144
159
  fun catchUp() {
145
160
  held?.let { item = it }
@@ -155,6 +170,12 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
155
170
 
156
171
  fun update() = invalidateState()
157
172
 
173
+ /** Reports a stream title for whatever it plays, as a receiver's poll does; a load clears it. */
174
+ fun title(title: String) {
175
+ metadata = Metadata(0, IcyInfo(title.toByteArray(), title, null))
176
+ invalidateState()
177
+ }
178
+
158
179
  override fun getState(): State =
159
180
  State.Builder()
160
181
  .setAvailableCommands(MediaPlayer.Commands.Builder().addAllCommands().build())
@@ -169,6 +190,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
169
190
  .setPlaybackState(if (item == null) STATE_IDLE else readiness)
170
191
  .setDeviceInfo(DEVICE_INFO)
171
192
  .setDeviceVolume(volume)
193
+ .apply { metadata?.let(::setTimedMetadata) }
172
194
  .build()
173
195
 
174
196
  override fun handleSetMediaItems(
@@ -180,6 +202,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
180
202
  loads += SentLoad(loaded, startPositionMs, intent)
181
203
  // A fresh uid makes a reload of the same item a new playlist entry to listeners.
182
204
  uid = Any()
205
+ metadata = null
183
206
  positionMs = if (startPositionMs == C.TIME_UNSET) 0 else startPositionMs
184
207
  readiness = STATE_READY
185
208
  if (lagging) held = loaded else item = loaded
@@ -3,8 +3,10 @@ package com.audiobrowser.remote
3
3
  import android.os.Looper
4
4
  import androidx.media3.common.C
5
5
  import androidx.media3.common.MediaItem
6
+ import androidx.media3.common.Metadata
6
7
  import androidx.media3.common.PlaybackException
7
8
  import androidx.media3.common.Player as MediaPlayer
9
+ import androidx.media3.extractor.metadata.icy.IcyInfo
8
10
  import java.time.Duration
9
11
  import kotlinx.coroutines.CompletableDeferred
10
12
  import kotlinx.coroutines.MainScope
@@ -870,6 +872,61 @@ class RemoteSwitchingPlayerTest {
870
872
  assertEquals(200_000, player.currentPosition)
871
873
  }
872
874
 
875
+ @Test
876
+ fun `a title for the outgoing item while the next one resolves never shows on it`() {
877
+ playLocally(listOf("a", "b"))
878
+ remote.startSession()
879
+ idle()
880
+ remote.player.title("A 1")
881
+ idle()
882
+ val seen = transitionsAndTitles()
883
+ gate = CompletableDeferred()
884
+
885
+ player.seekToNextMediaItem()
886
+ idle()
887
+ remote.player.title("A 2")
888
+ idle()
889
+ gate!!.complete(Unit)
890
+ idle()
891
+ remote.player.title("B 1")
892
+ idle()
893
+
894
+ assertEquals(listOf("b", "B 1"), seen)
895
+ }
896
+
897
+ @Test
898
+ fun `a new load of the same stream shows its title again`() {
899
+ playLocally(listOf("a"))
900
+ remote.startSession()
901
+ idle()
902
+ remote.player.title("Song")
903
+ idle()
904
+ val seen = transitionsAndTitles()
905
+
906
+ player.setMediaItems(items("a"))
907
+ idle()
908
+ remote.player.title("Song")
909
+ idle()
910
+
911
+ assertEquals(listOf("a", "Song"), seen)
912
+ }
913
+
914
+ @Test
915
+ fun `a play after a local stop shows the stream's title again`() {
916
+ playLocally(listOf("a"))
917
+ local.title("Song")
918
+ idle()
919
+ val seen = transitionsAndTitles()
920
+
921
+ player.stop()
922
+ player.prepare()
923
+ idle()
924
+ local.title("Song")
925
+ idle()
926
+
927
+ assertEquals(listOf("Song"), seen)
928
+ }
929
+
873
930
  @Test
874
931
  fun `release brings playback back and lets every remote go`() {
875
932
  playLocally(listOf("a"))
@@ -906,6 +963,23 @@ class RemoteSwitchingPlayerTest {
906
963
  idle()
907
964
  }
908
965
 
966
+ /** The id of each item transitioned to, and each stream title, in the order the player tells. */
967
+ private fun transitionsAndTitles(): List<String> {
968
+ val seen = mutableListOf<String>()
969
+ player.addListener(
970
+ object : MediaPlayer.Listener {
971
+ override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
972
+ seen += mediaItem?.mediaId.orEmpty()
973
+ }
974
+
975
+ override fun onMetadata(metadata: Metadata) {
976
+ seen += (metadata[0] as IcyInfo).title.orEmpty()
977
+ }
978
+ }
979
+ )
980
+ return seen
981
+ }
982
+
909
983
  private fun queue() = (0 until player.mediaItemCount).map { player.getMediaItemAt(it).mediaId }
910
984
 
911
985
  private fun SentLoad.short() = Triple(item.mediaId, positionMs, autoplay)
@@ -162,10 +162,14 @@ final class AVPlayerEngine: PlayerEngine {
162
162
  itemObserver = nil
163
163
  }
164
164
 
165
+ var playerFailed: Bool { avPlayer.status == .failed }
166
+
165
167
  func recreate() {
166
168
  playerObserver?.invalidate()
167
169
  nowPlayingInfoController.unlinkPlayer()
170
+ let volume = avPlayer.volume
168
171
  avPlayer = AVPlayer()
172
+ avPlayer.volume = volume
169
173
  setUpAVPlayer()
170
174
  }
171
175
 
@@ -264,7 +268,7 @@ final class AVPlayerEngine: PlayerEngine {
264
268
  private func playerDidEmit(_ event: PlayerObserver.Event) {
265
269
  switch event {
266
270
  case let .status(status):
267
- if status == .failed { reportFailure(nil) }
271
+ if status == .failed { reportFailure(avPlayer.error) }
268
272
  case let .timeControlStatus(status):
269
273
  let mapped: PlayerTimeControlStatus
270
274
  switch status {
@@ -87,7 +87,7 @@ final class BrowserManager {
87
87
  func awaitTrackLoadHandler(event: TrackLoadEvent) async -> Bool {
88
88
  guard let handler = config.handleTrackLoad else { return false }
89
89
  do {
90
- try await handler(event).await().await()
90
+ try await handler(event).awaitNested()
91
91
  } catch {
92
92
  logger.error("handleTrackLoad failed: \(error.localizedDescription)")
93
93
  }
@@ -204,7 +204,7 @@ final class BrowserManager {
204
204
  let params = FormatNavigationErrorParams(
205
205
  error: error, defaultFormatted: fallback, path: path, kind: NavigationErrorKind(path: path),
206
206
  )
207
- return await (try? formatter(params).await()) ?? fallback
207
+ return await (try? formatter(params).awaitOrTimeout()) ?? fallback
208
208
  }
209
209
 
210
210
  // MARK: - Search
@@ -57,7 +57,7 @@ final class PageResolver {
57
57
  throw BrowserError.contentNotFound(path: SimpleRouter.searchRoutePath)
58
58
  }
59
59
  if let callback = searchEntry.searchCallback {
60
- return try await callback(params).await().await()
60
+ return try await callback(params).awaitNested()
61
61
  }
62
62
  if let searchConfig = searchEntry.searchConfig {
63
63
  return try await requests.fetchSearch(searchConfig, params: params)
@@ -76,13 +76,13 @@ final class PageResolver {
76
76
  let callbackParam = BrowserSourceCallbackParam(path: path, routeParams: params)
77
77
  // Nitro flattens `(ResolvedTrack | BrowseError) | Promise<BrowseResult>` into three arms:
78
78
  // a sync track, a sync error, or a promise of the same two.
79
- switch try await callback(callbackParam).await() {
79
+ switch try await callback(callbackParam).awaitCancellable() {
80
80
  case let .first(resolvedTrack):
81
81
  return resolvedTrack
82
82
  case let .second(browseError):
83
83
  throw BrowserError.callbackError(browseError.error)
84
84
  case let .third(promise):
85
- switch try await promise.await() {
85
+ switch try await promise.awaitCancellable() {
86
86
  case let .first(resolvedTrack):
87
87
  return resolvedTrack
88
88
  case let .second(browseError):
@@ -115,23 +115,18 @@ final class PageResolver {
115
115
  ) async throws -> [Section] {
116
116
  let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: parentPath)
117
117
  let artworkConfig = routeEntry?.artwork
118
- let artworkLoads = stamped.map { section in
119
- section.children.map { track in
120
- Task<ImageSource?, Never> { @MainActor in
121
- await self.requests.resolveArtworkUrl(track: track, perRouteConfig: artworkConfig)
122
- }
123
- }
118
+ let tracks = stamped.flatMap(\.children)
119
+ let artwork = await Array(tracks.indices).concurrentMap { index in
120
+ await self.requests.resolveArtworkUrl(track: tracks[index], perRouteConfig: artworkConfig)
124
121
  }
125
-
126
- var transformed: [Section] = []
127
- for (section, loads) in zip(stamped, artworkLoads) {
128
- var children: [Track] = []
129
- for (track, load) in zip(section.children, loads) {
130
- let artwork = await load.value
131
- children.append(artwork.map { track.copying(artworkSource: $0) } ?? track)
132
- }
133
- transformed.append(section.copying(children: children))
122
+ // A cancelled resolve gives no artwork; that page must not reach the cache.
123
+ try Task.checkCancellation()
124
+ var next = 0
125
+ return stamped.map { section in
126
+ section.copying(children: section.children.map { track in
127
+ defer { next += 1 }
128
+ return artwork[next].map { track.copying(artworkSource: $0) } ?? track
129
+ })
134
130
  }
135
- return transformed
136
131
  }
137
132
  }
@@ -37,8 +37,8 @@ final class RequestPipeline {
37
37
  let config = self.config
38
38
  // Double await: the TS side wraps a sync-or-async thunk in a JS promise, behind the
39
39
  // bridge's promise.
40
- let request = try await config.requestResolver?().await().await() ?? config.request
41
- let browse = try await config.browseResolver?().await().await() ?? config.browse
40
+ let request = try await config.requestResolver?().awaitNested() ?? config.request
41
+ let browse = try await config.browseResolver?().awaitNested() ?? config.browse
42
42
  return ResolvedLayers(request: request, browse: browse)
43
43
  }
44
44
  }
@@ -246,6 +246,8 @@ final class RequestPipeline {
246
246
  headers: RequestLayer.imageHeaders(request),
247
247
  body: request.body,
248
248
  )
249
+ } catch is CancellationError {
250
+ return nil
249
251
  } catch {
250
252
  logger.error("Failed to transform artwork URL for track: \(track.title), error: \(error.localizedDescription)")
251
253
  return nil
@@ -258,12 +260,12 @@ final class RequestPipeline {
258
260
  /// bridge hop, then the JS promise): a single await hands a `Promise` downstream. Copies the
259
261
  /// result out.
260
262
  func awaitAsyncConfig(_ promise: Promise<Promise<RequestConfig>>) async throws -> RequestConfig {
261
- try await extractConfig(promise.await().await())
263
+ try await extractConfig(promise.awaitNested())
262
264
  }
263
265
 
264
266
  /// Awaits a sync config callback (one bridge await) and copies the result out.
265
267
  func awaitSyncConfig(_ promise: Promise<RequestConfig>) async throws -> RequestConfig {
266
- try await extractConfig(promise.await())
268
+ try await extractConfig(promise.awaitCancellable())
267
269
  }
268
270
 
269
271
  /// A copy of `config`, so nothing reads the Nitro bridge's value after its Promise is gone.
@@ -202,7 +202,7 @@ final class CarPlayNowPlayingManager {
202
202
  Task { @MainActor [weak self] in
203
203
  let path: String?
204
204
  do {
205
- path = try await resolver(track).await()
205
+ path = try await resolver(track).awaitCancellable()
206
206
  } catch {
207
207
  self?.logger.error("resolveAlbumPath failed: \(error.localizedDescription)")
208
208
  path = nil
@@ -48,6 +48,7 @@ extension CarPlaySession {
48
48
  await showNavigationError(.code(.emptyContent), path: path, on: template)
49
49
  }
50
50
  case let .failure(error):
51
+ guard !(error is CancellationError || Task.isCancelled) else { return }
51
52
  logger.error("Failed to load content for \(path): \(error.localizedDescription)")
52
53
  await showNavigationError(NavigationError.from(error), path: path, on: template)
53
54
  }
@@ -119,6 +119,8 @@ extension CarPlaySession {
119
119
  /// The chrome to show if the Browse Gate gates this request, reported to JS; nil when allowed.
120
120
  func gate(_ reason: GateReason, path: String?, search: SearchParams? = nil) async -> Gate? {
121
121
  let chrome = await audioBrowser.browseGate.decide(NativeGateRequest(reason: reason, path: path, search: search))
122
+ // A cancelled decision fails closed, but the user never met this gate.
123
+ guard !Task.isCancelled else { return chrome }
122
124
  reportGates([chrome], reason: reason)
123
125
  return chrome
124
126
  }
@@ -0,0 +1,33 @@
1
+ import NitroModules
2
+
3
+ /// Awaits for JS callbacks in place of Nitro's `await()`, which ignores cancellation: see
4
+ /// `awaitCallback`. The nested forms are for a callback returning a promise, which crosses the
5
+ /// bridge as `Promise<Promise<U>>`.
6
+ extension Promise {
7
+ func awaitCancellable() async throws -> T {
8
+ try await awaitCallback(subscribe)
9
+ }
10
+
11
+ /// Throws `CallbackTimeoutError` after `callbackFallbackTimeout`; only for a caller with a
12
+ /// fallback.
13
+ func awaitOrTimeout() async throws -> T {
14
+ try await awaitCallback(timeout: callbackFallbackTimeout, subscribe)
15
+ }
16
+
17
+ func awaitNested<U>() async throws -> U where T == Promise<U> {
18
+ try await awaitCallback(subscribeNested)
19
+ }
20
+
21
+ /// The timeout covers both promises.
22
+ func awaitNestedOrTimeout<U>() async throws -> U where T == Promise<U> {
23
+ try await awaitCallback(timeout: callbackFallbackTimeout, subscribeNested)
24
+ }
25
+
26
+ private func subscribe(_ deliver: @escaping @Sendable (Result<T, Error>) -> Void) {
27
+ then { deliver(.success($0)) }.catch { deliver(.failure($0)) }
28
+ }
29
+
30
+ private func subscribeNested<U>(_ deliver: @escaping @Sendable (Result<U, Error>) -> Void) where T == Promise<U> {
31
+ then { $0.subscribe(deliver) }.catch { deliver(.failure($0)) }
32
+ }
33
+ }
@@ -132,7 +132,7 @@ public extension HybridAudioBrowser {
132
132
  func retry() throws {
133
133
  // Re-resolves rather than replaying the cached URL: short-lived URLs or tokens may have
134
134
  // expired since the failure.
135
- onMainActor { player?.reloadResolving(startFromCurrentTime: true) }
135
+ onMainActor { player?.retryNow() }
136
136
  }
137
137
 
138
138
  // MARK: - Sleep Timer
@@ -262,7 +262,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
262
262
  }
263
263
  browseGate.resolve = { [weak self] request in
264
264
  guard let self else { throw CancellationError() }
265
- return try await resolveGate(request).await().await()
265
+ return try await resolveGate(request).awaitNestedOrTimeout()
266
266
  }
267
267
  // Unconditional: `shared` is weak, so after a reload the old instance may be gone while
268
268
  // CarPlay is still subscribed to its emitters.
@@ -54,7 +54,7 @@ final class MediaLoader {
54
54
  func resolveAndLoad(src: String, track: Track? = nil) {
55
55
  mediaResolverTask?.cancel()
56
56
  // `self` stays weak across the await: a consumer resolver that never settles must not pin
57
- // the loader, and cancellation cannot force its `await` to return.
57
+ // the loader.
58
58
  let resolveUrl = resolveUrl
59
59
  mediaResolverTask = Task { [weak self] in
60
60
  guard !Task.isCancelled else { return }
@@ -15,8 +15,8 @@ enum PlaybackFailure {
15
15
  /// The two answers rank the evidence differently, on purpose:
16
16
  /// - The error: a transport failure first (no response arrived, so a logged status belongs to
17
17
  /// an earlier attempt), then a non-2xx status, then undecodable media.
18
- /// - Retrying: a status first (a retry cannot change what the server refused), then the error
19
- /// chain. An unrecognized failure counts as retryable, bounded by the retry budgets, as on
18
+ /// - Retrying: a non-2xx status first (a retry cannot change what the server refused), then the
19
+ /// error chain. An unrecognized failure counts as retryable, bounded by the retry budgets, as on
20
20
  /// Android: AVFoundation reports most stream failures opaquely.
21
21
  static func classify(
22
22
  _ error: Error?,
@@ -93,7 +93,7 @@ enum PlaybackFailure {
93
93
  ])
94
94
 
95
95
  private static func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
96
- if let status = httpStatusCode {
96
+ if let status = httpStatusCode, !(200 ... 299).contains(status) {
97
97
  return retryableHTTPStatusCodes.contains(status) || (500 ... 599).contains(status)
98
98
  }
99
99
  guard let error else { return false }