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.
- package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +19 -26
- package/android/src/main/java/com/audiobrowser/Service.kt +15 -30
- package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt +16 -8
- package/android/src/main/java/com/audiobrowser/browser/TrackLoadHandler.kt +5 -3
- package/android/src/main/java/com/audiobrowser/http/RequestConfigBuilder.kt +10 -2
- package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +21 -1
- package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +0 -3
- package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +3 -0
- package/android/src/main/java/com/audiobrowser/player/PlaybackStateMachine.kt +15 -1
- package/android/src/main/java/com/audiobrowser/player/Player.kt +43 -33
- package/android/src/main/java/com/audiobrowser/player/PlayerEngineFactory.kt +0 -2
- package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +38 -15
- package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +0 -7
- package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
- package/android/src/test/java/com/audiobrowser/GateDecisionTest.kt +128 -0
- package/android/src/test/java/com/audiobrowser/ResolveFormattedErrorTest.kt +93 -0
- package/android/src/test/java/com/audiobrowser/ServiceTaskRemovedTest.kt +35 -0
- package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt +75 -5
- package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt +42 -0
- package/android/src/test/java/com/audiobrowser/browser/TrackLoadHandlerTest.kt +43 -0
- package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt +62 -0
- package/android/src/test/java/com/audiobrowser/player/BrowseTilesTest.kt +31 -32
- package/android/src/test/java/com/audiobrowser/player/MediaFactoryTest.kt +1 -8
- package/android/src/test/java/com/audiobrowser/player/NowPlayingFormatterTest.kt +75 -0
- package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt +25 -0
- package/android/src/test/java/com/audiobrowser/player/PlayFromSearchTest.kt +108 -0
- package/android/src/test/java/com/audiobrowser/player/PlaybackStateMachineTest.kt +41 -3
- package/android/src/test/java/com/audiobrowser/player/PlayerRetryTest.kt +126 -1
- package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +0 -1
- package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +105 -0
- package/android/src/test/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicyTest.kt +0 -7
- package/android/src/test/java/com/audiobrowser/util/AwaitCancellableTest.kt +136 -0
- package/android/src/test/java/com/audiobrowser/util/JsPromise.kt +44 -0
- package/ios/AVPlayerEngine.swift +2 -1
- package/ios/HybridAudioBrowser+Player.swift +14 -4
- package/ios/Player/Player.swift +15 -10
- package/ios/Player/PlayerEngine.swift +1 -1
- package/ios/Tests/PlayerPolicyTests.swift +71 -0
- package/ios/Tests/Support/TestTypes.swift +6 -1
- 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
|
+
}
|
package/ios/AVPlayerEngine.swift
CHANGED
|
@@ -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
|
-
|
|
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
|
}
|
package/ios/Player/Player.swift
CHANGED
|
@@ -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,
|
|
644
|
-
/// ready and the ready transition waits for it
|
|
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: (
|
|
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)
|
|
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.
|
|
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
|
|
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,
|
|
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() {
|
|
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.
|
|
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"
|