react-native-audio-browser 0.2.0-next.50 → 0.2.0-next.51

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 (90) hide show
  1. package/android/build.gradle +15 -0
  2. package/android/src/cast/java/com/audiobrowser/cast/CastSupport.kt +215 -0
  3. package/android/src/main/AndroidManifest.xml +11 -0
  4. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +0 -4
  5. package/android/src/main/java/com/audiobrowser/RemoteOutputs.kt +47 -10
  6. package/android/src/main/java/com/audiobrowser/model/PlayerSetupOptions.kt +12 -3
  7. package/android/src/main/java/com/audiobrowser/player/EqualizerController.kt +4 -1
  8. package/android/src/main/java/com/audiobrowser/player/LocalEngine.kt +49 -0
  9. package/android/src/main/java/com/audiobrowser/player/Player.kt +170 -119
  10. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +18 -13
  11. package/android/src/main/java/com/audiobrowser/player/TransformingDataSource.kt +10 -13
  12. package/android/src/main/java/com/audiobrowser/remote/RemoteItem.kt +64 -0
  13. package/android/src/main/java/com/audiobrowser/remote/RemoteOutputsController.kt +98 -0
  14. package/android/src/main/java/com/audiobrowser/remote/RemotePlayback.kt +42 -0
  15. package/android/src/main/java/com/audiobrowser/remote/RemoteQueue.kt +110 -0
  16. package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +696 -0
  17. package/android/src/main/java/com/audiobrowser/sonos/DeviceDescriptionParser.kt +113 -0
  18. package/android/src/main/java/com/audiobrowser/sonos/DidlLite.kt +39 -0
  19. package/android/src/main/java/com/audiobrowser/sonos/SoapClient.kt +59 -0
  20. package/android/src/main/java/com/audiobrowser/sonos/SoapEnvelopes.kt +92 -0
  21. package/android/src/main/java/com/audiobrowser/sonos/SoapResponseParser.kt +105 -0
  22. package/android/src/main/java/com/audiobrowser/sonos/SonosDiscoverer.kt +69 -0
  23. package/android/src/main/java/com/audiobrowser/sonos/SonosOutputs.kt +128 -0
  24. package/android/src/main/java/com/audiobrowser/sonos/SonosPlayer.kt +550 -0
  25. package/android/src/main/java/com/audiobrowser/sonos/SonosRemote.kt +99 -0
  26. package/android/src/main/java/com/audiobrowser/sonos/SonosRouteProviderService.kt +201 -0
  27. package/android/src/main/java/com/audiobrowser/sonos/SonosStreamUri.kt +15 -0
  28. package/android/src/main/java/com/audiobrowser/sonos/SonosTransport.kt +66 -0
  29. package/android/src/main/java/com/audiobrowser/sonos/SpeakerXml.kt +26 -0
  30. package/android/src/main/java/com/audiobrowser/sonos/SsdpDiscovery.kt +63 -0
  31. package/android/src/main/java/com/audiobrowser/sonos/SsdpMessages.kt +63 -0
  32. package/android/src/main/java/com/audiobrowser/sonos/ZoneGroupState.kt +68 -0
  33. package/android/src/main/java/com/audiobrowser/util/OutputMonitor.kt +2 -1
  34. package/android/src/nocast/java/com/audiobrowser/cast/CastSupport.kt +18 -0
  35. package/android/src/test/java/com/audiobrowser/RemoteOutputsTest.kt +20 -3
  36. package/android/src/test/java/com/audiobrowser/model/PlayerSetupOptionsTest.kt +35 -0
  37. package/android/src/test/java/com/audiobrowser/player/EqualizerControllerTest.kt +12 -0
  38. package/android/src/test/java/com/audiobrowser/player/PlayerCastTest.kt +136 -0
  39. package/android/src/test/java/com/audiobrowser/player/PlayerSonosTest.kt +213 -0
  40. package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +275 -0
  41. package/android/src/test/java/com/audiobrowser/remote/RemoteItemTest.kt +61 -0
  42. package/android/src/test/java/com/audiobrowser/remote/RemoteOutputsControllerTest.kt +77 -0
  43. package/android/src/test/java/com/audiobrowser/remote/RemoteQueueTest.kt +101 -0
  44. package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +815 -0
  45. package/android/src/test/java/com/audiobrowser/sonos/DeviceDescriptionParserTest.kt +203 -0
  46. package/android/src/test/java/com/audiobrowser/sonos/DidlLiteTest.kt +90 -0
  47. package/android/src/test/java/com/audiobrowser/sonos/SoapClientTest.kt +73 -0
  48. package/android/src/test/java/com/audiobrowser/sonos/SoapEnvelopesTest.kt +135 -0
  49. package/android/src/test/java/com/audiobrowser/sonos/SoapResponseParserTest.kt +170 -0
  50. package/android/src/test/java/com/audiobrowser/sonos/SonosDiscovererTest.kt +174 -0
  51. package/android/src/test/java/com/audiobrowser/sonos/SonosPlayerTest.kt +691 -0
  52. package/android/src/test/java/com/audiobrowser/sonos/SonosRemoteTest.kt +129 -0
  53. package/android/src/test/java/com/audiobrowser/sonos/SonosRoutesTest.kt +165 -0
  54. package/android/src/test/java/com/audiobrowser/sonos/SonosStreamUriTest.kt +64 -0
  55. package/android/src/test/java/com/audiobrowser/sonos/SonosTransportTest.kt +204 -0
  56. package/android/src/test/java/com/audiobrowser/sonos/SsdpMessagesTest.kt +99 -0
  57. package/android/src/test/java/com/audiobrowser/sonos/ZoneGroupStateTest.kt +139 -0
  58. package/android/src/test/java/com/audiobrowser/util/OutputMonitorTest.kt +12 -10
  59. package/android/src/test/resources/sonos/device_description.xml +78 -0
  60. package/android/src/testCast/java/com/audiobrowser/cast/CastEndsTest.kt +56 -0
  61. package/android/src/testCast/java/com/audiobrowser/cast/SendingMediaItemConverterTest.kt +79 -0
  62. package/lib/commonjs/features/player/setup.js +2 -0
  63. package/lib/commonjs/features/player/setup.js.map +1 -1
  64. package/lib/module/features/player/setup.js +2 -0
  65. package/lib/module/features/player/setup.js.map +1 -1
  66. package/lib/typescript/src/features/player/setup.d.ts +37 -7
  67. package/lib/typescript/src/features/player/setup.d.ts.map +1 -1
  68. package/lib/typescript/src/specs/audio-browser.nitro.d.ts +3 -3
  69. package/lib/typescript/src/specs/audio-browser.nitro.d.ts.map +1 -1
  70. package/nitrogen/generated/android/c++/JHybridAudioBrowserSpec.cpp +4 -0
  71. package/nitrogen/generated/android/c++/JNativeSetupPlayerOptions.hpp +7 -5
  72. package/nitrogen/generated/android/c++/JOutputType.hpp +3 -0
  73. package/nitrogen/generated/android/c++/JRemoteOutputsOptions.hpp +66 -0
  74. package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/NativeSetupPlayerOptions.kt +3 -3
  75. package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/OutputType.kt +3 -2
  76. package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/RemoteOutputsOptions.kt +61 -0
  77. package/nitrogen/generated/ios/AudioBrowser-Swift-Cxx-Bridge.hpp +18 -0
  78. package/nitrogen/generated/ios/AudioBrowser-Swift-Cxx-Umbrella.hpp +3 -0
  79. package/nitrogen/generated/ios/c++/HybridAudioBrowserSpecSwift.hpp +3 -0
  80. package/nitrogen/generated/ios/swift/NativeSetupPlayerOptions.swift +5 -12
  81. package/nitrogen/generated/ios/swift/OutputType.swift +4 -0
  82. package/nitrogen/generated/ios/swift/RemoteOutputsOptions.swift +78 -0
  83. package/nitrogen/generated/shared/c++/NativeSetupPlayerOptions.hpp +8 -5
  84. package/nitrogen/generated/shared/c++/OutputType.hpp +6 -2
  85. package/nitrogen/generated/shared/c++/RemoteOutputsOptions.hpp +92 -0
  86. package/package.json +1 -1
  87. package/src/features/player/setup.ts +38 -7
  88. package/src/specs/audio-browser.nitro.ts +4 -3
  89. package/website/guide/audio-output.md +185 -4
  90. package/website/guide/configuration.md +6 -0
@@ -0,0 +1,696 @@
1
+ package com.audiobrowser.remote
2
+
3
+ import android.os.Looper
4
+ import androidx.media3.common.C
5
+ import androidx.media3.common.ForwardingSimpleBasePlayer
6
+ import androidx.media3.common.MediaItem
7
+ import androidx.media3.common.PlaybackException
8
+ import androidx.media3.common.Player as MediaPlayer
9
+ import androidx.media3.common.SimpleBasePlayer
10
+ import com.google.common.util.concurrent.Futures
11
+ import com.google.common.util.concurrent.ListenableFuture
12
+ import kotlin.math.roundToInt
13
+ import kotlinx.coroutines.CancellationException
14
+ import kotlinx.coroutines.CoroutineScope
15
+ import kotlinx.coroutines.Job
16
+ import kotlinx.coroutines.delay
17
+ import kotlinx.coroutines.launch
18
+ import timber.log.Timber
19
+
20
+ /**
21
+ * The session's player while remote outputs are on: the local player while none of the remotes has
22
+ * a session, else the receiver of the first that has, carrying the queue, position, play intent,
23
+ * repeat and shuffle across each move.
24
+ * - The phone plays on while the current item is resolved for the receiver ([resolve]).
25
+ * - While remote, this side owns the queue: it shows changes at once, and sends the receiver one
26
+ * item at a time, moving on when the receiver reports the item's end. An edit that leaves the
27
+ * current item in place doesn't reach the receiver. The shuffle mode is kept, but the queue plays
28
+ * in list order (radio-garden/react-native-audio-browser#210).
29
+ * - Moving between remotes, or to a remote's new session, goes straight from receiver to receiver.
30
+ * - A receiver's failure to play is the player error, which [prepare] clears by loading the item
31
+ * again; so is an item the receiver hasn't started within [startTimeoutMs] of being sent or
32
+ * played: holding it ready when paused, playing it when not. [stop] stops the receiver; [prepare]
33
+ * loads the item there again.
34
+ * - [setVolume] is the receiver's device volume while remote.
35
+ */
36
+ internal class RemoteSwitchingPlayer(
37
+ local: MediaPlayer,
38
+ remotes: List<RemotePlayback>,
39
+ private val resolve: suspend (MediaItem) -> MediaItem,
40
+ private val scope: CoroutineScope,
41
+ private val startTimeoutMs: Long = 30_000,
42
+ ) : ForwardingSimpleBasePlayer(local) {
43
+
44
+ var local: MediaPlayer = local
45
+ private set
46
+
47
+ private var remotes: List<RemotePlayback> = emptyList()
48
+ private var route: Route = Route.Local
49
+
50
+ val isRemote: Boolean
51
+ get() = route is Route.Remote
52
+
53
+ private val queue = RemoteQueue()
54
+ private var playIntent = false
55
+ private var repeat = MediaPlayer.REPEAT_MODE_OFF
56
+ private var shuffle = false
57
+
58
+ private sealed interface Route {
59
+ data object Local : Route
60
+
61
+ /** The phone plays on while the current item is resolved for [target]'s receiver. */
62
+ class HandingOver(val target: RemotePlayback, val job: Job) : Route
63
+
64
+ class Remote(val output: RemotePlayback, val receiver: MediaPlayer) : Route {
65
+ var load: Load = Load.Idle(C.TIME_UNSET)
66
+ var startTimeout: Job? = null
67
+
68
+ /** Whether the receiver reported the current item playing since the start timeout armed. */
69
+ var reportedPlaying = false
70
+ }
71
+ }
72
+
73
+ /** Where the receiver is with the current item. */
74
+ private sealed interface Load {
75
+ /**
76
+ * Nothing loaded there: not prepared, stopped, or an empty queue. Prepare loads from
77
+ * [positionMs].
78
+ */
79
+ class Idle(val positionMs: Long) : Load
80
+
81
+ /**
82
+ * The item is resolved for the receiver; until then, the receiver's reports are the last
83
+ * item's.
84
+ */
85
+ class Resolving(val job: Job, val positionMs: Long) : Load
86
+
87
+ /** [item] went to the receiver, which hasn't reported it yet. */
88
+ class Sent(val item: MediaItem, val positionMs: Long) : Load
89
+
90
+ /** The receiver has [item]: what it reports is the current item's. */
91
+ class Playing(val item: MediaItem) : Load
92
+
93
+ class Failed(val error: PlaybackException, val positionMs: Long) : Load
94
+
95
+ /** The last item played to its end, at [positionMs]. */
96
+ class Ended(val positionMs: Long) : Load
97
+ }
98
+
99
+ init {
100
+ setRemotes(remotes)
101
+ }
102
+
103
+ /** Puts [newLocal] in the local player's place, and plays on it unless remote. */
104
+ fun setLocal(newLocal: MediaPlayer) {
105
+ local = newLocal
106
+ if (!isRemote) setPlayer(newLocal)
107
+ }
108
+
109
+ /**
110
+ * Plays on [newRemotes] from now on: a remote that stays keeps its session and what it plays, one
111
+ * that goes is released.
112
+ */
113
+ fun setRemotes(newRemotes: List<RemotePlayback>) {
114
+ val gone = remotes.filter { it !in newRemotes }
115
+ remotes = newRemotes
116
+ for (remote in newRemotes) remote.setListener(listenerFor(remote))
117
+ gone.forEach { it.setListener(null) }
118
+ updateActivePlayer()
119
+ gone.forEach(RemotePlayback::release)
120
+ }
121
+
122
+ private fun listenerFor(remote: RemotePlayback) =
123
+ object : RemotePlayback.Listener {
124
+ override fun onSessionChanged() = updateActivePlayer()
125
+
126
+ override fun onPlaying() {
127
+ if (remote === remoteRoute?.output) onReceiverPlaying()
128
+ }
129
+
130
+ override fun onEnded() {
131
+ if (remote === remoteRoute?.output) onReceiverEnded()
132
+ }
133
+
134
+ override fun onFailed(error: PlaybackException) {
135
+ if (remote === remoteRoute?.output) onReceiverFailed(error)
136
+ }
137
+ }
138
+
139
+ private val remoteRoute: Route.Remote?
140
+ get() = route as? Route.Remote
141
+
142
+ private val receiverListener =
143
+ object : MediaPlayer.Listener {
144
+ override fun onEvents(player: MediaPlayer, events: MediaPlayer.Events) {
145
+ val remote = remoteRoute ?: return
146
+ if (player !== remote.receiver) return
147
+ val changed = followReceiver(remote)
148
+ if (remote.startTimeout != null && started(remote)) disarmStart(remote)
149
+ if (changed) invalidateState()
150
+ }
151
+ }
152
+
153
+ /** Plays on [remote]'s receiver from now on, with [load] where it is with the current item. */
154
+ private fun enter(remote: Route.Remote, load: Load) {
155
+ remote.load = load
156
+ route = remote
157
+ remote.receiver.addListener(receiverListener)
158
+ setPlayer(remote.receiver)
159
+ }
160
+
161
+ /** Lets go of [remote]'s receiver: its load is cut short and the receiver stopped. */
162
+ private fun leave(remote: Route.Remote) {
163
+ cancelLoad(remote)
164
+ remote.receiver.removeListener(receiverListener)
165
+ stopReceiver(remote.receiver)
166
+ }
167
+
168
+ private fun updateActivePlayer() {
169
+ val current = remoteRoute
170
+ if (
171
+ current != null &&
172
+ current.output in remotes &&
173
+ current.output.isSessionAvailable &&
174
+ current.output.player === current.receiver
175
+ ) {
176
+ return
177
+ }
178
+ val next = remotes.firstOrNull { it.isSessionAvailable }
179
+ (route as? Route.HandingOver)?.let {
180
+ if (it.target === next) return
181
+ it.job.cancel()
182
+ route = Route.Local
183
+ }
184
+ when {
185
+ next == null -> if (current != null) handOverToLocal(current)
186
+ current != null -> moveTo(current, next)
187
+ else -> handOverToRemote(next)
188
+ }
189
+ }
190
+
191
+ private fun handOverToRemote(target: RemotePlayback) {
192
+ route =
193
+ Route.HandingOver(
194
+ target,
195
+ scope.launch {
196
+ // The phone plays on, and can move to another item, while the current one resolves.
197
+ var item: MediaItem?
198
+ var resolved: Result<MediaItem>?
199
+ do {
200
+ item = local.currentMediaItem
201
+ resolved = item?.let { resolveCatching(it) }
202
+ } while (item !== local.currentMediaItem)
203
+ becomeRemote(target, resolved)
204
+ },
205
+ )
206
+ }
207
+
208
+ private fun becomeRemote(target: RemotePlayback, resolved: Result<MediaItem>?) {
209
+ val items = local.mediaItems()
210
+ queue.set(items, local.currentMediaItemIndex)
211
+ playIntent = local.playWhenReady
212
+ repeat = local.repeatMode
213
+ shuffle = local.shuffleModeEnabled
214
+ val prepared = local.playbackState != STATE_IDLE && items.isNotEmpty()
215
+ val localPositionMs = local.currentPosition
216
+ val remote = Route.Remote(target, target.player)
217
+ enter(remote, Load.Idle(localPositionMs))
218
+ local.stop()
219
+ local.clearMediaItems()
220
+ if (prepared) {
221
+ resolved
222
+ ?.onSuccess { send(remote, it, if (it.isRemoteLive) C.TIME_UNSET else localPositionMs) }
223
+ ?.onFailure { fail(remote, it, localPositionMs) }
224
+ }
225
+ invalidateState()
226
+ }
227
+
228
+ /** Moves what plays from [from]'s receiver to [to]'s, without the phone in between. */
229
+ private fun moveTo(from: Route.Remote, to: RemotePlayback) {
230
+ val positionMs = positionOn(from)
231
+ val load = from.load
232
+ leave(from)
233
+ val remote = Route.Remote(to, to.player)
234
+ enter(remote, if (load is Load.Failed) load else Load.Idle(positionMs))
235
+ if (load is Load.Resolving || load is Load.Sent || load is Load.Playing)
236
+ load(remote, positionMs)
237
+ invalidateState()
238
+ }
239
+
240
+ private fun handOverToLocal(from: Route.Remote) {
241
+ val positionMs = positionOn(from)
242
+ val prepared = from.load.let { it is Load.Resolving || it is Load.Sent || it is Load.Playing }
243
+ leave(from)
244
+ local.repeatMode = repeat
245
+ local.shuffleModeEnabled = shuffle
246
+ if (queue.isEmpty) local.clearMediaItems()
247
+ else local.setMediaItems(queue.items.toList(), queue.index, positionMs)
248
+ local.playWhenReady = playIntent
249
+ if (prepared && !queue.isEmpty) local.prepare()
250
+ route = Route.Local
251
+ setPlayer(local)
252
+ }
253
+
254
+ /** Where the current item is on [remote]'s receiver, for the next player to go on from. */
255
+ private fun positionOn(remote: Route.Remote): Long =
256
+ when (val load = remote.load) {
257
+ is Load.Idle -> load.positionMs
258
+ is Load.Resolving -> load.positionMs
259
+ is Load.Sent -> load.positionMs
260
+ is Load.Failed -> load.positionMs
261
+ is Load.Playing ->
262
+ if (load.item.isRemoteLive || !receiverHolds(remote, load.item)) C.TIME_UNSET
263
+ else remote.receiver.currentPosition
264
+ is Load.Ended -> C.TIME_UNSET
265
+ }
266
+
267
+ private fun cancelLoad(remote: Route.Remote) {
268
+ (remote.load as? Load.Resolving)?.job?.cancel()
269
+ disarmStart(remote)
270
+ }
271
+
272
+ /**
273
+ * Fails the current item unless [remote]'s receiver has [started] it within the start timeout.
274
+ */
275
+ private fun armStart(remote: Route.Remote) {
276
+ disarmStart(remote)
277
+ remote.reportedPlaying = false
278
+ remote.startTimeout =
279
+ scope.launch {
280
+ delay(startTimeoutMs)
281
+ remote.startTimeout = null
282
+ if (route === remote && !started(remote)) {
283
+ onReceiverFailed(
284
+ PlaybackException(
285
+ "The remote output did not start the item",
286
+ null,
287
+ PlaybackException.ERROR_CODE_REMOTE_ERROR,
288
+ )
289
+ )
290
+ }
291
+ }
292
+ }
293
+
294
+ private fun disarmStart(remote: Route.Remote) {
295
+ remote.startTimeout?.cancel()
296
+ remote.startTimeout = null
297
+ }
298
+
299
+ /** A receiver whose session already ended refuses commands: it stops by itself. */
300
+ private fun stopReceiver(receiver: MediaPlayer) {
301
+ try {
302
+ receiver.stop()
303
+ } catch (e: IllegalStateException) {
304
+ Timber.w(e, "Remote output: could not stop the receiver")
305
+ }
306
+ }
307
+
308
+ /** Loads the current item on [remote]'s receiver from [positionMs], once it is resolved. */
309
+ private fun load(remote: Route.Remote, positionMs: Long) {
310
+ cancelLoad(remote)
311
+ val item = queue.current
312
+ if (item == null) {
313
+ remote.load = Load.Idle(C.TIME_UNSET)
314
+ stopReceiver(remote.receiver)
315
+ return
316
+ }
317
+ remote.load =
318
+ Load.Resolving(
319
+ scope.launch {
320
+ val resolved = resolveCatching(item)
321
+ if (route !== remote) return@launch
322
+ resolved
323
+ .onSuccess { send(remote, it, positionMs) }
324
+ .onFailure { fail(remote, it, positionMs) }
325
+ invalidateState()
326
+ },
327
+ positionMs,
328
+ )
329
+ }
330
+
331
+ private fun send(remote: Route.Remote, item: MediaItem, positionMs: Long) {
332
+ remote.load = Load.Sent(item, positionMs)
333
+ armStart(remote)
334
+ try {
335
+ // Before the load, which autoplays as this says. Told again, a receiver plays what it holds.
336
+ if (remote.receiver.playWhenReady != playIntent) remote.receiver.playWhenReady = playIntent
337
+ remote.receiver.setMediaItem(item, positionMs)
338
+ } catch (e: IllegalStateException) {
339
+ // The session ended under it: the move, already on its way, takes the item along.
340
+ Timber.e(e, "Remote output: could not load the item on the receiver")
341
+ }
342
+ }
343
+
344
+ private fun fail(remote: Route.Remote, cause: Throwable, positionMs: Long) {
345
+ Timber.w(cause, "Remote output: could not resolve the item")
346
+ remote.load =
347
+ Load.Failed(
348
+ PlaybackException(
349
+ "Could not resolve the item for the remote output",
350
+ cause,
351
+ PlaybackException.ERROR_CODE_REMOTE_ERROR,
352
+ ),
353
+ positionMs,
354
+ )
355
+ }
356
+
357
+ private suspend fun resolveCatching(item: MediaItem): Result<MediaItem> =
358
+ try {
359
+ Result.success(resolve(item))
360
+ } catch (e: CancellationException) {
361
+ throw e
362
+ } catch (e: Exception) {
363
+ Result.failure(e)
364
+ }
365
+
366
+ /**
367
+ * Whether [remote]'s receiver holds the item sent and has started it: reported it playing, or
368
+ * holds it ready while paused.
369
+ */
370
+ private fun started(remote: Route.Remote): Boolean {
371
+ val load = remote.load as? Load.Playing ?: return false
372
+ if (!receiverHolds(remote, load.item)) return false
373
+ return when (remote.receiver.playbackState) {
374
+ STATE_ENDED -> true
375
+ STATE_READY -> !playIntent || remote.reportedPlaying
376
+ else -> playIntent && remote.reportedPlaying
377
+ }
378
+ }
379
+
380
+ private fun onReceiverPlaying() {
381
+ val remote = remoteRoute ?: return
382
+ val changed = followReceiver(remote)
383
+ when (remote.load) {
384
+ is Load.Playing -> {
385
+ remote.reportedPlaying = true
386
+ disarmStart(remote)
387
+ }
388
+ // Cast reports the item sent playing before its player shows it, and only once. A receiver
389
+ // still showing the last item reports that one.
390
+ is Load.Sent -> if (remote.receiver.currentMediaItem == null) remote.reportedPlaying = true
391
+ else -> Unit
392
+ }
393
+ if (changed) invalidateState()
394
+ }
395
+
396
+ private fun onReceiverEnded() {
397
+ val remote = remoteRoute ?: return
398
+ followReceiver(remote)
399
+ // An end reported before the receiver holds the item sent is the last item's.
400
+ if (remote.load !is Load.Playing) return
401
+ val next = queue.nextAtEnd(repeat)
402
+ if (next == C.INDEX_UNSET) {
403
+ val duration = remote.receiver.duration
404
+ remote.load = Load.Ended(if (duration == C.TIME_UNSET) positionOn(remote) else duration)
405
+ } else {
406
+ queue.moveTo(next)
407
+ load(remote, C.TIME_UNSET)
408
+ }
409
+ invalidateState()
410
+ }
411
+
412
+ private fun onReceiverFailed(error: PlaybackException) {
413
+ val remote = remoteRoute ?: return
414
+ val load = remote.load
415
+ if (load !is Load.Playing && load !is Load.Sent) return
416
+ Timber.w(error, "Remote output: the receiver failed to play")
417
+ // One code for every remote failure: the local engine's recoveries key on the others.
418
+ val remoteError =
419
+ if (error.errorCode == PlaybackException.ERROR_CODE_REMOTE_ERROR) error
420
+ else PlaybackException(error.message, error, PlaybackException.ERROR_CODE_REMOTE_ERROR)
421
+ val positionMs = positionOn(remote)
422
+ cancelLoad(remote)
423
+ remote.load = Load.Failed(remoteError, positionMs)
424
+ invalidateState()
425
+ }
426
+
427
+ /** Whether [remote]'s receiver reports [item] as its own. */
428
+ private fun receiverHolds(remote: Route.Remote, item: MediaItem) =
429
+ remote.receiver.currentMediaItem === item
430
+
431
+ override fun getState(): State {
432
+ val state = super.getState()
433
+ val remote = remoteRoute ?: return state
434
+ val load = remote.load
435
+ val holds = load is Load.Playing && receiverHolds(remote, load.item)
436
+ // Duration, seekability and liveness come from the receiver's data for the item it plays.
437
+ val playing = state.playlist.getOrNull(state.currentMediaItemIndex).takeIf { holds }
438
+ val playlist =
439
+ queue.items.indices.map { i ->
440
+ val data =
441
+ if (i == queue.index && playing != null) playing.buildUpon().setUid(queue.uids[i])
442
+ else MediaItemData.Builder(queue.uids[i])
443
+ data.setMediaItem(queue.items[i]).build()
444
+ }
445
+ val maxVolume = state.deviceInfo.maxVolume
446
+ return state
447
+ .buildUpon()
448
+ .setPlaylist(playlist)
449
+ .setCurrentMediaItemIndex(queue.index)
450
+ .setRepeatMode(repeat)
451
+ .setShuffleModeEnabled(shuffle)
452
+ .setVolume(if (maxVolume > 0) state.deviceVolume.toFloat() / maxVolume else 0f)
453
+ .setAvailableCommands(state.availableCommands.buildUpon().addAll(*QUEUE_COMMANDS).build())
454
+ .setPlayerError(null)
455
+ .apply {
456
+ if (!holds) setPlayWhenReady(playIntent, PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST)
457
+ when (load) {
458
+ is Load.Idle ->
459
+ setPlaybackState(STATE_IDLE).setContentPositionMs(position(load.positionMs))
460
+ is Load.Resolving ->
461
+ setPlaybackState(STATE_BUFFERING).setContentPositionMs(position(load.positionMs))
462
+ is Load.Sent ->
463
+ setPlaybackState(STATE_BUFFERING).setContentPositionMs(position(load.positionMs))
464
+ is Load.Failed ->
465
+ setPlayerError(load.error)
466
+ .setPlaybackState(STATE_IDLE)
467
+ .setContentPositionMs(position(load.positionMs))
468
+ is Load.Ended ->
469
+ setPlaybackState(STATE_ENDED).setContentPositionMs(position(load.positionMs))
470
+ is Load.Playing -> if (!holds) setPlaybackState(STATE_IDLE).setContentPositionMs(0)
471
+ }
472
+ if (queue.isEmpty) setPlaybackState(STATE_IDLE)
473
+ }
474
+ .build()
475
+ }
476
+
477
+ private fun position(positionMs: Long) = if (positionMs == C.TIME_UNSET) 0 else positionMs
478
+
479
+ /**
480
+ * Catches up with the receiver: the item arriving there, or a pause or play from elsewhere.
481
+ * Returns whether anything changed.
482
+ */
483
+ private fun followReceiver(remote: Route.Remote): Boolean {
484
+ when (val load = remote.load) {
485
+ is Load.Sent ->
486
+ if (receiverHolds(remote, load.item)) {
487
+ remote.load = Load.Playing(load.item)
488
+ playIntent = remote.receiver.playWhenReady
489
+ if (remote.reportedPlaying) disarmStart(remote)
490
+ return true
491
+ }
492
+ is Load.Playing ->
493
+ if (receiverHolds(remote, load.item) && playIntent != remote.receiver.playWhenReady) {
494
+ playIntent = remote.receiver.playWhenReady
495
+ return true
496
+ }
497
+ else -> Unit
498
+ }
499
+ return false
500
+ }
501
+
502
+ override fun handleSetPlayWhenReady(playWhenReady: Boolean): ListenableFuture<*> {
503
+ val remote = remoteRoute ?: return super.handleSetPlayWhenReady(playWhenReady)
504
+ val resumes = playWhenReady && !playIntent
505
+ playIntent = playWhenReady
506
+ // A receiver that played on after failing still hears a pause; one still holding the last
507
+ // item while the next resolves is not told to play it.
508
+ if (!playWhenReady || remote.load !is Load.Resolving)
509
+ remote.receiver.playWhenReady = playWhenReady
510
+ if (remote.load is Load.Playing) {
511
+ if (resumes) armStart(remote) else if (!playWhenReady) disarmStart(remote)
512
+ }
513
+ return done()
514
+ }
515
+
516
+ override fun handlePrepare(): ListenableFuture<*> {
517
+ val remote = remoteRoute ?: return super.handlePrepare()
518
+ when (val load = remote.load) {
519
+ is Load.Idle -> load(remote, load.positionMs)
520
+ is Load.Failed -> load(remote, load.positionMs)
521
+ is Load.Playing -> if (!receiverHolds(remote, load.item)) load(remote, C.TIME_UNSET)
522
+ else -> Unit
523
+ }
524
+ return done()
525
+ }
526
+
527
+ override fun handleStop(): ListenableFuture<*> {
528
+ val remote = remoteRoute ?: return super.handleStop()
529
+ val positionMs = positionOn(remote)
530
+ cancelLoad(remote)
531
+ stopReceiver(remote.receiver)
532
+ remote.load = Load.Idle(positionMs)
533
+ return done()
534
+ }
535
+
536
+ override fun handleSetRepeatMode(repeatMode: Int): ListenableFuture<*> {
537
+ if (!isRemote) return super.handleSetRepeatMode(repeatMode)
538
+ repeat = repeatMode
539
+ return done()
540
+ }
541
+
542
+ override fun handleSetShuffleModeEnabled(shuffleModeEnabled: Boolean): ListenableFuture<*> {
543
+ if (!isRemote) return super.handleSetShuffleModeEnabled(shuffleModeEnabled)
544
+ shuffle = shuffleModeEnabled
545
+ return done()
546
+ }
547
+
548
+ override fun handleSetVolume(volume: Float, volumeOperationType: Int): ListenableFuture<*> {
549
+ val remote = remoteRoute ?: return super.handleSetVolume(volume, volumeOperationType)
550
+ val maxVolume = remote.receiver.deviceInfo.maxVolume
551
+ remote.receiver.setDeviceVolume((volume * maxVolume).roundToInt(), 0)
552
+ return done()
553
+ }
554
+
555
+ override fun handleSetMediaItems(
556
+ mediaItems: List<MediaItem>,
557
+ startIndex: Int,
558
+ startPositionMs: Long,
559
+ ): ListenableFuture<*> {
560
+ val remote =
561
+ remoteRoute ?: return super.handleSetMediaItems(mediaItems, startIndex, startPositionMs)
562
+ queue.set(mediaItems, if (startIndex == C.INDEX_UNSET) 0 else startIndex)
563
+ reloadCurrent(remote, startPositionMs)
564
+ return done()
565
+ }
566
+
567
+ override fun handleAddMediaItems(index: Int, mediaItems: List<MediaItem>): ListenableFuture<*> {
568
+ val remote = remoteRoute ?: return super.handleAddMediaItems(index, mediaItems)
569
+ val wasEmpty = queue.isEmpty
570
+ queue.add(index, mediaItems)
571
+ if (wasEmpty) reloadCurrent(remote, C.TIME_UNSET)
572
+ return done()
573
+ }
574
+
575
+ override fun handleReplaceMediaItems(
576
+ fromIndex: Int,
577
+ toIndex: Int,
578
+ mediaItems: List<MediaItem>,
579
+ ): ListenableFuture<*> {
580
+ val remote = remoteRoute ?: return super.handleReplaceMediaItems(fromIndex, toIndex, mediaItems)
581
+ if (queue.replace(fromIndex, toIndex, mediaItems)) reloadCurrent(remote, C.TIME_UNSET)
582
+ return done()
583
+ }
584
+
585
+ override fun handleRemoveMediaItems(fromIndex: Int, toIndex: Int): ListenableFuture<*> {
586
+ val remote = remoteRoute ?: return super.handleRemoveMediaItems(fromIndex, toIndex)
587
+ if (!queue.remove(fromIndex, toIndex)) return done()
588
+ // As the local player does: the current item gone with nothing after it, playback ends there,
589
+ // unless the queue repeats.
590
+ val nothingAfter = fromIndex >= queue.items.size && !queue.isEmpty
591
+ val playing = remote.load !is Load.Idle && remote.load !is Load.Failed
592
+ when {
593
+ nothingAfter && repeat == REPEAT_MODE_ALL -> queue.moveTo(0)
594
+ nothingAfter && playing -> {
595
+ cancelLoad(remote)
596
+ stopReceiver(remote.receiver)
597
+ remote.load = Load.Ended(0)
598
+ return done()
599
+ }
600
+ }
601
+ reloadCurrent(remote, C.TIME_UNSET)
602
+ return done()
603
+ }
604
+
605
+ override fun handleMoveMediaItems(
606
+ fromIndex: Int,
607
+ toIndex: Int,
608
+ newIndex: Int,
609
+ ): ListenableFuture<*> {
610
+ if (!isRemote) return super.handleMoveMediaItems(fromIndex, toIndex, newIndex)
611
+ queue.move(fromIndex, toIndex, newIndex)
612
+ return done()
613
+ }
614
+
615
+ override fun handleSeek(
616
+ mediaItemIndex: Int,
617
+ positionMs: Long,
618
+ seekCommand: Int,
619
+ ): ListenableFuture<*> {
620
+ val remote = remoteRoute ?: return super.handleSeek(mediaItemIndex, positionMs, seekCommand)
621
+ val target = if (mediaItemIndex == C.INDEX_UNSET) queue.index else mediaItemIndex
622
+ if (target !in queue.items.indices) return done()
623
+ val load = remote.load
624
+ if (
625
+ target == queue.index &&
626
+ positionMs != C.TIME_UNSET &&
627
+ load is Load.Playing &&
628
+ receiverHolds(remote, load.item)
629
+ ) {
630
+ remote.receiver.seekTo(positionMs)
631
+ } else {
632
+ queue.moveTo(target)
633
+ reloadCurrent(remote, positionMs)
634
+ }
635
+ return done()
636
+ }
637
+
638
+ /**
639
+ * Loads the current item again from [positionMs] if the receiver is to play it; else keeps the
640
+ * position for the next prepare.
641
+ */
642
+ private fun reloadCurrent(remote: Route.Remote, positionMs: Long) {
643
+ when (val load = remote.load) {
644
+ is Load.Idle -> remote.load = Load.Idle(positionMs)
645
+ is Load.Failed -> remote.load = Load.Failed(load.error, positionMs)
646
+ else -> load(remote, positionMs)
647
+ }
648
+ }
649
+
650
+ /**
651
+ * Brings playback back to the local player if remote, and lets go of the remotes. The local
652
+ * player stays with its owner, unreleased.
653
+ */
654
+ override fun handleRelease(): ListenableFuture<*> {
655
+ (route as? Route.HandingOver)?.job?.cancel()
656
+ if (route is Route.HandingOver) route = Route.Local
657
+ remotes.forEach { it.setListener(null) }
658
+ remoteRoute?.let(::handOverToLocal)
659
+ remotes.forEach(RemotePlayback::release)
660
+ setPlayer(ReleasedPlayer(applicationLooper))
661
+ return done()
662
+ }
663
+
664
+ private fun done() = Futures.immediateVoidFuture()
665
+
666
+ private companion object {
667
+ // Available from the queue this side keeps, whatever the receiver's own.
668
+ val QUEUE_COMMANDS =
669
+ intArrayOf(
670
+ MediaPlayer.COMMAND_PLAY_PAUSE,
671
+ MediaPlayer.COMMAND_PREPARE,
672
+ MediaPlayer.COMMAND_STOP,
673
+ MediaPlayer.COMMAND_SEEK_TO_DEFAULT_POSITION,
674
+ MediaPlayer.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM,
675
+ MediaPlayer.COMMAND_SEEK_TO_PREVIOUS,
676
+ MediaPlayer.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM,
677
+ MediaPlayer.COMMAND_SEEK_TO_NEXT,
678
+ MediaPlayer.COMMAND_SEEK_TO_MEDIA_ITEM,
679
+ MediaPlayer.COMMAND_SET_MEDIA_ITEM,
680
+ MediaPlayer.COMMAND_CHANGE_MEDIA_ITEMS,
681
+ MediaPlayer.COMMAND_GET_TIMELINE,
682
+ MediaPlayer.COMMAND_GET_CURRENT_MEDIA_ITEM,
683
+ MediaPlayer.COMMAND_SET_REPEAT_MODE,
684
+ MediaPlayer.COMMAND_SET_SHUFFLE_MODE,
685
+ MediaPlayer.COMMAND_GET_VOLUME,
686
+ MediaPlayer.COMMAND_SET_VOLUME,
687
+ )
688
+ }
689
+
690
+ /** Stands in once released, so this player stops listening to the local one. */
691
+ private class ReleasedPlayer(looper: Looper) : SimpleBasePlayer(looper) {
692
+ override fun getState(): State = State.Builder().build()
693
+ }
694
+
695
+ private fun MediaPlayer.mediaItems() = (0 until mediaItemCount).map(::getMediaItemAt)
696
+ }