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

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 (40) hide show
  1. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +19 -26
  2. package/android/src/main/java/com/audiobrowser/Service.kt +15 -30
  3. package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt +16 -8
  4. package/android/src/main/java/com/audiobrowser/browser/TrackLoadHandler.kt +5 -3
  5. package/android/src/main/java/com/audiobrowser/http/RequestConfigBuilder.kt +10 -2
  6. package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +21 -1
  7. package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +0 -3
  8. package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +3 -0
  9. package/android/src/main/java/com/audiobrowser/player/PlaybackStateMachine.kt +15 -1
  10. package/android/src/main/java/com/audiobrowser/player/Player.kt +43 -33
  11. package/android/src/main/java/com/audiobrowser/player/PlayerEngineFactory.kt +0 -2
  12. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +38 -15
  13. package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +0 -7
  14. package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
  15. package/android/src/test/java/com/audiobrowser/GateDecisionTest.kt +128 -0
  16. package/android/src/test/java/com/audiobrowser/ResolveFormattedErrorTest.kt +93 -0
  17. package/android/src/test/java/com/audiobrowser/ServiceTaskRemovedTest.kt +35 -0
  18. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt +75 -5
  19. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt +42 -0
  20. package/android/src/test/java/com/audiobrowser/browser/TrackLoadHandlerTest.kt +43 -0
  21. package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt +62 -0
  22. package/android/src/test/java/com/audiobrowser/player/BrowseTilesTest.kt +31 -32
  23. package/android/src/test/java/com/audiobrowser/player/MediaFactoryTest.kt +1 -8
  24. package/android/src/test/java/com/audiobrowser/player/NowPlayingFormatterTest.kt +75 -0
  25. package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt +25 -0
  26. package/android/src/test/java/com/audiobrowser/player/PlayFromSearchTest.kt +108 -0
  27. package/android/src/test/java/com/audiobrowser/player/PlaybackStateMachineTest.kt +41 -3
  28. package/android/src/test/java/com/audiobrowser/player/PlayerRetryTest.kt +126 -1
  29. package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +0 -1
  30. package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +105 -0
  31. package/android/src/test/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicyTest.kt +0 -7
  32. package/android/src/test/java/com/audiobrowser/util/AwaitCancellableTest.kt +136 -0
  33. package/android/src/test/java/com/audiobrowser/util/JsPromise.kt +44 -0
  34. package/ios/AVPlayerEngine.swift +2 -1
  35. package/ios/HybridAudioBrowser+Player.swift +14 -4
  36. package/ios/Player/Player.swift +15 -10
  37. package/ios/Player/PlayerEngine.swift +1 -1
  38. package/ios/Tests/PlayerPolicyTests.swift +71 -0
  39. package/ios/Tests/Support/TestTypes.swift +6 -1
  40. package/package.json +2 -1
@@ -1,19 +1,26 @@
1
1
  package com.audiobrowser.player
2
2
 
3
+ import android.os.Handler
4
+ import android.os.Looper
5
+ import androidx.media3.common.Metadata
3
6
  import androidx.media3.common.Player as MediaPlayer
7
+ import androidx.media3.extractor.metadata.icy.IcyInfo
4
8
  import com.audiobrowser.Callbacks
5
9
  import com.audiobrowser.TestFixtures
6
10
  import com.audiobrowser.model.PlayerSetupOptions
7
11
  import com.audiobrowser.util.TrackFactory
8
12
  import com.margelo.nitro.audiobrowser.TimedMetadata
13
+ import kotlin.concurrent.thread
9
14
  import org.junit.After
10
15
  import org.junit.Assert.assertEquals
16
+ import org.junit.Assert.assertNull
11
17
  import org.junit.Test
12
18
  import org.junit.runner.RunWith
13
19
  import org.mockito.Answers
14
20
  import org.mockito.Mockito.mock
15
21
  import org.robolectric.RobolectricTestRunner
16
22
  import org.robolectric.RuntimeEnvironment
23
+ import org.robolectric.Shadows.shadowOf
17
24
 
18
25
  @RunWith(RobolectricTestRunner::class)
19
26
  class PlayerTrackChangeTest {
@@ -43,4 +50,102 @@ class PlayerTrackChangeTest {
43
50
 
44
51
  assertEquals(listOf<TimedMetadata?>(null), seenAtTrackChange)
45
52
  }
53
+
54
+ private fun icy(title: String) =
55
+ Metadata(IcyInfo("StreamTitle='$title';".toByteArray(), title, null))
56
+
57
+ private fun idle() {
58
+ shadowOf(player.exoPlayer.playbackLooper).idle()
59
+ shadowOf(Looper.getMainLooper()).idle()
60
+ }
61
+
62
+ private fun skip() = player.sessionPlayer.seekTo(1, 0)
63
+
64
+ private fun playTwoTracks() {
65
+ player.setup(PlayerSetupOptions())
66
+ player.sessionPlayer.setMediaItems(
67
+ listOf(
68
+ TrackFactory.toMedia3(TestFixtures.track(title = "A", src = "https://s/a.mp3")),
69
+ TrackFactory.toMedia3(TestFixtures.track(title = "B", src = "https://s/b.mp3")),
70
+ )
71
+ )
72
+ idle()
73
+ player.playerListener.onMetadata(icy("A song 1"))
74
+ }
75
+
76
+ /** Delivers an outgoing item's title the way MetadataRenderer does, posted before [switch]. */
77
+ private fun assertOutgoingTitleDropped(switch: () -> Unit) {
78
+ playTwoTracks()
79
+ val playbackLooper = shadowOf(player.exoPlayer.playbackLooper)
80
+ playbackLooper.pause()
81
+ Handler(player.exoPlayer.playbackLooper).post {
82
+ Handler(Looper.getMainLooper()).post { player.playerListener.onMetadata(icy("A song 2")) }
83
+ }
84
+ switch()
85
+ playbackLooper.unPause()
86
+ idle()
87
+
88
+ assertNull(player.nowPlaying.timedMetadata)
89
+ }
90
+
91
+ @Test
92
+ fun `a title the outgoing item had already posted does not survive a skip`() =
93
+ assertOutgoingTitleDropped(::skip)
94
+
95
+ @Test
96
+ fun `a title the outgoing item had already posted does not survive a new queue`() =
97
+ assertOutgoingTitleDropped {
98
+ player.sessionPlayer.setMediaItems(
99
+ listOf(TrackFactory.toMedia3(TestFixtures.track(title = "C", src = "https://s/c.mp3")))
100
+ )
101
+ }
102
+
103
+ @Test
104
+ fun `the next item's first title is kept when the queue advances on its own`() {
105
+ playTwoTracks()
106
+ player.playerListener.onMediaItemTransition(
107
+ player.sessionPlayer.currentMediaItem,
108
+ MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_AUTO,
109
+ )
110
+ player.playerListener.onMetadata(icy("B song 1"))
111
+
112
+ assertEquals("B song 1", player.nowPlaying.timedMetadata?.title)
113
+ }
114
+
115
+ @Test
116
+ fun `the new item's first title is kept once the playback thread has caught up`() {
117
+ playTwoTracks()
118
+ skip()
119
+ idle()
120
+ player.playerListener.onMetadata(icy("B song 1"))
121
+
122
+ assertEquals("B song 1", player.nowPlaying.timedMetadata?.title)
123
+ }
124
+
125
+ @Test
126
+ fun `titles are kept after the engine is rebuilt during a track change`() {
127
+ playTwoTracks()
128
+ // Holds the old engine's playback thread until setup() waits on its release, so the thread
129
+ // handles the fence with the release queued behind it.
130
+ val oldPlaybackLooper = shadowOf(player.exoPlayer.playbackLooper)
131
+ oldPlaybackLooper.pause()
132
+ val testThread = Thread.currentThread()
133
+ val releaser =
134
+ thread(isDaemon = true) {
135
+ val deadline = System.currentTimeMillis() + 10_000
136
+ while (
137
+ testThread.state != Thread.State.TIMED_WAITING && System.currentTimeMillis() < deadline
138
+ ) {
139
+ Thread.sleep(1)
140
+ }
141
+ oldPlaybackLooper.unPause()
142
+ }
143
+ skip()
144
+ player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
145
+ releaser.join()
146
+ idle()
147
+ player.playerListener.onMetadata(icy("B song 1"))
148
+
149
+ assertEquals("B song 1", player.nowPlaying.timedMetadata?.title)
150
+ }
46
151
  }
@@ -83,13 +83,6 @@ class RetryLoadErrorHandlingPolicyTest {
83
83
  assertTrue(retryPending)
84
84
  }
85
85
 
86
- @Test
87
- fun `retry is skipped when shouldRetry is false`() {
88
- val policy = RetryLoadErrorHandlingPolicy(shouldRetry = { false })
89
- val delay = policy.getRetryDelayMsFor(errorInfo(UnknownHostException("offline")))
90
- assertEquals(C.TIME_UNSET, delay)
91
- }
92
-
93
86
  @Test
94
87
  fun `retry stops once max retries is exceeded`() {
95
88
  val policy = RetryLoadErrorHandlingPolicy(maxRetries = 3)
@@ -0,0 +1,136 @@
1
+ package com.audiobrowser.util
2
+
3
+ import java.util.concurrent.TimeoutException
4
+ import kotlin.time.Duration.Companion.seconds
5
+ import kotlinx.coroutines.CancellationException
6
+ import kotlinx.coroutines.ExperimentalCoroutinesApi
7
+ import kotlinx.coroutines.async
8
+ import kotlinx.coroutines.test.advanceTimeBy
9
+ import kotlinx.coroutines.test.runCurrent
10
+ import kotlinx.coroutines.test.runTest
11
+ import kotlinx.coroutines.withTimeoutOrNull
12
+ import org.junit.Assert.assertEquals
13
+ import org.junit.Assert.assertFalse
14
+ import org.junit.Assert.assertTrue
15
+ import org.junit.Test
16
+
17
+ @OptIn(ExperimentalCoroutinesApi::class)
18
+ class AwaitCancellableTest {
19
+
20
+ @Test
21
+ fun `an answer resumes the await with its value`() =
22
+ runTest(timeout = 5.seconds) {
23
+ val js = JsPromise<String>()
24
+ val result = backgroundScope.async { js.promise.awaitCancellable() }
25
+ runCurrent()
26
+
27
+ js.resolve("answer")
28
+ runCurrent()
29
+
30
+ assertTrue(result.isCompleted)
31
+ assertEquals("answer", result.await())
32
+ }
33
+
34
+ @Test
35
+ fun `a rejection resumes the await with its error`() =
36
+ runTest(timeout = 5.seconds) {
37
+ val js = JsPromise<String>()
38
+ val result = backgroundScope.async { runCatching { js.promise.awaitCancellable() } }
39
+ runCurrent()
40
+
41
+ js.reject(IllegalStateException("rejected"))
42
+ runCurrent()
43
+
44
+ assertTrue(result.isCompleted)
45
+ assertEquals("rejected", result.await().exceptionOrNull()?.message)
46
+ }
47
+
48
+ @Test
49
+ fun `a cancelled caller stops waiting and ignores a later answer`() =
50
+ runTest(timeout = 5.seconds) {
51
+ val js = JsPromise<String>()
52
+ var after = false
53
+ val caller =
54
+ backgroundScope.async {
55
+ js.promise.awaitCancellable()
56
+ after = true
57
+ }
58
+ runCurrent()
59
+
60
+ caller.cancel()
61
+ runCurrent()
62
+ assertTrue(caller.isCompleted)
63
+ js.resolve("late")
64
+ runCurrent()
65
+
66
+ assertFalse(after)
67
+ }
68
+
69
+ @Test
70
+ fun `a promise that never settles fails at its timeout`() =
71
+ runTest(timeout = 5.seconds) {
72
+ val js = JsPromise<String>()
73
+ val result = backgroundScope.async { runCatching { js.promise.awaitOrTimeout() } }
74
+
75
+ advanceTimeBy(FALLBACK_TIMEOUT - 1.seconds)
76
+ runCurrent()
77
+ assertFalse(result.isCompleted)
78
+ advanceTimeBy(2.seconds)
79
+ runCurrent()
80
+
81
+ assertTrue(result.isCompleted)
82
+ val error = result.await().exceptionOrNull()
83
+ assertTrue(error is TimeoutException)
84
+ assertFalse(error is CancellationException)
85
+ }
86
+
87
+ @Test
88
+ fun `a nested promise's timeout covers both layers`() =
89
+ runTest(timeout = 5.seconds) {
90
+ val outer = JsPromise<com.margelo.nitro.core.Promise<String>>()
91
+ val inner = JsPromise<String>()
92
+ val result = backgroundScope.async { runCatching { outer.promise.awaitNestedOrTimeout() } }
93
+ runCurrent()
94
+
95
+ advanceTimeBy(FALLBACK_TIMEOUT / 2)
96
+ outer.resolve(inner.promise)
97
+ advanceTimeBy(FALLBACK_TIMEOUT / 2 + 1.seconds)
98
+ runCurrent()
99
+
100
+ assertTrue(result.isCompleted)
101
+ assertTrue(result.await().exceptionOrNull() is TimeoutException)
102
+ }
103
+
104
+ @Test
105
+ fun `a nested promise answers with the inner value`() =
106
+ runTest(timeout = 5.seconds) {
107
+ val outer = JsPromise<com.margelo.nitro.core.Promise<String>>()
108
+ val inner = JsPromise<String>()
109
+ val result = backgroundScope.async { outer.promise.awaitNestedOrTimeout() }
110
+ runCurrent()
111
+
112
+ outer.resolve(inner.promise)
113
+ runCurrent()
114
+ inner.resolve("answer")
115
+ runCurrent()
116
+
117
+ assertTrue(result.isCompleted)
118
+ assertEquals("answer", result.await())
119
+ }
120
+
121
+ @Test
122
+ fun `an outer timeout keeps its cancellation`() =
123
+ runTest(timeout = 5.seconds) {
124
+ val js = JsPromise<String>()
125
+ val result =
126
+ backgroundScope.async {
127
+ runCatching { withTimeoutOrNull(FALLBACK_TIMEOUT / 2) { js.promise.awaitOrTimeout() } }
128
+ }
129
+
130
+ advanceTimeBy(FALLBACK_TIMEOUT / 2 + 1.seconds)
131
+ runCurrent()
132
+
133
+ assertTrue(result.isCompleted)
134
+ assertEquals(Result.success(null), result.await())
135
+ }
136
+ }
@@ -0,0 +1,44 @@
1
+ package com.audiobrowser.util
2
+
3
+ import com.margelo.nitro.core.Promise
4
+ import org.mockito.ArgumentMatchers.any
5
+ import org.mockito.Mockito.doAnswer
6
+ import org.mockito.Mockito.mock
7
+
8
+ /**
9
+ * A Nitro [Promise] needs JNI, so this one is a mock the test settles; settled before anyone
10
+ * listens, it answers each listener as it registers, as Nitro's does.
11
+ */
12
+ class JsPromise<T> {
13
+ @Suppress("UNCHECKED_CAST") val promise = mock(Promise::class.java) as Promise<T>
14
+ private var result: Result<T>? = null
15
+ private val onResolved = mutableListOf<(T) -> Unit>()
16
+ private val onRejected = mutableListOf<(Throwable) -> Unit>()
17
+
18
+ init {
19
+ doAnswer {
20
+ @Suppress("UNCHECKED_CAST") val listener = it.arguments[0] as (T) -> Unit
21
+ result?.onSuccess(listener) ?: onResolved.add(listener)
22
+ promise
23
+ }
24
+ .`when`(promise)
25
+ .then(any() ?: {})
26
+ doAnswer {
27
+ @Suppress("UNCHECKED_CAST") val listener = it.arguments[0] as (Throwable) -> Unit
28
+ result?.onFailure(listener) ?: onRejected.add(listener)
29
+ promise
30
+ }
31
+ .`when`(promise)
32
+ .catch(any() ?: {})
33
+ }
34
+
35
+ fun resolve(value: T) {
36
+ result = Result.success(value)
37
+ onResolved.forEach { it(value) }
38
+ }
39
+
40
+ fun reject(error: Throwable) {
41
+ result = Result.failure(error)
42
+ onRejected.forEach { it(error) }
43
+ }
44
+ }
@@ -112,7 +112,8 @@ final class AVPlayerEngine: PlayerEngine {
112
112
 
113
113
  var resumePosition: Double? {
114
114
  guard let item = avPlayer.currentItem, !item.duration.isIndefinite else { return nil }
115
- return item.currentTime().seconds
115
+ let seconds = item.currentTime().seconds
116
+ return seconds.isFinite ? seconds : nil
116
117
  }
117
118
 
118
119
  var liveEdge: Double? {
@@ -49,13 +49,23 @@ public extension HybridAudioBrowser {
49
49
  }
50
50
 
51
51
  func seekTo(position: Double) throws {
52
+ guard let position = finite(position, "seekTo") else { return }
52
53
  onMainActor { player?.seek(to: position) }
53
54
  }
54
55
 
55
56
  func seekBy(offset: Double) throws {
57
+ guard let offset = finite(offset, "seekBy") else { return }
56
58
  onMainActor { player?.seek(by: offset) }
57
59
  }
58
60
 
61
+ private func finite(_ seconds: Double, _ method: String) -> Double? {
62
+ guard seconds.isFinite else {
63
+ logger.error("\(method, privacy: .public) ignored a non-finite time: \(seconds)")
64
+ return nil
65
+ }
66
+ return seconds
67
+ }
68
+
59
69
  func seekToLiveEdge() throws {
60
70
  onMainActor { player?.seekToLiveEdge() }
61
71
  }
@@ -187,7 +197,7 @@ public extension HybridAudioBrowser {
187
197
  func skip(index: Double, initialPosition: Double?) throws {
188
198
  try onMainActor {
189
199
  try player?.skipTo(Int(index))
190
- if let position = initialPosition {
200
+ if let position = initialPosition.flatMap({ finite($0, "skip") }) {
191
201
  player?.seek(to: position)
192
202
  }
193
203
  }
@@ -196,7 +206,7 @@ public extension HybridAudioBrowser {
196
206
  func skipToNext(initialPosition: Double?) throws {
197
207
  onMainActor {
198
208
  player?.next()
199
- if let position = initialPosition {
209
+ if let position = initialPosition.flatMap({ finite($0, "skipToNext") }) {
200
210
  player?.seek(to: position)
201
211
  }
202
212
  }
@@ -205,7 +215,7 @@ public extension HybridAudioBrowser {
205
215
  func skipToPrevious(initialPosition: Double?) throws {
206
216
  onMainActor {
207
217
  player?.previous()
208
- if let position = initialPosition {
218
+ if let position = initialPosition.flatMap({ finite($0, "skipToPrevious") }) {
209
219
  player?.seek(to: position)
210
220
  }
211
221
  }
@@ -249,7 +259,7 @@ public extension HybridAudioBrowser {
249
259
  try player.setQueue(
250
260
  tracks,
251
261
  initialIndex: startIndex.map { Int($0) } ?? 0,
252
- startPositionMs: startPosition.map { $0 * 1000 },
262
+ startPositionMs: startPosition.flatMap { finite($0, "setQueue") }.map { $0 * 1000 },
253
263
  )
254
264
  }
255
265
  }
@@ -640,11 +640,11 @@ final class Player {
640
640
 
641
641
  // MARK: - Seeking
642
642
 
643
- /// Seeks the current item. While it awaits the next item, the target is held until that one is
644
- /// ready and the ready transition waits for it (`DeferredSeek`); `completion` then reports false
645
- /// at once.
643
+ /// Seeks the current item. While it awaits the next item, or in .error for the restart, the
644
+ /// target is held until the next item is ready and the ready transition waits for it
645
+ /// (`DeferredSeek`); `completion` then reports false at once.
646
646
  func seek(to seconds: TimeInterval, completion: @escaping @MainActor (Bool) -> Void = { _ in }) {
647
- if awaitingItem {
647
+ if awaitingItem || state == .error {
648
648
  deferredSeek.capture(seconds)
649
649
  completion(false)
650
650
  } else if engine.hasItem {
@@ -655,18 +655,19 @@ final class Player {
655
655
  }
656
656
 
657
657
  func seek(by offset: TimeInterval) {
658
- if awaitingItem {
659
- seek(to: (deferredSeek.target ?? 0) + offset)
658
+ if awaitingItem || state == .error {
659
+ seek(to: (resumePosition ?? 0) + offset)
660
660
  } else if engine.hasItem {
661
661
  seek(to: engine.currentTime + offset)
662
662
  }
663
663
  }
664
664
 
665
665
  /// Jumps to the live edge: the end of the seekable window when there is one; without one
666
- /// (ICY) there is nothing to seek within, so it reconnects. No-op for a track that isn't live.
666
+ /// (ICY), or in .error, whose item's window is stale, it reconnects. No-op for a track that
667
+ /// isn't live.
667
668
  func seekToLiveEdge() {
668
669
  guard currentTrack?.live == true, engine.hasItem else { return }
669
- if let edge = engine.liveEdge {
670
+ if let edge = engine.liveEdge, state != .error {
670
671
  seek(to: edge)
671
672
  } else {
672
673
  reloadResolving(startFromCurrentTime: false)
@@ -747,10 +748,14 @@ final class Player {
747
748
 
748
749
  /// Recovers from a media-services reset: every AVPlayer and session handle is invalid, so a
749
750
  /// new player reloads the current track, keeping the play intent, so a live stream reconnects
750
- /// instead of going silent. No-op when nothing is loaded.
751
+ /// instead of going silent. An on-demand track resumes where it was, unless it ended, or was
752
+ /// stopped and its rewind may not have landed. No-op when nothing is loaded.
751
753
  func mediaServicesWereReset() {
752
- guard currentTrack != nil else { return }
754
+ guard let track = currentTrack else { return }
753
755
  logger.info("Media services were reset — recreating player and reloading current track")
756
+ if track.live != true, state != .ended, state != .stopped, let position = resumePosition {
757
+ deferredSeek.capture(position)
758
+ }
754
759
  engine.clearItem()
755
760
  engine.recreate()
756
761
  reloadResolving(startFromCurrentTime: false)
@@ -42,7 +42,7 @@ enum EngineEvent {
42
42
  var currentTime: Double { get }
43
43
  var duration: Double { get }
44
44
  var bufferedPosition: Double { get }
45
- /// The position a reload resumes from: nil without an item, or for an indefinite duration.
45
+ /// The position a reload resumes from: nil without an item, for an indefinite duration, or when the item's time isn't finite.
46
46
  var resumePosition: Double? { get }
47
47
  /// The end of the seekable window; nil when there is none.
48
48
  var liveEdge: Double? { get }
@@ -183,6 +183,16 @@ struct PlayerSeekingTests {
183
183
  #expect(engine.resolveAndLoadCalls.count == 2)
184
184
  #expect(player.state == .loading)
185
185
  }
186
+
187
+ @Test func theLiveEdgeInAnErrorIsAReconnect() throws {
188
+ let (player, engine, _) = try makePlaying(live: true)
189
+ engine.liveEdge = 120
190
+ engine.emit(.failed(nil, httpStatusCode: 404))
191
+ player.seekToLiveEdge()
192
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
193
+ #expect(engine.seekCalls.isEmpty)
194
+ #expect(engine.resolveAndLoadCalls.count == 2)
195
+ }
186
196
  }
187
197
 
188
198
  @Suite("Player - engine events")
@@ -358,6 +368,35 @@ struct PlayerRecoveringTests {
358
368
  #expect(player.playWhenReady)
359
369
  }
360
370
 
371
+ @Test func aMediaServicesResetResumesAnOnDemandTrack_notALiveOne() throws {
372
+ let (player, engine, _) = try makePlaying()
373
+ engine.resumePosition = 120
374
+ player.mediaServicesWereReset()
375
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
376
+ #expect(engine.seekCalls == [120])
377
+
378
+ let (live, liveEngine, _) = try makePlaying(live: true)
379
+ liveEngine.resumePosition = 120
380
+ live.mediaServicesWereReset()
381
+ liveEngine.emit(.itemPrepared(likelyToKeepUp: true))
382
+ #expect(liveEngine.seekCalls.isEmpty)
383
+ }
384
+
385
+ @Test func aMediaServicesResetAfterTheEndOrAStopStartsOver() throws {
386
+ let (ended, endedEngine, _) = try makePlaying()
387
+ endedEngine.resumePosition = 300
388
+ ended.transition(.trackEndedNaturally)
389
+ ended.mediaServicesWereReset()
390
+ #expect(ended.deferredSeek.target == nil)
391
+
392
+ let (stopped, stoppedEngine, _) = try makePlaying()
393
+ stopped.stop()
394
+ // The stop's rewind has not landed.
395
+ stoppedEngine.resumePosition = 120
396
+ stopped.mediaServicesWereReset()
397
+ #expect(stopped.deferredSeek.target == nil)
398
+ }
399
+
361
400
  @Test func aStopRewindsAFiniteTrack_notALiveOne() throws {
362
401
  let (player, engine, _) = try makePlaying()
363
402
  player.stop()
@@ -413,6 +452,38 @@ struct PlayerReviewRegressionTests {
413
452
  #expect(engine.seekCalls == [25, 25])
414
453
  }
415
454
 
455
+ @Test func aSeekInAnErrorDuringTheStartSeekReplacesTheStart() throws {
456
+ let engine = MockPlayerEngine()
457
+ let player = makePlayer(engine: engine, retries: false)
458
+ try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
459
+ engine.seekResult = nil
460
+ engine.hasItem = true
461
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
462
+ engine.emit(.failed(nil, httpStatusCode: 404))
463
+ #expect(player.state == .error)
464
+
465
+ player.seek(to: 40)
466
+ player.seek(by: 5)
467
+ engine.completeSeeks(false)
468
+ player.play()
469
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
470
+
471
+ #expect(engine.seekCalls == [25, 45])
472
+ }
473
+
474
+ @Test func aSeekInAnErrorIsWhereThePlayResumes() throws {
475
+ let (player, engine, _) = try makePlaying()
476
+ engine.resumePosition = 120
477
+ engine.emit(.failed(nil, httpStatusCode: 404))
478
+ #expect(player.state == .error)
479
+
480
+ player.seek(by: -80)
481
+ player.play()
482
+ engine.emit(.itemPrepared(likelyToKeepUp: true))
483
+
484
+ #expect(engine.seekCalls == [40])
485
+ }
486
+
416
487
  @Test func endingWithTheIntentAlreadyOffSavesPositionZero() throws {
417
488
  UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
418
489
  let (player, engine, _) = try makePlaying()
@@ -55,7 +55,12 @@ final class MockPlayerEngine: PlayerEngine {
55
55
  func resolveAndLoad(src: String, track _: Track) { resolveAndLoadCalls.append(src) }
56
56
  func cancelLoading() { cancelLoadingCount += 1 }
57
57
  func dropAsset() { dropAssetCount += 1 }
58
- func clearItem() { clearItemCount += 1 }
58
+ func clearItem() {
59
+ clearItemCount += 1
60
+ hasItem = false
61
+ resumePosition = nil
62
+ }
63
+
59
64
  func stopObservingItem() { stopObservingItemCount += 1 }
60
65
  func recreate() { recreateCount += 1 }
61
66
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "react-native-audio-browser",
3
- "version": "0.2.0-next.74",
3
+ "version": "0.2.0-next.76",
4
4
  "description": "react-native-audio-browser is a react native package built with Nitro",
5
5
  "keywords": [
6
6
  "react-native",
@@ -70,6 +70,7 @@
70
70
  "ios:test": "swift test --disable-sandbox",
71
71
  "lint": "oxlint --fix",
72
72
  "release": "semantic-release",
73
+ "stream-server": "node scripts/stream-server/index.ts",
73
74
  "test": "vitest run",
74
75
  "types": "tsc --noEmit",
75
76
  "vocab-check": "node scripts/vocab-check.ts"