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,236 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import android.net.Uri
|
|
4
|
+
import android.os.Looper
|
|
5
|
+
import androidx.media3.common.C
|
|
6
|
+
import androidx.media3.common.Player as MediaPlayer
|
|
7
|
+
import androidx.media3.common.util.Util
|
|
8
|
+
import com.audiobrowser.Callbacks
|
|
9
|
+
import com.audiobrowser.TestFixtures
|
|
10
|
+
import com.audiobrowser.model.PlayerSetupOptions
|
|
11
|
+
import com.audiobrowser.model.RetryPolicy
|
|
12
|
+
import com.audiobrowser.util.TrackFactory
|
|
13
|
+
import com.margelo.nitro.audiobrowser.Playback
|
|
14
|
+
import com.margelo.nitro.audiobrowser.PlaybackState
|
|
15
|
+
import java.io.File
|
|
16
|
+
import java.nio.ByteBuffer
|
|
17
|
+
import java.nio.ByteOrder
|
|
18
|
+
import java.time.Duration
|
|
19
|
+
import org.junit.After
|
|
20
|
+
import org.junit.Assert.assertEquals
|
|
21
|
+
import org.junit.Assert.assertFalse
|
|
22
|
+
import org.junit.Assert.fail
|
|
23
|
+
import org.junit.Rule
|
|
24
|
+
import org.junit.Test
|
|
25
|
+
import org.junit.rules.TemporaryFolder
|
|
26
|
+
import org.junit.runner.RunWith
|
|
27
|
+
import org.mockito.Mockito.mock
|
|
28
|
+
import org.mockito.Mockito.mockingDetails
|
|
29
|
+
import org.mockito.Mockito.times
|
|
30
|
+
import org.mockito.Mockito.verify
|
|
31
|
+
import org.mockito.Mockito.`when`
|
|
32
|
+
import org.robolectric.RobolectricTestRunner
|
|
33
|
+
import org.robolectric.RuntimeEnvironment
|
|
34
|
+
import org.robolectric.Shadows.shadowOf
|
|
35
|
+
import org.robolectric.annotation.Config
|
|
36
|
+
import org.robolectric.shadows.ShadowSystemClock
|
|
37
|
+
|
|
38
|
+
/** A play from the session, or JS's setPlayWhenReady(true), plays as play() does. */
|
|
39
|
+
@RunWith(RobolectricTestRunner::class)
|
|
40
|
+
@Config(sdk = [28])
|
|
41
|
+
class SessionPlayTest {
|
|
42
|
+
|
|
43
|
+
@get:Rule val folder = TemporaryFolder()
|
|
44
|
+
|
|
45
|
+
private val context = RuntimeEnvironment.getApplication()
|
|
46
|
+
private val player = Player(context)
|
|
47
|
+
private val callbacks = mock(Callbacks::class.java)
|
|
48
|
+
|
|
49
|
+
@After
|
|
50
|
+
fun release() {
|
|
51
|
+
player.networkMonitor.destroy()
|
|
52
|
+
player.exoPlayer.release()
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
@Test
|
|
56
|
+
fun `an app's play handler takes a session play once and nothing plays`() {
|
|
57
|
+
load(Uri.fromFile(silentWav()).toString())
|
|
58
|
+
player.stop()
|
|
59
|
+
`when`(callbacks.handleRemotePlay()).thenReturn(true)
|
|
60
|
+
|
|
61
|
+
// What media3 runs for a controller's play.
|
|
62
|
+
Util.handlePlayButtonAction(player.forwardingPlayer)
|
|
63
|
+
idleFor(1)
|
|
64
|
+
|
|
65
|
+
verify(callbacks, times(1)).handleRemotePlay()
|
|
66
|
+
assertFalse(player.exoPlayer.playWhenReady)
|
|
67
|
+
assertFalse(player.isPlaying)
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
@Test
|
|
71
|
+
fun `a session play after a stop loads once and plays`() {
|
|
72
|
+
load(Uri.fromFile(silentWav()).toString())
|
|
73
|
+
player.stop()
|
|
74
|
+
val before = states().size
|
|
75
|
+
|
|
76
|
+
Util.handlePlayButtonAction(player.forwardingPlayer)
|
|
77
|
+
idleUntil("playing") { player.playbackState == PlaybackState.PLAYING }
|
|
78
|
+
|
|
79
|
+
assertEquals(listOf(PlaybackState.BUFFERING, PlaybackState.PLAYING), states().drop(before))
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
@Test
|
|
83
|
+
fun `setPlayWhenReady(true) after a stop loads`() {
|
|
84
|
+
load(Uri.fromFile(silentWav()).toString())
|
|
85
|
+
player.stop()
|
|
86
|
+
|
|
87
|
+
// As JS setPlayWhenReady(true) does: the setter alone.
|
|
88
|
+
player.playWhenReady = true
|
|
89
|
+
|
|
90
|
+
idleUntil("playing") { player.playbackState == PlaybackState.PLAYING }
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
@Test
|
|
94
|
+
fun `setPlayWhenReady(true) after a cancelled retry reloads`() {
|
|
95
|
+
load("https://127.0.0.1:9/stream", RetryPolicy.Infinite())
|
|
96
|
+
player.play()
|
|
97
|
+
idleUntil("a pending retry") { player.playbackError?.retrying == true }
|
|
98
|
+
player.pause()
|
|
99
|
+
idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
|
|
100
|
+
|
|
101
|
+
player.playWhenReady = true
|
|
102
|
+
|
|
103
|
+
idleUntil("the reload's retry") { player.playbackError?.retrying == true }
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
@Test
|
|
107
|
+
fun `a setup's raised intent over a stop loads nothing`() {
|
|
108
|
+
load(Uri.fromFile(silentWav()).toString())
|
|
109
|
+
player.stop()
|
|
110
|
+
|
|
111
|
+
val before = states().size
|
|
112
|
+
|
|
113
|
+
player.applySetupPlayWhenReady(true)
|
|
114
|
+
idleFor(1)
|
|
115
|
+
|
|
116
|
+
assertEquals(emptyList<PlaybackState>(), states().drop(before))
|
|
117
|
+
|
|
118
|
+
assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
|
|
119
|
+
assertEquals(PlaybackState.STOPPED, player.playbackState)
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
@Test
|
|
123
|
+
fun `a setup's raised intent over a terminal error loads nothing`() {
|
|
124
|
+
load("https://127.0.0.1:9/stream", RetryPolicy.Limited(maxRetries = 0))
|
|
125
|
+
val beforePlay = states().size
|
|
126
|
+
player.play()
|
|
127
|
+
idleUntil("the play's load to fail") { PlaybackState.ERROR in states().drop(beforePlay) }
|
|
128
|
+
|
|
129
|
+
val before = states().size
|
|
130
|
+
|
|
131
|
+
player.applySetupPlayWhenReady(true)
|
|
132
|
+
idleFor(1)
|
|
133
|
+
|
|
134
|
+
assertEquals(emptyList<PlaybackState>(), states().drop(before))
|
|
135
|
+
|
|
136
|
+
assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
|
|
137
|
+
assertEquals(PlaybackState.ERROR, player.playbackState)
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
@Test
|
|
141
|
+
fun `a setup's raised intent over a cancelled retry loads nothing`() {
|
|
142
|
+
load("https://127.0.0.1:9/stream", RetryPolicy.Infinite())
|
|
143
|
+
player.play()
|
|
144
|
+
idleUntil("a pending retry") { player.playbackError?.retrying == true }
|
|
145
|
+
player.pause()
|
|
146
|
+
idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
|
|
147
|
+
|
|
148
|
+
val before = states().size
|
|
149
|
+
|
|
150
|
+
player.applySetupPlayWhenReady(true)
|
|
151
|
+
idleFor(1)
|
|
152
|
+
|
|
153
|
+
assertEquals(emptyList<PlaybackState>(), states().drop(before))
|
|
154
|
+
|
|
155
|
+
assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
|
|
156
|
+
assertEquals(PlaybackState.PAUSED, player.playbackState)
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
@Test
|
|
160
|
+
fun `a setup's raised intent plays a queue set afterwards`() {
|
|
161
|
+
player.setup(PlayerSetupOptions())
|
|
162
|
+
player.setCallbacks(callbacks)
|
|
163
|
+
player.exoPlayer.trackSelectionParameters =
|
|
164
|
+
player.exoPlayer.trackSelectionParameters
|
|
165
|
+
.buildUpon()
|
|
166
|
+
.setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, true)
|
|
167
|
+
.build()
|
|
168
|
+
player.applySetupPlayWhenReady(true)
|
|
169
|
+
|
|
170
|
+
player.setQueue(arrayOf(TestFixtures.track(src = Uri.fromFile(silentWav()).toString())))
|
|
171
|
+
|
|
172
|
+
idleUntil("playing") { player.playbackState == PlaybackState.PLAYING }
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
private fun load(src: String, retryPolicy: RetryPolicy = RetryPolicy.Default) {
|
|
176
|
+
player.setup(PlayerSetupOptions(retryPolicy = retryPolicy))
|
|
177
|
+
player.setCallbacks(callbacks)
|
|
178
|
+
player.exoPlayer.trackSelectionParameters =
|
|
179
|
+
player.exoPlayer.trackSelectionParameters
|
|
180
|
+
.buildUpon()
|
|
181
|
+
.setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, true)
|
|
182
|
+
.build()
|
|
183
|
+
player.exoPlayer.setMediaItems(listOf(TrackFactory.toMedia3(TestFixtures.track(src = src))))
|
|
184
|
+
player.exoPlayer.prepare()
|
|
185
|
+
idleFor(1)
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
private fun states() =
|
|
189
|
+
mockingDetails(callbacks)
|
|
190
|
+
.invocations
|
|
191
|
+
.filter { it.method.name == "onPlaybackChanged" }
|
|
192
|
+
.map { (it.arguments[0] as Playback).state }
|
|
193
|
+
|
|
194
|
+
private fun idleFor(seconds: Int) =
|
|
195
|
+
repeat(seconds * 10) {
|
|
196
|
+
ShadowSystemClock.advanceBy(Duration.ofMillis(100))
|
|
197
|
+
Thread.sleep(10)
|
|
198
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
private fun idleUntil(what: String, condition: () -> Boolean) {
|
|
202
|
+
val deadline = System.currentTimeMillis() + 5_000
|
|
203
|
+
while (!condition()) {
|
|
204
|
+
if (System.currentTimeMillis() > deadline)
|
|
205
|
+
fail(
|
|
206
|
+
"timed out waiting for $what: ${player.playbackState}, exo ${player.exoPlayer.playbackState}"
|
|
207
|
+
)
|
|
208
|
+
ShadowSystemClock.advanceBy(Duration.ofMillis(100))
|
|
209
|
+
Thread.sleep(10)
|
|
210
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
211
|
+
}
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
/** Half a second of 8 kHz mono 8-bit silence. */
|
|
215
|
+
private fun silentWav(): File {
|
|
216
|
+
val samples = 4_000
|
|
217
|
+
val header =
|
|
218
|
+
ByteBuffer.allocate(44).order(ByteOrder.LITTLE_ENDIAN).apply {
|
|
219
|
+
put("RIFF".toByteArray())
|
|
220
|
+
putInt(36 + samples)
|
|
221
|
+
put("WAVEfmt ".toByteArray())
|
|
222
|
+
putInt(16)
|
|
223
|
+
putShort(1)
|
|
224
|
+
putShort(1)
|
|
225
|
+
putInt(8_000)
|
|
226
|
+
putInt(8_000)
|
|
227
|
+
putShort(1)
|
|
228
|
+
putShort(8)
|
|
229
|
+
put("data".toByteArray())
|
|
230
|
+
putInt(samples)
|
|
231
|
+
}
|
|
232
|
+
return folder.newFile("silence.wav").apply {
|
|
233
|
+
writeBytes(header.array() + ByteArray(samples) { 0x80.toByte() })
|
|
234
|
+
}
|
|
235
|
+
}
|
|
236
|
+
}
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import androidx.media3.common.Player as MediaPlayer
|
|
4
|
+
import com.margelo.nitro.audiobrowser.PlaybackState
|
|
5
|
+
import org.junit.Assert.assertEquals
|
|
6
|
+
import org.junit.Test
|
|
7
|
+
|
|
8
|
+
class SessionViewRulesTest {
|
|
9
|
+
|
|
10
|
+
private fun view(
|
|
11
|
+
engineState: Int = MediaPlayer.STATE_IDLE,
|
|
12
|
+
state: PlaybackState = PlaybackState.NONE,
|
|
13
|
+
engineFailed: Boolean = false,
|
|
14
|
+
keepAlive: Boolean = true,
|
|
15
|
+
) = SessionView.playbackState(engineState, state, engineFailed, keepAlive)
|
|
16
|
+
|
|
17
|
+
@Test
|
|
18
|
+
fun `an idle engine with an error, in ERROR or in PAUSED reads ready while keep-alive is on`() {
|
|
19
|
+
assertEquals(MediaPlayer.STATE_READY, view(state = PlaybackState.PLAYING, engineFailed = true))
|
|
20
|
+
assertEquals(MediaPlayer.STATE_READY, view(state = PlaybackState.ERROR))
|
|
21
|
+
assertEquals(MediaPlayer.STATE_READY, view(state = PlaybackState.PAUSED))
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
@Test
|
|
25
|
+
fun `an ended queue on an idle engine reads ended, keep-alive or not`() {
|
|
26
|
+
assertEquals(MediaPlayer.STATE_ENDED, view(state = PlaybackState.ENDED))
|
|
27
|
+
assertEquals(MediaPlayer.STATE_ENDED, view(state = PlaybackState.ENDED, keepAlive = false))
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
@Test
|
|
31
|
+
fun `no masking without keep-alive`() {
|
|
32
|
+
assertEquals(MediaPlayer.STATE_IDLE, view(engineFailed = true, keepAlive = false))
|
|
33
|
+
assertEquals(MediaPlayer.STATE_IDLE, view(state = PlaybackState.ERROR, keepAlive = false))
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
@Test
|
|
37
|
+
fun `no masking in other states or outside idle`() {
|
|
38
|
+
assertEquals(MediaPlayer.STATE_IDLE, view(state = PlaybackState.STOPPED))
|
|
39
|
+
assertEquals(MediaPlayer.STATE_IDLE, view(state = PlaybackState.STOPPED, engineFailed = true))
|
|
40
|
+
assertEquals(MediaPlayer.STATE_IDLE, view(state = PlaybackState.NONE))
|
|
41
|
+
assertEquals(
|
|
42
|
+
MediaPlayer.STATE_BUFFERING,
|
|
43
|
+
view(engineState = MediaPlayer.STATE_BUFFERING, engineFailed = true),
|
|
44
|
+
)
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
@Test
|
|
48
|
+
fun `an idle engine read as anything else isn't about to play`() {
|
|
49
|
+
assertEquals(
|
|
50
|
+
false,
|
|
51
|
+
SessionView.playWhenReady(true, MediaPlayer.STATE_IDLE, MediaPlayer.STATE_READY),
|
|
52
|
+
)
|
|
53
|
+
assertEquals(
|
|
54
|
+
true,
|
|
55
|
+
SessionView.playWhenReady(true, MediaPlayer.STATE_IDLE, MediaPlayer.STATE_IDLE),
|
|
56
|
+
)
|
|
57
|
+
assertEquals(
|
|
58
|
+
true,
|
|
59
|
+
SessionView.playWhenReady(true, MediaPlayer.STATE_READY, MediaPlayer.STATE_READY),
|
|
60
|
+
)
|
|
61
|
+
}
|
|
62
|
+
}
|
|
@@ -0,0 +1,188 @@
|
|
|
1
|
+
package com.audiobrowser.player
|
|
2
|
+
|
|
3
|
+
import android.net.Uri
|
|
4
|
+
import android.os.Looper
|
|
5
|
+
import androidx.media3.common.C
|
|
6
|
+
import androidx.media3.common.Player as MediaPlayer
|
|
7
|
+
import androidx.media3.session.MediaSession
|
|
8
|
+
import androidx.media3.session.controllerTitle
|
|
9
|
+
import androidx.media3.session.legacy.PlaybackStateCompat
|
|
10
|
+
import androidx.media3.session.legacyState
|
|
11
|
+
import com.audiobrowser.Callbacks
|
|
12
|
+
import com.audiobrowser.TestFixtures
|
|
13
|
+
import com.audiobrowser.model.PlayerSetupOptions
|
|
14
|
+
import com.audiobrowser.model.RetryPolicy
|
|
15
|
+
import com.audiobrowser.util.TrackFactory
|
|
16
|
+
import com.margelo.nitro.audiobrowser.PlaybackState
|
|
17
|
+
import java.io.File
|
|
18
|
+
import java.nio.ByteBuffer
|
|
19
|
+
import java.nio.ByteOrder
|
|
20
|
+
import java.time.Duration
|
|
21
|
+
import org.junit.After
|
|
22
|
+
import org.junit.Assert.assertEquals
|
|
23
|
+
import org.junit.Assert.fail
|
|
24
|
+
import org.junit.Rule
|
|
25
|
+
import org.junit.Test
|
|
26
|
+
import org.junit.rules.TemporaryFolder
|
|
27
|
+
import org.junit.runner.RunWith
|
|
28
|
+
import org.mockito.Mockito.mock
|
|
29
|
+
import org.robolectric.RobolectricTestRunner
|
|
30
|
+
import org.robolectric.RuntimeEnvironment
|
|
31
|
+
import org.robolectric.Shadows.shadowOf
|
|
32
|
+
import org.robolectric.annotation.Config
|
|
33
|
+
import org.robolectric.shadows.ShadowSystemClock
|
|
34
|
+
|
|
35
|
+
/**
|
|
36
|
+
* What the session tells legacy controllers (Android Auto, Bluetooth, the system UI) for each state
|
|
37
|
+
* on an idle engine.
|
|
38
|
+
*/
|
|
39
|
+
@RunWith(RobolectricTestRunner::class)
|
|
40
|
+
@Config(sdk = [28])
|
|
41
|
+
class SessionViewTest {
|
|
42
|
+
|
|
43
|
+
@get:Rule val folder = TemporaryFolder()
|
|
44
|
+
|
|
45
|
+
private val context = RuntimeEnvironment.getApplication()
|
|
46
|
+
private val player = Player(context)
|
|
47
|
+
private val callbacks = mock(Callbacks::class.java)
|
|
48
|
+
private lateinit var session: MediaSession
|
|
49
|
+
|
|
50
|
+
private val paused = PlaybackStateCompat.STATE_PAUSED
|
|
51
|
+
private val idle = PlaybackStateCompat.STATE_NONE
|
|
52
|
+
|
|
53
|
+
@After
|
|
54
|
+
fun release() {
|
|
55
|
+
session.release()
|
|
56
|
+
player.networkMonitor.destroy()
|
|
57
|
+
player.exoPlayer.release()
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
@Test
|
|
61
|
+
fun `a cancelled retry reads paused`() {
|
|
62
|
+
play(RetryPolicy.Infinite())
|
|
63
|
+
idleUntil("a pending retry") { player.playbackError?.retrying == true }
|
|
64
|
+
|
|
65
|
+
player.pause()
|
|
66
|
+
idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
|
|
67
|
+
|
|
68
|
+
assertEquals(PlaybackState.PAUSED, player.playbackState)
|
|
69
|
+
assertEquals(paused, session.legacyState())
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
@Test
|
|
73
|
+
fun `a terminal error reads paused`() {
|
|
74
|
+
failTerminally()
|
|
75
|
+
|
|
76
|
+
assertEquals(paused, session.legacyState())
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
@Test
|
|
80
|
+
fun `an error a rebuild dropped reads paused`() {
|
|
81
|
+
failTerminally()
|
|
82
|
+
|
|
83
|
+
player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
|
|
84
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
85
|
+
|
|
86
|
+
assertEquals(PlaybackState.ERROR, player.playbackState)
|
|
87
|
+
assertEquals(paused, session.legacyState())
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
@Test
|
|
91
|
+
fun `a stop after a terminal error reads idle`() {
|
|
92
|
+
failTerminally()
|
|
93
|
+
|
|
94
|
+
player.stop()
|
|
95
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
96
|
+
|
|
97
|
+
assertEquals(idle, session.legacyState())
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
@Test
|
|
101
|
+
fun `a stop after a cancelled retry reads idle`() {
|
|
102
|
+
play(RetryPolicy.Infinite())
|
|
103
|
+
idleUntil("a pending retry") { player.playbackError?.retrying == true }
|
|
104
|
+
player.pause()
|
|
105
|
+
idleUntil("an idle engine") { player.exoPlayer.playbackState == MediaPlayer.STATE_IDLE }
|
|
106
|
+
|
|
107
|
+
player.stop()
|
|
108
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
109
|
+
|
|
110
|
+
assertEquals(idle, session.legacyState())
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
@Test
|
|
114
|
+
fun `an ended queue a rebuild carried idle reads ended`() {
|
|
115
|
+
play(RetryPolicy.Default, Uri.fromFile(silentWav()).toString())
|
|
116
|
+
idleUntil("ENDED") { player.playbackState == PlaybackState.ENDED }
|
|
117
|
+
|
|
118
|
+
player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
|
|
119
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
120
|
+
|
|
121
|
+
assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
|
|
122
|
+
assertEquals(PlaybackStateCompat.STATE_STOPPED, session.legacyState())
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
@Test
|
|
126
|
+
fun `the session hears the current track's title`() {
|
|
127
|
+
play(RetryPolicy.Default, Uri.fromFile(silentWav()).toString())
|
|
128
|
+
idleUntil("ENDED") { player.playbackState == PlaybackState.ENDED }
|
|
129
|
+
|
|
130
|
+
assertEquals("T", session.controllerTitle())
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
private fun failTerminally() {
|
|
134
|
+
play(RetryPolicy.Limited(maxRetries = 0))
|
|
135
|
+
idleUntil("a terminal error") { player.playbackState == PlaybackState.ERROR }
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
private fun play(retryPolicy: RetryPolicy, src: String = "https://127.0.0.1:9/stream") {
|
|
139
|
+
player.setup(PlayerSetupOptions(retryPolicy = retryPolicy))
|
|
140
|
+
player.setCallbacks(callbacks)
|
|
141
|
+
session = MediaSession.Builder(context, player.forwardingPlayer).build()
|
|
142
|
+
player.setMediaSession(session)
|
|
143
|
+
player.exoPlayer.trackSelectionParameters =
|
|
144
|
+
player.exoPlayer.trackSelectionParameters
|
|
145
|
+
.buildUpon()
|
|
146
|
+
.setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, true)
|
|
147
|
+
.build()
|
|
148
|
+
player.exoPlayer.setMediaItems(listOf(TrackFactory.toMedia3(TestFixtures.track(src = src))))
|
|
149
|
+
player.exoPlayer.prepare()
|
|
150
|
+
player.play()
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
private fun idleUntil(what: String, condition: () -> Boolean) {
|
|
154
|
+
val deadline = System.currentTimeMillis() + 5_000
|
|
155
|
+
while (!condition()) {
|
|
156
|
+
if (System.currentTimeMillis() > deadline)
|
|
157
|
+
fail(
|
|
158
|
+
"timed out waiting for $what: ${player.playbackState}, exo ${player.exoPlayer.playbackState}"
|
|
159
|
+
)
|
|
160
|
+
ShadowSystemClock.advanceBy(Duration.ofMillis(100))
|
|
161
|
+
Thread.sleep(10)
|
|
162
|
+
shadowOf(Looper.getMainLooper()).idle()
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
/** Half a second of 8 kHz mono 8-bit silence. */
|
|
167
|
+
private fun silentWav(): File {
|
|
168
|
+
val samples = 4_000
|
|
169
|
+
val header =
|
|
170
|
+
ByteBuffer.allocate(44).order(ByteOrder.LITTLE_ENDIAN).apply {
|
|
171
|
+
put("RIFF".toByteArray())
|
|
172
|
+
putInt(36 + samples)
|
|
173
|
+
put("WAVEfmt ".toByteArray())
|
|
174
|
+
putInt(16)
|
|
175
|
+
putShort(1)
|
|
176
|
+
putShort(1)
|
|
177
|
+
putInt(8_000)
|
|
178
|
+
putInt(8_000)
|
|
179
|
+
putShort(1)
|
|
180
|
+
putShort(8)
|
|
181
|
+
put("data".toByteArray())
|
|
182
|
+
putInt(samples)
|
|
183
|
+
}
|
|
184
|
+
return folder.newFile("silence.wav").apply {
|
|
185
|
+
writeBytes(header.array() + ByteArray(samples) { 0x80.toByte() })
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
}
|
|
@@ -4,12 +4,14 @@ import android.os.Looper
|
|
|
4
4
|
import androidx.media3.common.C
|
|
5
5
|
import androidx.media3.common.DeviceInfo
|
|
6
6
|
import androidx.media3.common.MediaItem
|
|
7
|
+
import androidx.media3.common.Metadata
|
|
7
8
|
import androidx.media3.common.PlaybackException
|
|
8
9
|
import androidx.media3.common.PlaybackParameters
|
|
9
10
|
import androidx.media3.common.Player as MediaPlayer
|
|
10
11
|
import androidx.media3.common.SimpleBasePlayer
|
|
11
12
|
import androidx.media3.common.TrackSelectionParameters
|
|
12
13
|
import androidx.media3.common.util.Util
|
|
14
|
+
import androidx.media3.extractor.metadata.icy.IcyInfo
|
|
13
15
|
import com.google.common.util.concurrent.Futures
|
|
14
16
|
import com.google.common.util.concurrent.ListenableFuture
|
|
15
17
|
|
|
@@ -140,6 +142,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
|
|
|
140
142
|
var lagging = false
|
|
141
143
|
private var held: MediaItem? = null
|
|
142
144
|
private var uid = Any()
|
|
145
|
+
private var metadata: Metadata? = null
|
|
143
146
|
|
|
144
147
|
fun catchUp() {
|
|
145
148
|
held?.let { item = it }
|
|
@@ -155,6 +158,12 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
|
|
|
155
158
|
|
|
156
159
|
fun update() = invalidateState()
|
|
157
160
|
|
|
161
|
+
/** Reports a stream title for whatever it plays, as a receiver's poll does; a load clears it. */
|
|
162
|
+
fun title(title: String) {
|
|
163
|
+
metadata = Metadata(0, IcyInfo(title.toByteArray(), title, null))
|
|
164
|
+
invalidateState()
|
|
165
|
+
}
|
|
166
|
+
|
|
158
167
|
override fun getState(): State =
|
|
159
168
|
State.Builder()
|
|
160
169
|
.setAvailableCommands(MediaPlayer.Commands.Builder().addAllCommands().build())
|
|
@@ -169,6 +178,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
|
|
|
169
178
|
.setPlaybackState(if (item == null) STATE_IDLE else readiness)
|
|
170
179
|
.setDeviceInfo(DEVICE_INFO)
|
|
171
180
|
.setDeviceVolume(volume)
|
|
181
|
+
.apply { metadata?.let(::setTimedMetadata) }
|
|
172
182
|
.build()
|
|
173
183
|
|
|
174
184
|
override fun handleSetMediaItems(
|
|
@@ -180,6 +190,7 @@ internal class FakeReceiver(looper: Looper) : SimpleBasePlayer(looper) {
|
|
|
180
190
|
loads += SentLoad(loaded, startPositionMs, intent)
|
|
181
191
|
// A fresh uid makes a reload of the same item a new playlist entry to listeners.
|
|
182
192
|
uid = Any()
|
|
193
|
+
metadata = null
|
|
183
194
|
positionMs = if (startPositionMs == C.TIME_UNSET) 0 else startPositionMs
|
|
184
195
|
readiness = STATE_READY
|
|
185
196
|
if (lagging) held = loaded else item = loaded
|
|
@@ -3,8 +3,10 @@ package com.audiobrowser.remote
|
|
|
3
3
|
import android.os.Looper
|
|
4
4
|
import androidx.media3.common.C
|
|
5
5
|
import androidx.media3.common.MediaItem
|
|
6
|
+
import androidx.media3.common.Metadata
|
|
6
7
|
import androidx.media3.common.PlaybackException
|
|
7
8
|
import androidx.media3.common.Player as MediaPlayer
|
|
9
|
+
import androidx.media3.extractor.metadata.icy.IcyInfo
|
|
8
10
|
import java.time.Duration
|
|
9
11
|
import kotlinx.coroutines.CompletableDeferred
|
|
10
12
|
import kotlinx.coroutines.MainScope
|
|
@@ -870,6 +872,45 @@ class RemoteSwitchingPlayerTest {
|
|
|
870
872
|
assertEquals(200_000, player.currentPosition)
|
|
871
873
|
}
|
|
872
874
|
|
|
875
|
+
@Test
|
|
876
|
+
fun `a title for the outgoing item while the next one resolves never shows on it`() {
|
|
877
|
+
playLocally(listOf("a", "b"))
|
|
878
|
+
remote.startSession()
|
|
879
|
+
idle()
|
|
880
|
+
remote.player.title("A 1")
|
|
881
|
+
idle()
|
|
882
|
+
val seen = transitionsAndTitles()
|
|
883
|
+
gate = CompletableDeferred()
|
|
884
|
+
|
|
885
|
+
player.seekToNextMediaItem()
|
|
886
|
+
idle()
|
|
887
|
+
remote.player.title("A 2")
|
|
888
|
+
idle()
|
|
889
|
+
gate!!.complete(Unit)
|
|
890
|
+
idle()
|
|
891
|
+
remote.player.title("B 1")
|
|
892
|
+
idle()
|
|
893
|
+
|
|
894
|
+
assertEquals(listOf("b", "B 1"), seen)
|
|
895
|
+
}
|
|
896
|
+
|
|
897
|
+
@Test
|
|
898
|
+
fun `a new load of the same stream shows its title again`() {
|
|
899
|
+
playLocally(listOf("a"))
|
|
900
|
+
remote.startSession()
|
|
901
|
+
idle()
|
|
902
|
+
remote.player.title("Song")
|
|
903
|
+
idle()
|
|
904
|
+
val seen = transitionsAndTitles()
|
|
905
|
+
|
|
906
|
+
player.setMediaItems(items("a"))
|
|
907
|
+
idle()
|
|
908
|
+
remote.player.title("Song")
|
|
909
|
+
idle()
|
|
910
|
+
|
|
911
|
+
assertEquals(listOf("a", "Song"), seen)
|
|
912
|
+
}
|
|
913
|
+
|
|
873
914
|
@Test
|
|
874
915
|
fun `release brings playback back and lets every remote go`() {
|
|
875
916
|
playLocally(listOf("a"))
|
|
@@ -906,6 +947,23 @@ class RemoteSwitchingPlayerTest {
|
|
|
906
947
|
idle()
|
|
907
948
|
}
|
|
908
949
|
|
|
950
|
+
/** The id of each item transitioned to, and each stream title, in the order the player tells. */
|
|
951
|
+
private fun transitionsAndTitles(): List<String> {
|
|
952
|
+
val seen = mutableListOf<String>()
|
|
953
|
+
player.addListener(
|
|
954
|
+
object : MediaPlayer.Listener {
|
|
955
|
+
override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
|
|
956
|
+
seen += mediaItem?.mediaId.orEmpty()
|
|
957
|
+
}
|
|
958
|
+
|
|
959
|
+
override fun onMetadata(metadata: Metadata) {
|
|
960
|
+
seen += (metadata[0] as IcyInfo).title.orEmpty()
|
|
961
|
+
}
|
|
962
|
+
}
|
|
963
|
+
)
|
|
964
|
+
return seen
|
|
965
|
+
}
|
|
966
|
+
|
|
909
967
|
private fun queue() = (0 until player.mediaItemCount).map { player.getMediaItemAt(it).mediaId }
|
|
910
968
|
|
|
911
969
|
private fun SentLoad.short() = Triple(item.mediaId, positionMs, autoplay)
|