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.
- package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +19 -26
- 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/NowPlayingUpdater.kt +3 -0
- package/android/src/main/java/com/audiobrowser/player/Player.kt +7 -1
- package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +32 -11
- 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/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/PlayerTrackChangeTest.kt +105 -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/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.
|
|
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"
|