react-native-audio-browser 0.2.0-next.75 → 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 (24) hide show
  1. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +19 -26
  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/NowPlayingUpdater.kt +3 -0
  7. package/android/src/main/java/com/audiobrowser/player/Player.kt +7 -1
  8. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +32 -11
  9. package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
  10. package/android/src/test/java/com/audiobrowser/GateDecisionTest.kt +128 -0
  11. package/android/src/test/java/com/audiobrowser/ResolveFormattedErrorTest.kt +93 -0
  12. package/android/src/test/java/com/audiobrowser/ServiceTaskRemovedTest.kt +35 -0
  13. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt +75 -5
  14. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt +42 -0
  15. package/android/src/test/java/com/audiobrowser/browser/TrackLoadHandlerTest.kt +43 -0
  16. package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt +62 -0
  17. package/android/src/test/java/com/audiobrowser/player/BrowseTilesTest.kt +31 -32
  18. package/android/src/test/java/com/audiobrowser/player/NowPlayingFormatterTest.kt +75 -0
  19. package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt +25 -0
  20. package/android/src/test/java/com/audiobrowser/player/PlayFromSearchTest.kt +108 -0
  21. package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +105 -0
  22. package/android/src/test/java/com/audiobrowser/util/AwaitCancellableTest.kt +136 -0
  23. package/android/src/test/java/com/audiobrowser/util/JsPromise.kt +44 -0
  24. package/package.json +2 -1
@@ -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
+ }
@@ -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
  }
@@ -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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "react-native-audio-browser",
3
- "version": "0.2.0-next.75",
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"