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.
Files changed (68) hide show
  1. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +20 -27
  2. package/android/src/main/java/com/audiobrowser/Service.kt +3 -0
  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/EnginePlayback.kt +9 -5
  7. package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +71 -39
  8. package/android/src/main/java/com/audiobrowser/player/LiveStreamExtractor.kt +65 -0
  9. package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +12 -3
  10. package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +8 -0
  11. package/android/src/main/java/com/audiobrowser/player/Player.kt +85 -37
  12. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +38 -11
  13. package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +1 -1
  14. package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +21 -0
  15. package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
  16. package/android/src/test/java/androidx/media3/session/SessionViews.kt +10 -0
  17. package/android/src/test/java/com/audiobrowser/GateDecisionTest.kt +128 -0
  18. package/android/src/test/java/com/audiobrowser/ResolveFormattedErrorTest.kt +93 -0
  19. package/android/src/test/java/com/audiobrowser/ServiceTaskRemovedTest.kt +35 -0
  20. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt +75 -5
  21. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt +42 -0
  22. package/android/src/test/java/com/audiobrowser/browser/TrackLoadHandlerTest.kt +43 -0
  23. package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt +62 -0
  24. package/android/src/test/java/com/audiobrowser/player/BrowseTilesTest.kt +31 -32
  25. package/android/src/test/java/com/audiobrowser/player/LiveStreamEndTest.kt +372 -0
  26. package/android/src/test/java/com/audiobrowser/player/NowPlayingFormatterTest.kt +75 -0
  27. package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt +25 -0
  28. package/android/src/test/java/com/audiobrowser/player/PlayFromSearchTest.kt +108 -0
  29. package/android/src/test/java/com/audiobrowser/player/PlayerSetupEndedTest.kt +221 -0
  30. package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +17 -7
  31. package/android/src/test/java/com/audiobrowser/player/PlayerSuppressionTest.kt +183 -7
  32. package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +153 -0
  33. package/android/src/test/java/com/audiobrowser/player/SessionPlayTest.kt +236 -0
  34. package/android/src/test/java/com/audiobrowser/player/SessionViewRulesTest.kt +62 -0
  35. package/android/src/test/java/com/audiobrowser/player/SessionViewTest.kt +188 -0
  36. package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +11 -0
  37. package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +58 -0
  38. package/android/src/test/java/com/audiobrowser/util/AwaitCancellableTest.kt +136 -0
  39. package/android/src/test/java/com/audiobrowser/util/JsPromise.kt +44 -0
  40. package/ios/AVPlayerEngine.swift +5 -1
  41. package/ios/Browser/BrowserManager.swift +2 -2
  42. package/ios/Browser/PageResolver.swift +14 -19
  43. package/ios/Browser/RequestPipeline.swift +6 -4
  44. package/ios/CarPlay/CarPlayNowPlayingManager.swift +1 -1
  45. package/ios/CarPlay/CarPlaySession+PageLoader.swift +1 -0
  46. package/ios/CarPlay/CarPlaySession+TabBar.swift +2 -0
  47. package/ios/Extension/Promise+AwaitCallback.swift +33 -0
  48. package/ios/HybridAudioBrowser+Player.swift +1 -1
  49. package/ios/HybridAudioBrowser.swift +1 -1
  50. package/ios/Player/MediaLoader.swift +1 -1
  51. package/ios/Player/PlaybackFailure.swift +3 -3
  52. package/ios/Player/Player.swift +67 -49
  53. package/ios/Player/PlayerEngine.swift +2 -0
  54. package/ios/Player/RetryLoop.swift +72 -12
  55. package/ios/Tests/AwaitCallbackTests.swift +210 -0
  56. package/ios/Tests/GenerationMemoTests.swift +57 -0
  57. package/ios/Tests/PlaybackFailureTests.swift +7 -0
  58. package/ios/Tests/PlayerPolicyTests.swift +346 -6
  59. package/ios/Tests/PlayerTests.swift +79 -1
  60. package/ios/Tests/RetryLoopTests.swift +30 -5
  61. package/ios/Tests/Support/TestTypes.swift +15 -7
  62. package/ios/Tests/Support/TimeLimit.swift +43 -0
  63. package/ios/Util/AwaitCallback.swift +80 -0
  64. package/ios/Util/GenerationMemo.swift +11 -4
  65. package/package.json +2 -1
  66. package/android/src/test/java/com/audiobrowser/player/SessionErrorMaskTest.kt +0 -63
  67. package/ios/Player/EndOfTrackJudgement.swift +0 -25
  68. 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
+ }