react-native-audio-browser 0.2.0-next.50 → 0.2.0-next.52
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/build.gradle +15 -0
- package/android/src/cast/java/com/audiobrowser/cast/CastSupport.kt +215 -0
- package/android/src/main/AndroidManifest.xml +11 -0
- package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +0 -4
- package/android/src/main/java/com/audiobrowser/RemoteOutputs.kt +47 -10
- package/android/src/main/java/com/audiobrowser/model/PlayerSetupOptions.kt +12 -3
- package/android/src/main/java/com/audiobrowser/player/EqualizerController.kt +4 -1
- package/android/src/main/java/com/audiobrowser/player/LocalEngine.kt +49 -0
- package/android/src/main/java/com/audiobrowser/player/Player.kt +170 -119
- package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +18 -13
- package/android/src/main/java/com/audiobrowser/player/TransformingDataSource.kt +10 -13
- package/android/src/main/java/com/audiobrowser/remote/RemoteItem.kt +64 -0
- package/android/src/main/java/com/audiobrowser/remote/RemoteOutputsController.kt +98 -0
- package/android/src/main/java/com/audiobrowser/remote/RemotePlayback.kt +42 -0
- package/android/src/main/java/com/audiobrowser/remote/RemoteQueue.kt +110 -0
- package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +696 -0
- package/android/src/main/java/com/audiobrowser/sonos/DeviceDescriptionParser.kt +113 -0
- package/android/src/main/java/com/audiobrowser/sonos/DidlLite.kt +39 -0
- package/android/src/main/java/com/audiobrowser/sonos/SoapClient.kt +59 -0
- package/android/src/main/java/com/audiobrowser/sonos/SoapEnvelopes.kt +92 -0
- package/android/src/main/java/com/audiobrowser/sonos/SoapResponseParser.kt +105 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosDiscoverer.kt +69 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosOutputs.kt +128 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosPlayer.kt +550 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosRemote.kt +99 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosRouteProviderService.kt +201 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosStreamUri.kt +15 -0
- package/android/src/main/java/com/audiobrowser/sonos/SonosTransport.kt +66 -0
- package/android/src/main/java/com/audiobrowser/sonos/SpeakerXml.kt +26 -0
- package/android/src/main/java/com/audiobrowser/sonos/SsdpDiscovery.kt +63 -0
- package/android/src/main/java/com/audiobrowser/sonos/SsdpMessages.kt +63 -0
- package/android/src/main/java/com/audiobrowser/sonos/ZoneGroupState.kt +68 -0
- package/android/src/main/java/com/audiobrowser/util/OutputMonitor.kt +2 -1
- package/android/src/main/java/com/audiobrowser/util/TrackFactory.kt +1 -1
- package/android/src/nocast/java/com/audiobrowser/cast/CastSupport.kt +18 -0
- package/android/src/test/java/com/audiobrowser/RemoteOutputsTest.kt +20 -3
- package/android/src/test/java/com/audiobrowser/model/PlayerSetupOptionsTest.kt +35 -0
- package/android/src/test/java/com/audiobrowser/player/EqualizerControllerTest.kt +12 -0
- package/android/src/test/java/com/audiobrowser/player/PlayerCastTest.kt +136 -0
- package/android/src/test/java/com/audiobrowser/player/PlayerSonosTest.kt +213 -0
- package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +275 -0
- package/android/src/test/java/com/audiobrowser/remote/RemoteItemTest.kt +61 -0
- package/android/src/test/java/com/audiobrowser/remote/RemoteOutputsControllerTest.kt +77 -0
- package/android/src/test/java/com/audiobrowser/remote/RemoteQueueTest.kt +101 -0
- package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +815 -0
- package/android/src/test/java/com/audiobrowser/sonos/DeviceDescriptionParserTest.kt +203 -0
- package/android/src/test/java/com/audiobrowser/sonos/DidlLiteTest.kt +90 -0
- package/android/src/test/java/com/audiobrowser/sonos/SoapClientTest.kt +73 -0
- package/android/src/test/java/com/audiobrowser/sonos/SoapEnvelopesTest.kt +135 -0
- package/android/src/test/java/com/audiobrowser/sonos/SoapResponseParserTest.kt +170 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosDiscovererTest.kt +174 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosPlayerTest.kt +691 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosRemoteTest.kt +129 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosRoutesTest.kt +165 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosStreamUriTest.kt +64 -0
- package/android/src/test/java/com/audiobrowser/sonos/SonosTransportTest.kt +204 -0
- package/android/src/test/java/com/audiobrowser/sonos/SsdpMessagesTest.kt +99 -0
- package/android/src/test/java/com/audiobrowser/sonos/ZoneGroupStateTest.kt +139 -0
- package/android/src/test/java/com/audiobrowser/util/OutputMonitorTest.kt +12 -10
- package/android/src/test/resources/sonos/device_description.xml +78 -0
- package/android/src/testCast/java/com/audiobrowser/cast/CastEndsTest.kt +56 -0
- package/android/src/testCast/java/com/audiobrowser/cast/SendingMediaItemConverterTest.kt +79 -0
- package/lib/commonjs/features/player/setup.js +2 -0
- package/lib/commonjs/features/player/setup.js.map +1 -1
- package/lib/module/features/player/setup.js +2 -0
- package/lib/module/features/player/setup.js.map +1 -1
- package/lib/typescript/src/features/player/setup.d.ts +37 -7
- package/lib/typescript/src/features/player/setup.d.ts.map +1 -1
- package/lib/typescript/src/specs/audio-browser.nitro.d.ts +3 -3
- package/lib/typescript/src/specs/audio-browser.nitro.d.ts.map +1 -1
- package/nitrogen/generated/android/c++/JHybridAudioBrowserSpec.cpp +4 -0
- package/nitrogen/generated/android/c++/JNativeSetupPlayerOptions.hpp +7 -5
- package/nitrogen/generated/android/c++/JOutputType.hpp +3 -0
- package/nitrogen/generated/android/c++/JRemoteOutputsOptions.hpp +66 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/NativeSetupPlayerOptions.kt +3 -3
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/OutputType.kt +3 -2
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/RemoteOutputsOptions.kt +61 -0
- package/nitrogen/generated/ios/AudioBrowser-Swift-Cxx-Bridge.hpp +18 -0
- package/nitrogen/generated/ios/AudioBrowser-Swift-Cxx-Umbrella.hpp +3 -0
- package/nitrogen/generated/ios/c++/HybridAudioBrowserSpecSwift.hpp +3 -0
- package/nitrogen/generated/ios/swift/NativeSetupPlayerOptions.swift +5 -12
- package/nitrogen/generated/ios/swift/OutputType.swift +4 -0
- package/nitrogen/generated/ios/swift/RemoteOutputsOptions.swift +78 -0
- package/nitrogen/generated/shared/c++/NativeSetupPlayerOptions.hpp +8 -5
- package/nitrogen/generated/shared/c++/OutputType.hpp +6 -2
- package/nitrogen/generated/shared/c++/RemoteOutputsOptions.hpp +92 -0
- package/package.json +3 -2
- package/src/features/player/setup.ts +38 -7
- package/src/specs/audio-browser.nitro.ts +4 -3
- package/website/guide/audio-output.md +185 -4
- 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
|
+
}
|