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,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)