react-native-audio-browser 0.2.0-next.60 → 0.2.0-next.62

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.
@@ -91,11 +91,9 @@ import com.margelo.nitro.core.NullType
91
91
  import com.margelo.nitro.core.Promise
92
92
  import java.util.concurrent.TimeUnit
93
93
  import java.util.concurrent.atomic.AtomicReference
94
- import kotlin.coroutines.resume
95
- import kotlin.coroutines.resumeWithException
96
- import kotlin.coroutines.suspendCoroutine
97
94
  import kotlin.time.Duration.Companion.seconds
98
95
  import kotlinx.coroutines.CancellationException
96
+ import kotlinx.coroutines.CompletableDeferred
99
97
  import kotlinx.coroutines.CoroutineScope
100
98
  import kotlinx.coroutines.Job
101
99
  import kotlinx.coroutines.MainScope
@@ -151,7 +149,6 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
151
149
  // connected list, holding a binder and a listener.
152
150
  mediaBrowserFuture?.let { MediaBrowser.releaseFuture(it) }
153
151
  mediaBrowserFuture = null
154
- setupPromise = null
155
152
 
156
153
  serviceBinding.unbind(this)
157
154
 
@@ -232,7 +229,9 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
232
229
  private val onBatteryWarningPending: (Boolean) -> Unit = { pending ->
233
230
  post { onBatteryWarningPendingChanged(BatteryWarningPendingChangedEvent(pending)) }
234
231
  }
235
- private var setupPromise: ((Unit) -> Unit)? = null
232
+ // Every setupPlayer waiting for the service awaits it. Replaced on disconnect, after
233
+ // cancelChildren has rejected its waiters.
234
+ private var connectionReady = CompletableDeferred<Unit>()
236
235
 
237
236
  // Staged by setup options or by setters called before the player exists; last write wins, and
238
237
  // [applyPendingPlayerState] consumes them.
@@ -792,18 +791,10 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
792
791
  return@async
793
792
  }
794
793
 
795
- suspendCoroutine<Unit> { continuation ->
796
- Timber.d("Binding to AudioBrowserService")
797
- val bound = serviceBinding.bind(Intent(context, Service::class.java), this@AudioBrowser)
798
-
799
- if (!bound) {
800
- continuation.resumeWithException(
801
- RuntimeException("Failed to bind to AudioBrowserService")
802
- )
803
- } else {
804
- setupPromise = { continuation.resume(Unit) }
805
- }
794
+ if (!serviceBinding.bind(Intent(context, Service::class.java), this@AudioBrowser)) {
795
+ throw RuntimeException("Failed to bind to AudioBrowserService")
806
796
  }
797
+ connectionReady.await()
807
798
  }
808
799
  }
809
800
 
@@ -1150,8 +1141,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
1150
1141
  val sessionToken = SessionToken(context, ComponentName(context, Service::class.java))
1151
1142
  mediaBrowserFuture = MediaBrowser.Builder(context, sessionToken).buildAsync()
1152
1143
 
1153
- setupPromise?.invoke(Unit)
1154
- setupPromise = null
1144
+ connectionReady.complete(Unit)
1155
1145
  }
1156
1146
  }
1157
1147
 
@@ -1171,6 +1161,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
1171
1161
  mainScope.coroutineContext.cancelChildren()
1172
1162
  mediaBrowserFuture = null
1173
1163
  connectedService = null
1164
+ connectionReady = CompletableDeferred()
1174
1165
  Timber.d("AudioBrowser.onServiceDisconnected()")
1175
1166
  }
1176
1167
 
@@ -76,8 +76,7 @@ class PlaybackStateStore(private val player: Player) {
76
76
 
77
77
  /** Restarts the interval, so a [save] on track change is not followed by an immediate repeat. */
78
78
  fun resetPeriodicSave() {
79
- periodicSaveJob?.cancel()
80
- periodicSaveJob = null
79
+ cancelPeriodicSave()
81
80
  launchPeriodicSave()
82
81
  }
83
82
 
@@ -92,11 +91,7 @@ class PlaybackStateStore(private val player: Player) {
92
91
  }
93
92
  }
94
93
 
95
- /**
96
- * Stops the periodic save without a final save, for engine teardown: a save against the released
97
- * player would persist position 0 over the real one.
98
- */
99
- fun cancelPeriodicSave() {
94
+ private fun cancelPeriodicSave() {
100
95
  periodicSaveJob?.cancel()
101
96
  periodicSaveJob = null
102
97
  }
@@ -104,8 +99,8 @@ class PlaybackStateStore(private val player: Player) {
104
99
  /** Stops the periodic save and calls [save] once more. */
105
100
  fun stopPeriodicSave() {
106
101
  cancelPeriodicSave()
107
- // After a natural end, setPlaybackState(ENDED) has saved position 0 and the dropped intent
108
- // calls this afterwards; saving here would make resumption start at the end of the track.
102
+ // After a natural end, setPlaybackState(ENDED) has saved position 0; a save here, from the
103
+ // dropped intent or a teardown, would make resumption start at the end of the track.
109
104
  if (player.playbackState != PlaybackState.ENDED) {
110
105
  save()
111
106
  }
@@ -949,8 +949,8 @@ internal constructor(
949
949
  }
950
950
 
951
951
  fun destroy() {
952
- // No final save: it would persist position 0 from the released player over the real one.
953
- playbackStateStore.cancelPeriodicSave()
952
+ // stop() saves only if playing; before it, so its STOPPED doesn't defeat the ENDED guard.
953
+ playbackStateStore.stopPeriodicSave()
954
954
  // An armed timer would fire pause() into the released player. Cleared before the release,
955
955
  // while a mid-ramp fade can still restore the volume.
956
956
  sleepTimer.clear()
@@ -83,7 +83,10 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
83
83
  )
84
84
  player.callbacks?.onPlaybackActiveTrackChanged(event)
85
85
 
86
- if (reason == MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_AUTO) {
86
+ if (
87
+ reason == MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
88
+ reason == MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_REPEAT
89
+ ) {
87
90
  player.sleepTimer.onTrackEnd()
88
91
  }
89
92
 
@@ -54,6 +54,9 @@ internal class RemoteSwitchingPlayer(
54
54
  private var repeat = MediaPlayer.REPEAT_MODE_OFF
55
55
  private var shuffle = false
56
56
 
57
+ /** Set as the receiver moves on at an item's end; the next [getState] reports it as automatic. */
58
+ private var pendingAutoTransition = false
59
+
57
60
  private sealed interface Route {
58
61
  data object Local : Route
59
62
 
@@ -393,6 +396,7 @@ internal class RemoteSwitchingPlayer(
393
396
  val duration = remote.receiver.duration
394
397
  remote.load = Load.Ended(if (duration == C.TIME_UNSET) positionOn(remote) else duration)
395
398
  } else {
399
+ pendingAutoTransition = true
396
400
  queue.moveTo(next)
397
401
  load(remote, C.TIME_UNSET)
398
402
  }
@@ -459,6 +463,10 @@ internal class RemoteSwitchingPlayer(
459
463
  is Load.Playing -> if (!holds) setPlaybackState(STATE_IDLE).setContentPositionMs(0)
460
464
  }
461
465
  if (queue.isEmpty) setPlaybackState(STATE_IDLE)
466
+ if (pendingAutoTransition) {
467
+ pendingAutoTransition = false
468
+ setPositionDiscontinuity(DISCONTINUITY_REASON_AUTO_TRANSITION, 0)
469
+ }
462
470
  }
463
471
  .build()
464
472
  }
@@ -133,6 +133,28 @@ class PlayerCastTest {
133
133
  assertEquals(10, receiver.volume)
134
134
  }
135
135
 
136
+ @Test
137
+ fun `the end-of-track sleep pauses when the receiver ends a track short of its duration`() {
138
+ player.setQueue(
139
+ arrayOf(
140
+ TestFixtures.track(title = "b", src = "https://s/b.mp3"),
141
+ TestFixtures.track(title = "c", src = "https://s/c.mp3"),
142
+ )
143
+ )
144
+ idleUntil("the first item on the receiver") { receiver.loads.size == 2 }
145
+ receiver.durationMs = 180_000
146
+ receiver.positionMs = 179_000
147
+ receiver.update()
148
+ idle()
149
+ player.sleepTimer.setEndOfTrack()
150
+
151
+ remote.end()
152
+ idleUntil("the next item on the receiver") { receiver.loads.size == 3 }
153
+
154
+ assertTrue(player.sleepTimer.get().isFirst)
155
+ assertFalse(receiver.loads.last().autoplay)
156
+ }
157
+
136
158
  private fun calls(name: String) =
137
159
  mockingDetails(callbacks).invocations.filter { it.method.name == name }
138
160
 
@@ -0,0 +1,48 @@
1
+ package com.audiobrowser.player
2
+
3
+ import com.audiobrowser.TestFixtures
4
+ import com.audiobrowser.model.PlayerSetupOptions
5
+ import com.audiobrowser.util.TrackFactory
6
+ import com.margelo.nitro.audiobrowser.PlaybackState
7
+ import org.junit.Assert.assertEquals
8
+ import org.junit.Before
9
+ import org.junit.Test
10
+ import org.junit.runner.RunWith
11
+ import org.robolectric.RobolectricTestRunner
12
+ import org.robolectric.RuntimeEnvironment
13
+
14
+ @RunWith(RobolectricTestRunner::class)
15
+ class PlayerDestroyTest {
16
+
17
+ private val player = Player(RuntimeEnvironment.getApplication())
18
+
19
+ @Before
20
+ fun load() {
21
+ player.setup(PlayerSetupOptions())
22
+ player.sessionPlayer.setMediaItems(
23
+ listOf(TrackFactory.toMedia3(TestFixtures.track(title = "a", src = "https://s/a.mp3"))),
24
+ 0,
25
+ 5_000,
26
+ )
27
+ player.sessionPlayer.prepare()
28
+ }
29
+
30
+ @Test
31
+ fun destroySavesASeekMadeWhileNotPlaying() {
32
+ player.sessionPlayer.seekTo(8_000)
33
+
34
+ player.destroy()
35
+
36
+ assertEquals(8_000L, player.playbackStateStore.get()?.positionMs)
37
+ }
38
+
39
+ @Test
40
+ fun destroyAfterTheQueueEndedKeepsPositionZero() {
41
+ player.playWhenReady = true
42
+ player.setPlaybackState(PlaybackState.ENDED)
43
+
44
+ player.destroy()
45
+
46
+ assertEquals(0L, player.playbackStateStore.get()?.positionMs)
47
+ }
48
+ }
@@ -0,0 +1,38 @@
1
+ package com.audiobrowser.player
2
+
3
+ import androidx.media3.common.Player as MediaPlayer
4
+ import com.audiobrowser.TestFixtures
5
+ import com.audiobrowser.model.PlayerSetupOptions
6
+ import com.audiobrowser.util.TrackFactory
7
+ import org.junit.After
8
+ import org.junit.Assert.assertFalse
9
+ import org.junit.Assert.assertTrue
10
+ import org.junit.Test
11
+ import org.junit.runner.RunWith
12
+ import org.robolectric.RobolectricTestRunner
13
+ import org.robolectric.RuntimeEnvironment
14
+
15
+ @RunWith(RobolectricTestRunner::class)
16
+ class PlayerSleepTimerTest {
17
+
18
+ private val player = Player(RuntimeEnvironment.getApplication())
19
+
20
+ @After fun release() = player.exoPlayer.release()
21
+
22
+ @Test
23
+ fun `the end-of-track sleep pauses a repeating track when it loops`() {
24
+ player.setup(PlayerSetupOptions())
25
+ val item = TrackFactory.toMedia3(TestFixtures.track())
26
+ player.sessionPlayer.setMediaItems(listOf(item))
27
+ player.playWhenReady = true
28
+ player.sleepTimer.setEndOfTrack()
29
+
30
+ player.playerListener.onMediaItemTransition(
31
+ item,
32
+ MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_REPEAT,
33
+ )
34
+
35
+ assertFalse(player.playWhenReady)
36
+ assertTrue(player.sleepTimer.get().isFirst)
37
+ }
38
+ }
@@ -9,6 +9,7 @@ import androidx.media3.common.PlaybackParameters
9
9
  import androidx.media3.common.Player as MediaPlayer
10
10
  import androidx.media3.common.SimpleBasePlayer
11
11
  import androidx.media3.common.TrackSelectionParameters
12
+ import androidx.media3.common.util.Util
12
13
  import com.google.common.util.concurrent.Futures
13
14
  import com.google.common.util.concurrent.ListenableFuture
14
15
 
@@ -125,6 +126,7 @@ internal data class SentLoad(val item: MediaItem, val positionMs: Long, val auto
125
126
  internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
126
127
  var item: MediaItem? = null
127
128
  var positionMs = 0L
129
+ var durationMs = C.TIME_UNSET
128
130
  var intent = false
129
131
  var readiness = STATE_IDLE
130
132
  var volume = 10
@@ -156,7 +158,11 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
156
158
  override fun getState(): State =
157
159
  State.Builder()
158
160
  .setAvailableCommands(MediaPlayer.Commands.Builder().addAllCommands().build())
159
- .setPlaylist(listOfNotNull(item).map { MediaItemData.Builder(uid).setMediaItem(it).build() })
161
+ .setPlaylist(
162
+ listOfNotNull(item).map {
163
+ MediaItemData.Builder(uid).setMediaItem(it).setDurationUs(Util.msToUs(durationMs)).build()
164
+ }
165
+ )
160
166
  .setCurrentMediaItemIndex(if (item == null) C.INDEX_UNSET else 0)
161
167
  .setContentPositionMs(positionMs)
162
168
  .setPlayWhenReady(intent, PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST)
@@ -12,4 +12,6 @@ enum PlaybackEvent {
12
12
  case audioFrameDecoded
13
13
  case bufferingSufficient
14
14
  case errorOccurred(TrackPlayerError.PlaybackError)
15
+ /// A pause cancelled a pending retry.
16
+ case retryCancelled
15
17
  }
@@ -50,7 +50,10 @@ struct DeferredSeek {
50
50
  return time
51
51
  }
52
52
 
53
- mutating func land() -> Landing {
53
+ /// A seek cut short, as when its item fails, keeps the target for the reload; a seek that cut it
54
+ /// short lands in its place.
55
+ mutating func land(finished: Bool) -> Landing {
56
+ guard finished else { return .none }
54
57
  switch state {
55
58
  case .inFlight:
56
59
  state = .idle
@@ -27,12 +27,13 @@ enum ErrorStatus: Equatable {
27
27
  }
28
28
 
29
29
  /// The status once `event` moves the state from `old` to `new`: an error event is a new
30
- /// terminal report; leaving `.error` clears it, and so does a retrying error reaching a state
31
- /// that carries no advisory error.
30
+ /// terminal report; leaving `.error` clears it, and so does a cancelled retry or a retrying
31
+ /// error reaching a state that carries no advisory error.
32
32
  func after(event: PlaybackEvent, from old: PlaybackState, to new: PlaybackState) -> ErrorStatus {
33
33
  if case let .errorOccurred(error) = event {
34
34
  return .terminal(error, report: terminalReport &+ 1)
35
35
  }
36
+ if case .retryCancelled = event { return .none }
36
37
  if old == .error || (isRetrying && !new.carriesAdvisoryError) { return .none }
37
38
  return self
38
39
  }
@@ -12,6 +12,9 @@ func nextPlaybackState(from current: PlaybackState, on event: PlaybackEvent) ->
12
12
  case .avPlayerPlaying: return .playing
13
13
  case .audioFrameDecoded: return .playing
14
14
  case .errorOccurred: return .error
15
+ case .retryCancelled:
16
+ guard current != .stopped, current != .ended, current != .error else { return nil }
17
+ return .paused
15
18
  case .loadSeekCompleted:
16
19
  guard current == .loading else { return nil }
17
20
  return .ready
@@ -55,6 +55,8 @@ final class Player {
55
55
  var primedNowPlaying = false
56
56
  /// One of this load's items is in the engine; until then it reports the previous one's position.
57
57
  var itemPrepared = false
58
+ /// A pause cancelled this load's retry, leaving the failed item for the next play to replace.
59
+ var reloadOnPlay = false
58
60
 
59
61
  mutating func claimNowPlayingPrime() -> Bool {
60
62
  guard !primedNowPlaying else { return false }
@@ -105,10 +107,16 @@ final class Player {
105
107
  }
106
108
  }
107
109
 
110
+ /// Whether the engine's item is not this Load's playable one: one loads, or a pause cancelled
111
+ /// the retry that was to replace a failed one. A seek waits for the next item meanwhile.
112
+ private var awaitingItem: Bool {
113
+ state == .loading || load?.reloadOnPlay == true
114
+ }
115
+
108
116
  /// Whether the engine reports this Load's position: not before one of its items is prepared,
109
- /// nor while one reloads.
117
+ /// nor while it awaits the next one.
110
118
  private var enginePositionIsCurrent: Bool {
111
- state != .loading && load?.itemPrepared == true
119
+ !awaitingItem && load?.itemPrepared == true
112
120
  }
113
121
 
114
122
  private var resumePosition: TimeInterval? {
@@ -169,16 +177,24 @@ final class Player {
169
177
  // A play during an interruption owns the intent: a later pause must not be auto-resumed.
170
178
  if newValue { shouldResumeAfterInterruption = false }
171
179
 
172
- // A terminal state has no item to play, or one parked at its end: reload, re-resolving a URL
173
- // that may have expired since. Only .error resumes from the last position.
174
- if newValue, state == .error || state == .stopped || state == .ended {
175
- reloadResolving(startFromCurrentTime: state == .error)
180
+ // A terminal state or a cancelled retry has no item to play, or one parked at its end: reload,
181
+ // re-resolving a URL that may have expired since. Only .error and a cancelled retry resume where they failed.
182
+ let resumes = state == .error || load?.reloadOnPlay == true
183
+ if newValue, resumes || state == .stopped || state == .ended {
184
+ reloadResolving(startFromCurrentTime: resumes)
176
185
  }
177
186
  if state != .loading {
178
187
  if newValue { engine.play() } else { engine.pause() }
179
188
  }
180
189
 
181
190
  guard changed else { return }
191
+ // Left to run, the retry would give up on the dropped intent and surface .error.
192
+ if !newValue, retry.pendingTask != nil {
193
+ retry.reset()
194
+ if let position = resumePosition { deferredSeek.capture(position) }
195
+ load?.reloadOnPlay = true
196
+ transition(.retryCancelled)
197
+ }
182
198
  // A pause during the sleep fade ends the timer early, restoring the pre-fade volume.
183
199
  if !newValue, sleepTimerManager.isFading { sleepTimerManager.clear() }
184
200
  publish()
@@ -361,11 +377,14 @@ final class Player {
361
377
  }
362
378
 
363
379
  func stop() {
364
- // Before the intent drop: a pending retry would surface .error and hold the session.
380
+ // A pending retry would turn the stop into .error, and the next play must start over rather
381
+ // than resume where it failed.
365
382
  retry.cancel()
383
+ load?.reloadOnPlay = false
366
384
  shouldResumeAfterInterruption = false
367
385
  transition(.stopped)
368
386
  setPlayWhenReady(false)
387
+ deferredSeek.reset()
369
388
  if currentTrack?.live != true { seek(to: 0) }
370
389
  }
371
390
 
@@ -384,7 +403,7 @@ final class Player {
384
403
  // A nested interruption keeps the intent the first one captured.
385
404
  shouldResumeAfterInterruption = shouldResumeAfterInterruption || playWhenReady
386
405
  pause()
387
- if playbackActive, state != .loading {
406
+ if playbackActive, state != .loading, state != .paused {
388
407
  transition(.avPlayerPaused(hasAsset: engine.hasLoadedAsset))
389
408
  }
390
409
  }
@@ -620,10 +639,11 @@ final class Player {
620
639
 
621
640
  // MARK: - Seeking
622
641
 
623
- /// Seeks the current item. While loading, the target is held until the item is ready and the
624
- /// ready transition waits for it (`DeferredSeek`); `completion` then reports false at once.
642
+ /// Seeks the current item. While it awaits the next item, the target is held until that one is
643
+ /// ready and the ready transition waits for it (`DeferredSeek`); `completion` then reports false
644
+ /// at once.
625
645
  func seek(to seconds: TimeInterval, completion: @escaping @MainActor (Bool) -> Void = { _ in }) {
626
- if state == .loading {
646
+ if awaitingItem {
627
647
  deferredSeek.capture(seconds)
628
648
  completion(false)
629
649
  } else if engine.hasItem {
@@ -634,7 +654,7 @@ final class Player {
634
654
  }
635
655
 
636
656
  func seek(by offset: TimeInterval) {
637
- if state == .loading {
657
+ if awaitingItem {
638
658
  seek(to: (deferredSeek.target ?? 0) + offset)
639
659
  } else if engine.hasItem {
640
660
  seek(to: engine.currentTime + offset)
@@ -646,7 +666,7 @@ final class Player {
646
666
  func seekToLiveEdge() {
647
667
  guard currentTrack?.live == true, engine.hasItem else { return }
648
668
  if let edge = engine.liveEdge {
649
- engine.seek(to: edge) { _ in }
669
+ seek(to: edge)
650
670
  } else {
651
671
  reloadResolving(startFromCurrentTime: false)
652
672
  }
@@ -661,7 +681,7 @@ final class Player {
661
681
  completion(false)
662
682
  return
663
683
  }
664
- seekDidLand()
684
+ seekDidLand(finished: finished)
665
685
  completion(finished)
666
686
  }
667
687
  }
@@ -673,8 +693,8 @@ final class Player {
673
693
  return true
674
694
  }
675
695
 
676
- private func seekDidLand() {
677
- switch deferredSeek.land() {
696
+ private func seekDidLand(finished: Bool) {
697
+ switch deferredSeek.land(finished: finished) {
678
698
  case .done:
679
699
  if state == .loading { transition(.loadSeekCompleted) }
680
700
  case let .reseek(time):
@@ -700,9 +720,12 @@ final class Player {
700
720
  }
701
721
 
702
722
  /// A restart from a terminal error begins a new Load on a new AVPlayer; automatic retries
703
- /// never get here in .error, since the retry loop keeps the state non-terminal. `time` is held
704
- /// as the deferred seek before the loading transition saves the snapshot.
723
+ /// never get here in .error, since the retry loop keeps the state non-terminal. `time`, else the
724
+ /// pending target, is held as the deferred seek before the loading transition saves the snapshot.
705
725
  private func prepareForReload(resumingAt time: TimeInterval?) {
726
+ load?.reloadOnPlay = false
727
+ let target = time ?? deferredSeek.target
728
+ deferredSeek.reset()
706
729
  if state == .error {
707
730
  beginLoad()
708
731
  clearItem()
@@ -712,7 +735,7 @@ final class Player {
712
735
  engine.dropAsset()
713
736
  engine.pause()
714
737
  }
715
- if let time { deferredSeek.capture(time) }
738
+ if let target { deferredSeek.capture(target) }
716
739
  transition(.trackLoading)
717
740
  }
718
741
 
@@ -861,11 +884,10 @@ final class Player {
861
884
  /// connectivity returns re-establishes a stalled stream. AVPlayer doesn't reliably report a
862
885
  /// live stream's mid-stream drop as a failure: it waits with no error, so the retry loop never
863
886
  /// engages. Only while stalled (.buffering) with play intent, so a pause or a retry that gave up
864
- /// isn't resumed; and not while the retry loop is itself waiting for the network, which owns
865
- /// that reload.
887
+ /// isn't resumed; and not while a retry is pending, which owns that reload.
866
888
  func networkStatusDidChange(isOnline: Bool) {
867
889
  engine.renderNowPlaying()
868
- guard isOnline, playWhenReady, state == .buffering, !retry.isWaitingForNetwork else { return }
890
+ guard isOnline, playWhenReady, state == .buffering, retry.pendingTask == nil else { return }
869
891
  logger.info("Connectivity restored while stalled — re-resolving to reconnect")
870
892
  reloadResolving(startFromCurrentTime: true)
871
893
  }
@@ -78,9 +78,6 @@ final class RetryLoop {
78
78
 
79
79
  /// The retry in flight; session release waits while there is one.
80
80
  private(set) var pendingTask: Task<Void, Never>?
81
- /// True only while a scheduled retry waits for connectivity, so a stall-driven reconnect can
82
- /// defer to it rather than load twice.
83
- private(set) var isWaitingForNetwork = false
84
81
  private(set) var attempts = 0
85
82
 
86
83
  /// Continuous audible playback after which the budgets refill (Android's HEALTHY_PLAYBACK_MS).
@@ -171,7 +168,6 @@ final class RetryLoop {
171
168
  attempts = 0
172
169
  firstRetryTime = nil
173
170
  firstOnlineRetryTime = nil
174
- isWaitingForNetwork = false
175
171
  }
176
172
 
177
173
  // MARK: - Healthy Playback
@@ -269,8 +265,6 @@ final class RetryLoop {
269
265
  }
270
266
 
271
267
  private func waitForNetworkRestored(monitor: any NetworkStatusProviding) async -> Bool {
272
- isWaitingForNetwork = true
273
- defer { isWaitingForNetwork = false }
274
268
  while !monitor.isOnline {
275
269
  guard await (try? sleep(0.5)) != nil else { return false }
276
270
  }
@@ -18,7 +18,7 @@ struct DeferredSeekTests {
18
18
  #expect(seek.begin() == 30)
19
19
  #expect(seek.state == .inFlight(30))
20
20
  #expect(seek.defersReady)
21
- #expect(seek.land() == .done)
21
+ #expect(seek.land(finished: true) == .done)
22
22
  #expect(seek.state == .idle)
23
23
  #expect(!seek.defersReady)
24
24
  }
@@ -45,15 +45,23 @@ struct DeferredSeekTests {
45
45
  _ = seek.begin()
46
46
  seek.capture(50)
47
47
  #expect(seek.state == .pending(50))
48
- #expect(seek.land() == .reseek(50))
48
+ #expect(seek.land(finished: true) == .reseek(50))
49
49
  #expect(seek.state == .inFlight(50))
50
- #expect(seek.land() == .done)
50
+ #expect(seek.land(finished: true) == .done)
51
+ }
52
+
53
+ @Test func anUnfinishedLandingKeepsTheTarget() {
54
+ var seek = DeferredSeek()
55
+ seek.capture(30)
56
+ _ = seek.begin()
57
+ #expect(seek.land(finished: false) == .none)
58
+ #expect(seek.state == .inFlight(30))
51
59
  }
52
60
 
53
61
  /// A seek issued while playing is never deferred, so its landing has nothing to do.
54
62
  @Test func aLandingWithNothingInFlightIsNone() {
55
63
  var seek = DeferredSeek()
56
- #expect(seek.land() == .none)
64
+ #expect(seek.land(finished: true) == .none)
57
65
  }
58
66
 
59
67
  @Test func resetDropsTheTargetAndInvalidatesSeeksInFlight() {
@@ -74,6 +74,92 @@ struct PlayerSeekingTests {
74
74
  #expect(player.state == .loading)
75
75
  }
76
76
 
77
+ @Test func aCompletionFromBeforeAReloadIsDropped() throws {
78
+ let engine = MockPlayerEngine()
79
+ let player = makePlayer(engine: engine, retries: false)
80
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
81
+ engine.seekResult = nil
82
+ engine.hasItem = true
83
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
84
+
85
+ player.reloadResolving(startFromCurrentTime: true)
86
+ engine.completeSeeks(true)
87
+ engine.completeSeeks(true)
88
+
89
+ #expect(player.state == .loading)
90
+ #expect(player.deferredSeek.target == 25)
91
+ #expect(engine.seekCalls == [25])
92
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
93
+ #expect(engine.seekCalls == [25, 25])
94
+ }
95
+
96
+ @Test func aStartSeekCutShortWaitsForTheNextItem() throws {
97
+ let engine = MockPlayerEngine()
98
+ let player = makePlayer(engine: engine, retries: false)
99
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
100
+ engine.seekResult = nil
101
+ engine.hasItem = true
102
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
103
+
104
+ engine.completeSeeks(false)
105
+
106
+ #expect(player.state == .loading)
107
+ #expect(player.deferredSeek.target == 25)
108
+ #expect(engine.seekCalls == [25])
109
+ }
110
+
111
+ /// A media-load retry passes no position, so the start in flight is what it resumes from.
112
+ @Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
113
+ let engine = MockPlayerEngine()
114
+ let player = makePlayer(engine: engine, retries: false)
115
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
116
+ engine.seekResult = nil
117
+ engine.hasItem = true
118
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
119
+
120
+ player.reloadResolving(startFromCurrentTime: false)
121
+ engine.completeSeeks(true)
122
+
123
+ #expect(player.state == .loading)
124
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
125
+ #expect(engine.seekCalls == [25, 25])
126
+ }
127
+
128
+ @Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
129
+ let engine = MockPlayerEngine()
130
+ let player = makePlayer(engine: engine, retries: false)
131
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
132
+ engine.seekResult = nil
133
+ engine.hasItem = true
134
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
135
+
136
+ player.stop()
137
+ player.play()
138
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
139
+
140
+ #expect(engine.seekCalls == [25, 0])
141
+ #expect(player.deferredSeek.target == nil)
142
+ }
143
+
144
+ @Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
145
+ let engine = MockPlayerEngine()
146
+ let player = makePlayer(engine: engine, retries: false)
147
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
148
+ engine.seekResult = nil
149
+ engine.hasItem = true
150
+ engine.hasLoadedAsset = true
151
+ engine.liveEdge = 120
152
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
153
+
154
+ player.seekToLiveEdge()
155
+ #expect(engine.seekCalls == [25])
156
+ engine.completeSeeks(true)
157
+ engine.completeSeeks(true)
158
+
159
+ #expect(engine.seekCalls == [25, 120])
160
+ #expect(player.state != .loading)
161
+ }
162
+
77
163
  @Test func theLiveEdgeIsTheSeekableWindowsEnd_orAReconnectWithoutOne() throws {
78
164
  let (player, engine, _) = try makePlaying(live: true)
79
165
  engine.liveEdge = 120
@@ -185,6 +271,23 @@ struct PlayerRecoveringTests {
185
271
  #expect(engine.resolveAndLoadCalls.count == 1)
186
272
  }
187
273
 
274
+ @Test func theNetworkReturningDuringABackoffLeavesTheReloadToTheRetry() async throws {
275
+ let engine = MockPlayerEngine()
276
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
277
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")])
278
+ player.play()
279
+ player.transition(.avPlayerWaiting)
280
+ engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
281
+ let retrying = player.retry.pendingTask
282
+ let loadsBefore = engine.resolveAndLoadCalls.count
283
+
284
+ player.networkStatusDidChange(isOnline: true)
285
+ await retrying?.value
286
+
287
+ #expect(player.state == .loading)
288
+ #expect(engine.resolveAndLoadCalls.count == loadsBefore + 1)
289
+ }
290
+
188
291
  @Test func theNetworkGoingReRendersTheStallLineWithoutReconnecting() throws {
189
292
  let (player, engine, _) = try makePlaying()
190
293
  player.transition(.avPlayerWaiting)
@@ -198,6 +198,132 @@ struct RetryingErrorTests {
198
198
  #expect(cb.playbackChanges.last?.error?.retrying == nil)
199
199
  #expect(cb.errorEvents.count == 1)
200
200
  }
201
+
202
+ /// The listener chose to pause, so the retry the pause stops is no failure; the next play
203
+ /// reloads where it failed, since the item it would have replaced is dead.
204
+ @Test @MainActor
205
+ func pauseDuringRetry_staysQuietAndReloadsOnPlay() async throws {
206
+ let (c, eh, cb) = try makePlayingWithRetries()
207
+ eh.resumePosition = 42
208
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
209
+ let retrying = c.retry.pendingTask
210
+
211
+ c.pause()
212
+ await retrying?.value
213
+
214
+ #expect(c.state != .error)
215
+ #expect(cb.errorEvents.isEmpty)
216
+ #expect(eh.resolveAndLoadCalls.isEmpty)
217
+
218
+ c.play()
219
+
220
+ #expect(eh.resolveAndLoadCalls.count == 1)
221
+ #expect(c.deferredSeek.target == 42)
222
+ }
223
+
224
+ @Test @MainActor
225
+ func pauseDuringRetry_whileBuffering_reportsPausedWithoutTheRetryingError() throws {
226
+ let (c, eh, cb) = try makePlayingWithRetries()
227
+ c.transition(.avPlayerWaiting)
228
+ eh.emit(.failed(URLError(.cannotConnectToHost), httpStatusCode: nil))
229
+ #expect(cb.playbackChanges.last?.error?.retrying == true)
230
+
231
+ c.pause()
232
+
233
+ #expect(cb.playbackChanges.last?.state == .paused)
234
+ #expect(cb.playbackChanges.last?.error == nil)
235
+ }
236
+
237
+ @Test @MainActor
238
+ func pauseDuringRetry_whileLoading_reportsPausedWithoutTheRetryingError() throws {
239
+ let (c, eh, cb) = try makePlayingWithRetries()
240
+ c.reloadResolving(startFromCurrentTime: false)
241
+ eh.emit(.loadFailed(URLError(.cannotConnectToHost)))
242
+ #expect(cb.playbackChanges.last?.state == .loading)
243
+ #expect(cb.playbackChanges.last?.error?.retrying == true)
244
+
245
+ c.pause()
246
+
247
+ #expect(cb.playbackChanges.last?.state == .paused)
248
+ #expect(cb.playbackChanges.last?.error == nil)
249
+ }
250
+
251
+ @Test @MainActor
252
+ func interruptionDuringALoadRetry_reportsPaused() throws {
253
+ let (c, eh, cb) = try makePlayingWithRetries()
254
+ c.reloadResolving(startFromCurrentTime: false)
255
+ eh.hasLoadedAsset = false
256
+ eh.emit(.loadFailed(URLError(.cannotConnectToHost)))
257
+
258
+ c.handleInterruptionBegan()
259
+
260
+ #expect(cb.playbackChanges.last?.state == .paused)
261
+ }
262
+
263
+ /// The failed item can't seek, so a seek waits for the reload, as one does while loading.
264
+ @Test @MainActor
265
+ func seekAfterPauseDuringRetry_landsOnTheReload() throws {
266
+ let (c, eh, _) = try makePlayingWithRetries()
267
+ eh.resumePosition = 42
268
+ eh.currentTime = 42
269
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
270
+ c.pause()
271
+
272
+ c.seek(by: 10)
273
+ #expect(c.deferredSeek.target == 52)
274
+ c.seek(to: 100)
275
+ c.play()
276
+
277
+ #expect(eh.seekCalls.isEmpty)
278
+ #expect(c.deferredSeek.target == 100)
279
+ }
280
+
281
+ @Test @MainActor
282
+ func pauseDuringRetry_refillsTheBudgets() async throws {
283
+ let (c, _, cb) = try makePlayingWithRetries()
284
+ c.retry.updatePolicy(from: .second(RetryConfig(
285
+ maxRetries: 1, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
286
+ )))
287
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
288
+ await c.retry.pendingTask?.value
289
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
290
+
291
+ c.pause()
292
+ c.play()
293
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
294
+ await c.retry.pendingTask?.value
295
+
296
+ #expect(c.state != .error)
297
+ #expect(cb.errorEvents.isEmpty)
298
+ }
299
+
300
+ @Test @MainActor
301
+ func pauseDuringRetry_thenStop_playsFromTheStart() throws {
302
+ let (c, eh, _) = try makePlayingWithRetries()
303
+ eh.resumePosition = 42
304
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
305
+
306
+ c.pause()
307
+ c.stop()
308
+ c.play()
309
+
310
+ #expect(eh.resolveAndLoadCalls.count == 1)
311
+ #expect(c.deferredSeek.target ?? 0 == 0)
312
+ }
313
+ }
314
+
315
+ /// Playing a track whose retries follow the play intent and back off long enough to pause in.
316
+ @MainActor
317
+ private func makePlayingWithRetries() throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
318
+ let engine = MockPlayerEngine()
319
+ let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05), retries: nil)
320
+ let callbacks = MockPlayerCallbacks()
321
+ player.callbacks = callbacks
322
+ try startPlaying(player, engine)
323
+ // The engine's position counts only once an item is prepared.
324
+ engine.emit(.itemPrepared(likelyToKeepUp: false))
325
+ engine.resolveAndLoadCalls.removeAll()
326
+ return (player, engine, callbacks)
201
327
  }
202
328
 
203
329
  // MARK: - emitStateChange
@@ -1281,6 +1407,19 @@ struct SessionReleaseTests {
1281
1407
  c.handleInterruptionEnded(shouldResume: false)
1282
1408
  #expect(eh.scheduleAudioSessionReleaseCount == 1)
1283
1409
  }
1410
+
1411
+ @Test @MainActor
1412
+ func pauseDuringRetry_requestsRelease() async throws {
1413
+ let (c, eh, _) = try makePlayingWithRetries()
1414
+ c.retry.handleError(URLError(.cannotConnectToHost), context: .playback)
1415
+ let retrying = c.retry.pendingTask
1416
+ eh.scheduleAudioSessionReleaseCount = 0
1417
+
1418
+ c.pause()
1419
+ await retrying?.value
1420
+
1421
+ #expect(eh.scheduleAudioSessionReleaseCount == 1)
1422
+ }
1284
1423
  }
1285
1424
 
1286
1425
  // MARK: - Media-stack effects of a publish
@@ -143,13 +143,13 @@ final class MockPlayerEngine: PlayerEngine {
143
143
  }
144
144
  }
145
145
 
146
- /// A Player whose retries reload while `retries` and otherwise give up, persisting to a
147
- /// test-only defaults suite.
146
+ /// A Player whose retries reload while `retries` and otherwise give up, or follow the play intent
147
+ /// when `retries` is nil, persisting to a test-only defaults suite.
148
148
  @MainActor
149
149
  func makePlayer(
150
150
  engine: MockPlayerEngine = MockPlayerEngine(),
151
151
  retry: RetryLoop = makeRetryLoop(),
152
- retries: Bool = true,
152
+ retries: Bool? = true,
153
153
  sleepTimerScheduler: any SleepTimerScheduling = ManualSleepTimerScheduler(),
154
154
  saveInterval: Duration = .seconds(5),
155
155
  ) -> Player {
@@ -158,7 +158,7 @@ func makePlayer(
158
158
  persistenceDefaults: UserDefaults(suiteName: "PlayerTests")!, persistenceSaveInterval: saveInterval,
159
159
  )
160
160
  // Player's init installs its own `shouldRetry`; replace it afterwards.
161
- retry.shouldRetry = { retries }
161
+ if let retries { retry.shouldRetry = { retries } }
162
162
  return player
163
163
  }
164
164
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "react-native-audio-browser",
3
- "version": "0.2.0-next.60",
3
+ "version": "0.2.0-next.62",
4
4
  "description": "react-native-audio-browser is a react native package built with Nitro",
5
5
  "keywords": [
6
6
  "react-native",