react-native-audio-browser 0.2.0-next.75 → 0.2.0-next.77
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 +20 -27
- package/android/src/main/java/com/audiobrowser/Service.kt +3 -0
- 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/EnginePlayback.kt +9 -5
- package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +71 -39
- package/android/src/main/java/com/audiobrowser/player/LiveStreamExtractor.kt +65 -0
- package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +12 -3
- package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +8 -0
- package/android/src/main/java/com/audiobrowser/player/Player.kt +85 -37
- package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +38 -11
- package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +1 -1
- package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +21 -0
- package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
- package/android/src/test/java/androidx/media3/session/SessionViews.kt +10 -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/LiveStreamEndTest.kt +372 -0
- 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/PlayerSetupEndedTest.kt +221 -0
- package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +17 -7
- package/android/src/test/java/com/audiobrowser/player/PlayerSuppressionTest.kt +183 -7
- package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +153 -0
- package/android/src/test/java/com/audiobrowser/player/SessionPlayTest.kt +236 -0
- package/android/src/test/java/com/audiobrowser/player/SessionViewRulesTest.kt +62 -0
- package/android/src/test/java/com/audiobrowser/player/SessionViewTest.kt +188 -0
- package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +11 -0
- package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +58 -0
- 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 +5 -1
- package/ios/Browser/BrowserManager.swift +2 -2
- package/ios/Browser/PageResolver.swift +14 -19
- package/ios/Browser/RequestPipeline.swift +6 -4
- package/ios/CarPlay/CarPlayNowPlayingManager.swift +1 -1
- package/ios/CarPlay/CarPlaySession+PageLoader.swift +1 -0
- package/ios/CarPlay/CarPlaySession+TabBar.swift +2 -0
- package/ios/Extension/Promise+AwaitCallback.swift +33 -0
- package/ios/HybridAudioBrowser+Player.swift +1 -1
- package/ios/HybridAudioBrowser.swift +1 -1
- package/ios/Player/MediaLoader.swift +1 -1
- package/ios/Player/PlaybackFailure.swift +3 -3
- package/ios/Player/Player.swift +67 -49
- package/ios/Player/PlayerEngine.swift +2 -0
- package/ios/Player/RetryLoop.swift +72 -12
- package/ios/Tests/AwaitCallbackTests.swift +210 -0
- package/ios/Tests/GenerationMemoTests.swift +57 -0
- package/ios/Tests/PlaybackFailureTests.swift +7 -0
- package/ios/Tests/PlayerPolicyTests.swift +346 -6
- package/ios/Tests/PlayerTests.swift +79 -1
- package/ios/Tests/RetryLoopTests.swift +30 -5
- package/ios/Tests/Support/TestTypes.swift +15 -7
- package/ios/Tests/Support/TimeLimit.swift +43 -0
- package/ios/Util/AwaitCallback.swift +80 -0
- package/ios/Util/GenerationMemo.swift +11 -4
- package/package.json +2 -1
- package/android/src/test/java/com/audiobrowser/player/SessionErrorMaskTest.kt +0 -63
- package/ios/Player/EndOfTrackJudgement.swift +0 -25
- package/ios/Tests/EndOfTrackJudgementTests.swift +0 -30
|
@@ -0,0 +1,372 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import android.os.Looper
|
|
4
|
+
import androidx.media3.common.C
|
|
5
|
+
import androidx.media3.common.ParserException
|
|
6
|
+
import androidx.media3.decoder.DecoderInputBuffer
|
|
7
|
+
import androidx.media3.exoplayer.FormatHolder
|
|
8
|
+
import androidx.media3.exoplayer.LoadingInfo
|
|
9
|
+
import androidx.media3.exoplayer.analytics.PlayerId
|
|
10
|
+
import androidx.media3.exoplayer.source.MediaPeriod
|
|
11
|
+
import androidx.media3.exoplayer.source.MediaSource
|
|
12
|
+
import androidx.media3.exoplayer.source.SampleStream
|
|
13
|
+
import androidx.media3.exoplayer.trackselection.ExoTrackSelection
|
|
14
|
+
import androidx.media3.exoplayer.trackselection.FixedTrackSelection
|
|
15
|
+
import androidx.media3.exoplayer.upstream.DefaultAllocator
|
|
16
|
+
import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter
|
|
17
|
+
import com.audiobrowser.TestFixtures.track
|
|
18
|
+
import com.audiobrowser.model.RetryPolicy
|
|
19
|
+
import com.audiobrowser.util.TrackFactory
|
|
20
|
+
import java.io.IOException
|
|
21
|
+
import java.net.ServerSocket
|
|
22
|
+
import java.nio.ByteBuffer
|
|
23
|
+
import java.nio.ByteOrder
|
|
24
|
+
import java.time.Duration
|
|
25
|
+
import java.util.concurrent.atomic.AtomicInteger
|
|
26
|
+
import kotlin.concurrent.thread
|
|
27
|
+
import org.junit.After
|
|
28
|
+
import org.junit.Assert.assertEquals
|
|
29
|
+
import org.junit.Assert.assertNotNull
|
|
30
|
+
import org.junit.Assert.assertNull
|
|
31
|
+
import org.junit.Assert.assertTrue
|
|
32
|
+
import org.junit.Assert.fail
|
|
33
|
+
import org.junit.Test
|
|
34
|
+
import org.junit.runner.RunWith
|
|
35
|
+
import org.robolectric.RobolectricTestRunner
|
|
36
|
+
import org.robolectric.RuntimeEnvironment
|
|
37
|
+
import org.robolectric.Shadows.shadowOf
|
|
38
|
+
import org.robolectric.shadows.ShadowSystemClock
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* A progressive stream that the server ends cleanly, served without a length, loaded through
|
|
42
|
+
* [MediaFactory] by media3's own media period. The test reads the samples as a renderer would and
|
|
43
|
+
* advances the clock by the audio it reads, since Robolectric plays no audio.
|
|
44
|
+
*/
|
|
45
|
+
@RunWith(RobolectricTestRunner::class)
|
|
46
|
+
class LiveStreamEndTest {
|
|
47
|
+
|
|
48
|
+
private val context = RuntimeEnvironment.getApplication()
|
|
49
|
+
private var server = ServerSocket(0)
|
|
50
|
+
private val requests = AtomicInteger()
|
|
51
|
+
private val played = AtomicInteger()
|
|
52
|
+
|
|
53
|
+
@After
|
|
54
|
+
fun shutdown() {
|
|
55
|
+
server.close()
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
@Test
|
|
59
|
+
fun `a live stream that closes before it has played reconnects`() {
|
|
60
|
+
serve(framesFor = { request -> if (request == 1) SECONDS_1_5 else SECONDS_60 })
|
|
61
|
+
|
|
62
|
+
val outcome =
|
|
63
|
+
play(
|
|
64
|
+
live = true,
|
|
65
|
+
RetryPolicy.Infinite(),
|
|
66
|
+
stopAfterFrames = SECONDS_1_5 * 3,
|
|
67
|
+
hasPlayed = false,
|
|
68
|
+
)
|
|
69
|
+
|
|
70
|
+
assertNull(outcome.error)
|
|
71
|
+
assertEquals(2, requests.get())
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
@Test
|
|
75
|
+
fun `a live stream that closes once reconnects once and plays on`() {
|
|
76
|
+
serve(framesFor = { request -> if (request == 1) SECONDS_1_5 else SECONDS_60 })
|
|
77
|
+
|
|
78
|
+
val outcome = play(live = true, RetryPolicy.Infinite(), stopAfterFrames = SECONDS_1_5 * 3)
|
|
79
|
+
|
|
80
|
+
assertNull(outcome.error)
|
|
81
|
+
assertTrue("the stream played on", !outcome.ended)
|
|
82
|
+
assertEquals(2, requests.get())
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
@Test
|
|
86
|
+
fun `a live stream that closes after every second and a half ends in an error`() {
|
|
87
|
+
serve(framesFor = { SECONDS_1_5 })
|
|
88
|
+
|
|
89
|
+
val outcome = play(live = true, RetryPolicy.Infinite())
|
|
90
|
+
|
|
91
|
+
assertNotNull("the retries never ran out", outcome.error)
|
|
92
|
+
// The 120 s recovery budget starts at the first close, at 1.49 s: closes come every 1.49 s,
|
|
93
|
+
// and the first at or past 120 s after it, the 82nd, is not retried.
|
|
94
|
+
assertEquals(82, requests.get())
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
@Test
|
|
98
|
+
fun `an on-demand file served without a length ends where the server ends it`() {
|
|
99
|
+
serve(framesFor = { SECONDS_1_5 })
|
|
100
|
+
|
|
101
|
+
val outcome = play(live = false, RetryPolicy.Infinite())
|
|
102
|
+
|
|
103
|
+
assertNull(outcome.error)
|
|
104
|
+
assertTrue("the file ended", outcome.ended)
|
|
105
|
+
assertEquals(1, requests.get())
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
@Test
|
|
109
|
+
fun `a live stream served with a length ends where its length ends`() {
|
|
110
|
+
// ADTS, not MP3: the MP3 extractor stops at the end of a known length before the source ends.
|
|
111
|
+
serve(
|
|
112
|
+
framesFor = { SECONDS_1_5 },
|
|
113
|
+
contentType = "audio/aac",
|
|
114
|
+
withLength = true,
|
|
115
|
+
body = ::silentAdts,
|
|
116
|
+
)
|
|
117
|
+
|
|
118
|
+
val outcome = play(live = true, RetryPolicy.Infinite())
|
|
119
|
+
|
|
120
|
+
assertNull(outcome.error)
|
|
121
|
+
assertTrue("the stream ended", outcome.ended)
|
|
122
|
+
assertEquals(1, requests.get())
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
@Test
|
|
126
|
+
fun `a live stream whose container declares its end ends there`() {
|
|
127
|
+
serve(framesFor = { 0 }, contentType = "audio/wav", body = { silentWav() })
|
|
128
|
+
|
|
129
|
+
val outcome = play(live = true, RetryPolicy.Infinite())
|
|
130
|
+
|
|
131
|
+
assertNull(outcome.error)
|
|
132
|
+
assertTrue("the stream ended", outcome.ended)
|
|
133
|
+
assertEquals(1, requests.get())
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
@Test
|
|
137
|
+
fun `a live station answering with an empty body fails at once as unplayable`() =
|
|
138
|
+
assertFailsAtOnce("audio/mpeg", "")
|
|
139
|
+
|
|
140
|
+
@Test
|
|
141
|
+
fun `a live station answering with a few bytes fails at once as unplayable`() =
|
|
142
|
+
assertFailsAtOnce("audio/mpeg", "ICY 404")
|
|
143
|
+
|
|
144
|
+
@Test
|
|
145
|
+
fun `a live station answering with a playlist fails at once as unplayable`() {
|
|
146
|
+
assertFailsAtOnce("audio/x-mpegurl", "#EXTM3U\nhttp://127.0.0.1:9/live.mp3\n")
|
|
147
|
+
assertFailsAtOnce("audio/x-scpls", "[playlist]\nFile1=http://127.0.0.1:9/live.mp3\n")
|
|
148
|
+
assertFailsAtOnce("application/pls+xml", "[playlist]\nFile1=http://127.0.0.1:9/live.mp3\n")
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
@Test
|
|
152
|
+
fun `a live station answering with a page fails at once as unplayable`() {
|
|
153
|
+
assertFailsAtOnce("text/html", "<html>Stream offline</html>")
|
|
154
|
+
assertFailsAtOnce("application/octet-stream", "<html>Stream offline</html>")
|
|
155
|
+
assertFailsAtOnce(null, "<html>Stream offline</html>")
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/**
|
|
159
|
+
* A live track whose one reply, [body] as [contentType], ends in the unrecognised format error.
|
|
160
|
+
*/
|
|
161
|
+
private fun assertFailsAtOnce(contentType: String?, body: String) {
|
|
162
|
+
requests.set(0)
|
|
163
|
+
server.close()
|
|
164
|
+
server = ServerSocket(0)
|
|
165
|
+
serve(framesFor = { 0 }, contentType = contentType, body = { body.toByteArray() })
|
|
166
|
+
|
|
167
|
+
val outcome = play(live = true, RetryPolicy.Infinite())
|
|
168
|
+
|
|
169
|
+
assertTrue(
|
|
170
|
+
"$contentType: not a parse error: ${outcome.error}",
|
|
171
|
+
outcome.error is ParserException,
|
|
172
|
+
)
|
|
173
|
+
assertEquals(contentType, 1, requests.get())
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
/**
|
|
177
|
+
* Answers the [n]th request, from 1, with the [body] of [framesFor]`(n)` frames as [contentType],
|
|
178
|
+
* silence by default and [withLength] or not, then ends it cleanly once they have all been read:
|
|
179
|
+
* a server sending in real time ends after its audio, never with it.
|
|
180
|
+
*/
|
|
181
|
+
private fun serve(
|
|
182
|
+
framesFor: (n: Int) -> Int,
|
|
183
|
+
contentType: String? = "audio/mpeg",
|
|
184
|
+
withLength: Boolean = false,
|
|
185
|
+
body: (frames: Int) -> ByteArray = ::silentMp3,
|
|
186
|
+
) {
|
|
187
|
+
val server = server
|
|
188
|
+
thread(isDaemon = true) {
|
|
189
|
+
var sent = 0
|
|
190
|
+
while (!server.isClosed) {
|
|
191
|
+
val socket =
|
|
192
|
+
try {
|
|
193
|
+
server.accept()
|
|
194
|
+
} catch (_: IOException) {
|
|
195
|
+
return@thread
|
|
196
|
+
}
|
|
197
|
+
socket.use {
|
|
198
|
+
val request = it.getInputStream().bufferedReader()
|
|
199
|
+
while (!request.readLine().isNullOrEmpty()) Unit
|
|
200
|
+
val frames = framesFor(requests.incrementAndGet())
|
|
201
|
+
val bytes = body(frames)
|
|
202
|
+
val headers = buildString {
|
|
203
|
+
append("HTTP/1.1 200 OK\r\nConnection: close\r\n")
|
|
204
|
+
contentType?.let { type -> append("Content-Type: $type\r\n") }
|
|
205
|
+
if (withLength) append("Content-Length: ${bytes.size}\r\n")
|
|
206
|
+
append("\r\n")
|
|
207
|
+
}
|
|
208
|
+
it.getOutputStream().run {
|
|
209
|
+
write(headers.toByteArray())
|
|
210
|
+
write(bytes)
|
|
211
|
+
flush()
|
|
212
|
+
}
|
|
213
|
+
sent += frames
|
|
214
|
+
while (played.get() < sent && !server.isClosed) Thread.sleep(1)
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
private class Outcome(val ended: Boolean, val error: IOException?)
|
|
221
|
+
|
|
222
|
+
private fun play(
|
|
223
|
+
live: Boolean,
|
|
224
|
+
retryPolicy: RetryPolicy,
|
|
225
|
+
stopAfterFrames: Int = Int.MAX_VALUE,
|
|
226
|
+
hasPlayed: Boolean = true,
|
|
227
|
+
): Outcome {
|
|
228
|
+
val factory =
|
|
229
|
+
MediaFactory(
|
|
230
|
+
context,
|
|
231
|
+
cache = null,
|
|
232
|
+
retryPolicy,
|
|
233
|
+
hasPlayed = { hasPlayed },
|
|
234
|
+
getRequestConfig = { _, _ -> null },
|
|
235
|
+
)
|
|
236
|
+
val item =
|
|
237
|
+
TrackFactory.toMedia3(
|
|
238
|
+
track(src = "http://127.0.0.1:${server.localPort}/stream.mp3")
|
|
239
|
+
.copy(live = live.takeIf { it })
|
|
240
|
+
)
|
|
241
|
+
val source = factory.createMediaSource(item)
|
|
242
|
+
source.prepareSource(
|
|
243
|
+
{ _, _ -> },
|
|
244
|
+
PlayerId.UNSET,
|
|
245
|
+
DefaultBandwidthMeter.Builder(context).build(),
|
|
246
|
+
)
|
|
247
|
+
val period =
|
|
248
|
+
source.createPeriod(
|
|
249
|
+
MediaSource.MediaPeriodId(Any()),
|
|
250
|
+
DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE),
|
|
251
|
+
0,
|
|
252
|
+
)
|
|
253
|
+
var prepared = false
|
|
254
|
+
period.prepare(
|
|
255
|
+
object : MediaPeriod.Callback {
|
|
256
|
+
override fun onPrepared(mediaPeriod: MediaPeriod) {
|
|
257
|
+
prepared = true
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
override fun onContinueLoadingRequested(source: MediaPeriod) {
|
|
261
|
+
source.continueLoading(LoadingInfo.Builder().build())
|
|
262
|
+
}
|
|
263
|
+
},
|
|
264
|
+
0,
|
|
265
|
+
)
|
|
266
|
+
try {
|
|
267
|
+
val prepareDeadline = System.currentTimeMillis() + 5_000
|
|
268
|
+
while (!prepared) {
|
|
269
|
+
if (System.currentTimeMillis() > prepareDeadline) fail("the stream never prepared")
|
|
270
|
+
try {
|
|
271
|
+
period.maybeThrowPrepareError()
|
|
272
|
+
} catch (e: IOException) {
|
|
273
|
+
return Outcome(ended = false, error = e)
|
|
274
|
+
}
|
|
275
|
+
Thread.sleep(5)
|
|
276
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
277
|
+
}
|
|
278
|
+
val streams = arrayOfNulls<SampleStream>(1)
|
|
279
|
+
period.selectTracks(
|
|
280
|
+
arrayOf<ExoTrackSelection>(FixedTrackSelection(period.trackGroups[0], 0)),
|
|
281
|
+
booleanArrayOf(false),
|
|
282
|
+
streams,
|
|
283
|
+
booleanArrayOf(false),
|
|
284
|
+
0,
|
|
285
|
+
)
|
|
286
|
+
val stream = checkNotNull(streams[0])
|
|
287
|
+
val buffer = DecoderInputBuffer(DecoderInputBuffer.BUFFER_REPLACEMENT_MODE_DISABLED)
|
|
288
|
+
val deadline = System.currentTimeMillis() + 60_000
|
|
289
|
+
while (played.get() < stopAfterFrames) {
|
|
290
|
+
if (System.currentTimeMillis() > deadline)
|
|
291
|
+
fail("still playing after ${played.get()} frames")
|
|
292
|
+
try {
|
|
293
|
+
stream.maybeThrowError()
|
|
294
|
+
} catch (e: IOException) {
|
|
295
|
+
return Outcome(ended = false, error = e)
|
|
296
|
+
}
|
|
297
|
+
buffer.clear()
|
|
298
|
+
val result = stream.readData(FormatHolder(), buffer, SampleStream.FLAG_OMIT_SAMPLE_DATA)
|
|
299
|
+
period.readDiscontinuity()
|
|
300
|
+
when (result) {
|
|
301
|
+
C.RESULT_BUFFER_READ -> {
|
|
302
|
+
if (buffer.isEndOfStream) return Outcome(ended = true, error = null)
|
|
303
|
+
played.incrementAndGet()
|
|
304
|
+
ShadowSystemClock.advanceBy(Duration.ofNanos(FRAME_NS))
|
|
305
|
+
}
|
|
306
|
+
C.RESULT_NOTHING_READ -> {
|
|
307
|
+
period.continueLoading(LoadingInfo.Builder().build())
|
|
308
|
+
Thread.sleep(1)
|
|
309
|
+
}
|
|
310
|
+
}
|
|
311
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
312
|
+
}
|
|
313
|
+
return Outcome(ended = false, error = null)
|
|
314
|
+
} finally {
|
|
315
|
+
source.releasePeriod(period)
|
|
316
|
+
source.releaseSource { _, _ -> }
|
|
317
|
+
}
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
private companion object {
|
|
321
|
+
// MPEG-1 Layer III at 32 kbit/s, 44.1 kHz, mono: 104 bytes and 1152 samples a frame.
|
|
322
|
+
val FRAME_HEADER = byteArrayOf(0xFF.toByte(), 0xFB.toByte(), 0x10, 0xC0.toByte())
|
|
323
|
+
const val FRAME_BYTES = 104
|
|
324
|
+
const val FRAME_NS = 1152 * 1_000_000_000L / 44_100
|
|
325
|
+
const val SECONDS_1_5 = 57
|
|
326
|
+
const val SECONDS_60 = 2_297
|
|
327
|
+
|
|
328
|
+
/** A WAV of a second of 8 kHz mono 8-bit silence, its data size in its header. */
|
|
329
|
+
fun silentWav(): ByteArray {
|
|
330
|
+
val samples = 8_000
|
|
331
|
+
val header =
|
|
332
|
+
ByteBuffer.allocate(44).order(ByteOrder.LITTLE_ENDIAN).apply {
|
|
333
|
+
put("RIFF".toByteArray())
|
|
334
|
+
putInt(36 + samples)
|
|
335
|
+
put("WAVEfmt ".toByteArray())
|
|
336
|
+
putInt(16)
|
|
337
|
+
putShort(1)
|
|
338
|
+
putShort(1)
|
|
339
|
+
putInt(8_000)
|
|
340
|
+
putInt(8_000)
|
|
341
|
+
putShort(1)
|
|
342
|
+
putShort(8)
|
|
343
|
+
put("data".toByteArray())
|
|
344
|
+
putInt(samples)
|
|
345
|
+
}
|
|
346
|
+
return header.array() + ByteArray(samples) { 0x80.toByte() }
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
/** [frames] ADTS frames of AAC LC at 44.1 kHz, mono, with 100 zero bytes of payload each. */
|
|
350
|
+
fun silentAdts(frames: Int): ByteArray {
|
|
351
|
+
val length = 7 + 100
|
|
352
|
+
val header =
|
|
353
|
+
byteArrayOf(
|
|
354
|
+
0xFF.toByte(),
|
|
355
|
+
0xF1.toByte(),
|
|
356
|
+
0x50,
|
|
357
|
+
(0x40 or (length shr 11)).toByte(),
|
|
358
|
+
(length shr 3).toByte(),
|
|
359
|
+
((length and 7) shl 5 or 0x1F).toByte(),
|
|
360
|
+
0xFC.toByte(),
|
|
361
|
+
)
|
|
362
|
+
val frame = header + ByteArray(length - header.size)
|
|
363
|
+
return ByteArray(frames * length) { frame[it % length] }
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
/** [frames] frames whose side info and main data are zero: silence any decoder accepts. */
|
|
367
|
+
fun silentMp3(frames: Int): ByteArray {
|
|
368
|
+
val frame = FRAME_HEADER + ByteArray(FRAME_BYTES - FRAME_HEADER.size)
|
|
369
|
+
return ByteArray(frames * FRAME_BYTES) { frame[it % FRAME_BYTES] }
|
|
370
|
+
}
|
|
371
|
+
}
|
|
372
|
+
}
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import com.audiobrowser.TestFixtures
|
|
4
|
+
import com.audiobrowser.model.PlayerSetupOptions
|
|
5
|
+
import com.audiobrowser.util.FALLBACK_TIMEOUT
|
|
6
|
+
import com.audiobrowser.util.JsPromise
|
|
7
|
+
import com.margelo.nitro.audiobrowser.FormatNowPlayingParams
|
|
8
|
+
import com.margelo.nitro.audiobrowser.Func_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____FormatNowPlayingParams
|
|
9
|
+
import com.margelo.nitro.audiobrowser.NowPlayingUpdate
|
|
10
|
+
import java.util.concurrent.TimeoutException
|
|
11
|
+
import kotlin.time.Duration.Companion.seconds
|
|
12
|
+
import kotlinx.coroutines.async
|
|
13
|
+
import kotlinx.coroutines.test.advanceTimeBy
|
|
14
|
+
import kotlinx.coroutines.test.runCurrent
|
|
15
|
+
import kotlinx.coroutines.test.runTest
|
|
16
|
+
import org.junit.After
|
|
17
|
+
import org.junit.Assert.assertEquals
|
|
18
|
+
import org.junit.Assert.assertFalse
|
|
19
|
+
import org.junit.Assert.assertTrue
|
|
20
|
+
import org.junit.Test
|
|
21
|
+
import org.junit.runner.RunWith
|
|
22
|
+
import org.robolectric.RobolectricTestRunner
|
|
23
|
+
import org.robolectric.RuntimeEnvironment
|
|
24
|
+
|
|
25
|
+
/** The now-playing formatter as setup hands it to the updater, unwrapped from the Nitro Func. */
|
|
26
|
+
@RunWith(RobolectricTestRunner::class)
|
|
27
|
+
class NowPlayingFormatterTest {
|
|
28
|
+
private val js = JsPromise<NowPlayingUpdate?>()
|
|
29
|
+
private val player =
|
|
30
|
+
Player(RuntimeEnvironment.getApplication()).apply {
|
|
31
|
+
setup(
|
|
32
|
+
PlayerSetupOptions(
|
|
33
|
+
nowPlayingMetadataFormatter =
|
|
34
|
+
Func_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____FormatNowPlayingParams {
|
|
35
|
+
js.promise
|
|
36
|
+
}
|
|
37
|
+
)
|
|
38
|
+
)
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
@After fun release() = player.exoPlayer.release()
|
|
42
|
+
|
|
43
|
+
private val params = FormatNowPlayingParams(TestFixtures.track("Station"), null, true, null, null)
|
|
44
|
+
|
|
45
|
+
@Test
|
|
46
|
+
fun `a formatter answering inside the timeout lands its answer`() =
|
|
47
|
+
runTest(timeout = 5.seconds) {
|
|
48
|
+
val answer = NowPlayingUpdate(title = null, artist = "Song - Artist", album = null)
|
|
49
|
+
val formatted = backgroundScope.async { player.nowPlaying.formatter!!(params) }
|
|
50
|
+
runCurrent()
|
|
51
|
+
|
|
52
|
+
advanceTimeBy(FALLBACK_TIMEOUT - 1.seconds)
|
|
53
|
+
js.resolve(answer)
|
|
54
|
+
runCurrent()
|
|
55
|
+
|
|
56
|
+
assertTrue(formatted.isCompleted)
|
|
57
|
+
assertEquals(answer, formatted.await())
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
@Test
|
|
61
|
+
fun `a formatter that never answers fails at the timeout`() =
|
|
62
|
+
runTest(timeout = 5.seconds) {
|
|
63
|
+
val formatted =
|
|
64
|
+
backgroundScope.async { runCatching { player.nowPlaying.formatter!!(params) } }
|
|
65
|
+
|
|
66
|
+
advanceTimeBy(FALLBACK_TIMEOUT - 1.seconds)
|
|
67
|
+
runCurrent()
|
|
68
|
+
assertFalse(formatted.isCompleted)
|
|
69
|
+
advanceTimeBy(2.seconds)
|
|
70
|
+
runCurrent()
|
|
71
|
+
|
|
72
|
+
assertTrue(formatted.isCompleted)
|
|
73
|
+
assertTrue(formatted.await().exceptionOrNull() is TimeoutException)
|
|
74
|
+
}
|
|
75
|
+
}
|
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
package com.audiobrowser.player
|
|
2
2
|
|
|
3
3
|
import com.audiobrowser.TestFixtures.track
|
|
4
|
+
import com.audiobrowser.util.JsPromise
|
|
5
|
+
import com.audiobrowser.util.awaitCancellable
|
|
4
6
|
import com.margelo.nitro.audiobrowser.FormatNowPlayingParams
|
|
5
7
|
import com.margelo.nitro.audiobrowser.NowPlayingMetadata
|
|
6
8
|
import com.margelo.nitro.audiobrowser.NowPlayingUpdate
|
|
@@ -9,6 +11,8 @@ import com.margelo.nitro.audiobrowser.PlaybackState
|
|
|
9
11
|
import com.margelo.nitro.audiobrowser.StallReason
|
|
10
12
|
import com.margelo.nitro.audiobrowser.Track
|
|
11
13
|
import kotlinx.coroutines.CompletableDeferred
|
|
14
|
+
import kotlinx.coroutines.Job
|
|
15
|
+
import kotlinx.coroutines.plus
|
|
12
16
|
import kotlinx.coroutines.test.advanceTimeBy
|
|
13
17
|
import kotlinx.coroutines.test.runCurrent
|
|
14
18
|
import kotlinx.coroutines.test.runTest
|
|
@@ -244,6 +248,27 @@ class NowPlayingUpdaterTest {
|
|
|
244
248
|
assertEquals(listOf("Place", "Song - Artist"), surface.stamps.map { it.secondary })
|
|
245
249
|
}
|
|
246
250
|
|
|
251
|
+
@Test
|
|
252
|
+
fun `a destroyed updater stamps nothing from a formatter still waiting on JS`() = runTest {
|
|
253
|
+
val surface = FakeSurface().apply { currentTrack = track("Station", artist = "Place") }
|
|
254
|
+
val updater = NowPlayingUpdater(surface, backgroundScope + Job())
|
|
255
|
+
val silent = JsPromise<NowPlayingUpdate?>()
|
|
256
|
+
var calls = 0
|
|
257
|
+
updater.formatter = {
|
|
258
|
+
if (++calls == 1) update(artist = "Song - Artist") else silent.promise.awaitCancellable()
|
|
259
|
+
}
|
|
260
|
+
updater.render()
|
|
261
|
+
runCurrent()
|
|
262
|
+
updater.render()
|
|
263
|
+
runCurrent()
|
|
264
|
+
val stamped = surface.stamps.toList()
|
|
265
|
+
|
|
266
|
+
updater.destroy()
|
|
267
|
+
runCurrent()
|
|
268
|
+
|
|
269
|
+
assertEquals(stamped, surface.stamps)
|
|
270
|
+
}
|
|
271
|
+
|
|
247
272
|
@Test
|
|
248
273
|
fun `a formatter that stops customizing restores the default`() = runTest {
|
|
249
274
|
val surface = FakeSurface().apply { currentTrack = track("Station", artist = "Place") }
|
|
@@ -0,0 +1,108 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import com.audiobrowser.AudioBrowser
|
|
4
|
+
import com.audiobrowser.TestFixtures
|
|
5
|
+
import com.audiobrowser.browser.BrowserConfig
|
|
6
|
+
import com.audiobrowser.browser.BrowserManager
|
|
7
|
+
import com.audiobrowser.model.PlayerSetupOptions
|
|
8
|
+
import com.audiobrowser.util.JsPromise
|
|
9
|
+
import com.margelo.nitro.audiobrowser.Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams
|
|
10
|
+
import com.margelo.nitro.audiobrowser.MediaReference
|
|
11
|
+
import com.margelo.nitro.audiobrowser.SearchParams
|
|
12
|
+
import com.margelo.nitro.audiobrowser.Track
|
|
13
|
+
import com.margelo.nitro.core.Promise
|
|
14
|
+
import kotlin.time.Duration.Companion.seconds
|
|
15
|
+
import kotlinx.coroutines.async
|
|
16
|
+
import kotlinx.coroutines.test.runCurrent
|
|
17
|
+
import kotlinx.coroutines.test.runTest
|
|
18
|
+
import org.junit.After
|
|
19
|
+
import org.junit.Assert.assertEquals
|
|
20
|
+
import org.junit.Assert.assertFalse
|
|
21
|
+
import org.junit.Assert.assertTrue
|
|
22
|
+
import org.junit.Test
|
|
23
|
+
import org.junit.runner.RunWith
|
|
24
|
+
import org.mockito.Mockito.RETURNS_DEFAULTS
|
|
25
|
+
import org.mockito.Mockito.mock
|
|
26
|
+
import org.mockito.stubbing.Answer
|
|
27
|
+
import org.robolectric.RobolectricTestRunner
|
|
28
|
+
import org.robolectric.RuntimeEnvironment
|
|
29
|
+
|
|
30
|
+
@RunWith(RobolectricTestRunner::class)
|
|
31
|
+
class PlayFromSearchTest {
|
|
32
|
+
private val player =
|
|
33
|
+
Player(RuntimeEnvironment.getApplication()).apply { setup(PlayerSetupOptions()) }
|
|
34
|
+
|
|
35
|
+
@After fun release() = player.exoPlayer.release()
|
|
36
|
+
|
|
37
|
+
private val params =
|
|
38
|
+
SearchParams(
|
|
39
|
+
mode = null,
|
|
40
|
+
query = "a",
|
|
41
|
+
genre = null,
|
|
42
|
+
artist = null,
|
|
43
|
+
album = null,
|
|
44
|
+
title = null,
|
|
45
|
+
playlist = null,
|
|
46
|
+
reference = MediaReference.UNKNOWN,
|
|
47
|
+
)
|
|
48
|
+
|
|
49
|
+
/** A browser whose search callback hands back [answer], behind Nitro's bridge promise. */
|
|
50
|
+
private fun browserWhoseSearchAnswers(answer: JsPromise<Array<Track>>) {
|
|
51
|
+
val bridge = JsPromise<Promise<Array<Track>>>().apply { resolve(answer.promise) }
|
|
52
|
+
val browserManager =
|
|
53
|
+
BrowserManager().apply {
|
|
54
|
+
config =
|
|
55
|
+
BrowserConfig(
|
|
56
|
+
routes =
|
|
57
|
+
arrayOf(
|
|
58
|
+
TestFixtures.staticRoute(
|
|
59
|
+
BrowserManager.SEARCH_ROUTE_PATH,
|
|
60
|
+
TestFixtures.resolvedTrack(path = BrowserManager.SEARCH_ROUTE_PATH),
|
|
61
|
+
)
|
|
62
|
+
.copy(
|
|
63
|
+
browseStatic = null,
|
|
64
|
+
searchCallback =
|
|
65
|
+
Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams {
|
|
66
|
+
bridge.promise
|
|
67
|
+
},
|
|
68
|
+
)
|
|
69
|
+
)
|
|
70
|
+
)
|
|
71
|
+
}
|
|
72
|
+
player.browser =
|
|
73
|
+
mock(
|
|
74
|
+
AudioBrowser::class.java,
|
|
75
|
+
Answer {
|
|
76
|
+
when {
|
|
77
|
+
it.method.name == "gateDecision" -> AudioBrowser.GateOutcome(false, null)
|
|
78
|
+
it.method.name.startsWith("getBrowserManager") -> browserManager
|
|
79
|
+
else -> RETURNS_DEFAULTS.answer(it)
|
|
80
|
+
}
|
|
81
|
+
},
|
|
82
|
+
)
|
|
83
|
+
player.notifyBrowserConfigurationReady()
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
@Test
|
|
87
|
+
fun `a search cancelled while its callback is silent ends and plays nothing`() =
|
|
88
|
+
runTest(timeout = 5.seconds) {
|
|
89
|
+
val answer = JsPromise<Array<Track>>()
|
|
90
|
+
browserWhoseSearchAnswers(answer)
|
|
91
|
+
val caller = backgroundScope.async { player.playFromSearch(params) }
|
|
92
|
+
runCurrent()
|
|
93
|
+
|
|
94
|
+
caller.cancel()
|
|
95
|
+
runCurrent()
|
|
96
|
+
answer.resolve(arrayOf(TestFixtures.track(title = "a")))
|
|
97
|
+
runCurrent()
|
|
98
|
+
|
|
99
|
+
assertTrue(caller.isCompleted)
|
|
100
|
+
assertTrue(caller.isCancelled)
|
|
101
|
+
assertEquals(emptyList<String>(), player.tracks.map { it.title })
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
@Test
|
|
105
|
+
fun `a search that times out waiting for AudioBrowser reports failure`() = runTest {
|
|
106
|
+
assertFalse(player.playFromSearch(params))
|
|
107
|
+
}
|
|
108
|
+
}
|