PlaybackService.kt
Each line, with the release that last changed it.
| 0.5.0 | 1 | package dev.stave.playback |
| 2 | ||
| 3 | import android.app.PendingIntent | |
| 4 | import android.content.Context | |
| 5 | import android.content.Intent | |
| 6 | import android.net.Uri | |
| 7 | import android.os.Build | |
| 8 | import android.os.Bundle | |
| 9 | import androidx.annotation.OptIn | |
| 10 | import androidx.media3.common.AudioAttributes | |
| 11 | import androidx.media3.common.C | |
| 12 | import androidx.media3.common.ForwardingPlayer | |
| 13 | import androidx.media3.common.MediaItem | |
| 14 | import androidx.media3.common.MediaMetadata | |
| 15 | import androidx.media3.common.Player | |
| 16 | import androidx.media3.common.util.UnstableApi | |
| 17 | import androidx.media3.datasource.DefaultDataSource | |
| 18 | import androidx.media3.datasource.okhttp.OkHttpDataSource | |
| 19 | import androidx.media3.exoplayer.ExoPlayer | |
| 20 | import androidx.media3.exoplayer.source.DefaultMediaSourceFactory | |
| 21 | import androidx.media3.session.CommandButton | |
| 22 | import androidx.media3.session.DefaultMediaNotificationProvider | |
| 23 | import androidx.media3.session.LibraryResult | |
| 24 | import androidx.media3.session.MediaLibraryService | |
| 25 | import androidx.media3.session.MediaSession | |
| 26 | import androidx.media3.session.SessionCommand | |
| 27 | import androidx.media3.session.SessionCommands | |
| 28 | import androidx.media3.session.SessionResult | |
| 29 | import com.google.common.collect.ImmutableList | |
| 30 | import com.google.common.util.concurrent.Futures | |
| 31 | import com.google.common.util.concurrent.ListenableFuture | |
| 32 | import com.google.common.util.concurrent.MoreExecutors | |
| 33 | import com.google.common.util.concurrent.SettableFuture | |
| 34 | import dagger.hilt.EntryPoint | |
| 35 | import dagger.hilt.InstallIn | |
| 36 | import dagger.hilt.android.EntryPointAccessors | |
| 37 | import dagger.hilt.components.SingletonComponent | |
| 38 | import dev.stave.R | |
| 39 | import dev.stave.data.SettingsStore | |
| 40 | import dev.stave.data.toDomain | |
| 41 | import dev.stave.domain.model.DidlItem | |
| 42 | import dev.stave.upnp.BrowseResult | |
| 43 | import dev.stave.upnp.ContentDirectoryClient | |
| 44 | import dev.stave.upnp.UpnpServiceHolder | |
| 45 | import kotlinx.coroutines.CoroutineScope | |
| 46 | import kotlinx.coroutines.Dispatchers | |
| 47 | import kotlinx.coroutines.SupervisorJob | |
| 48 | import kotlinx.coroutines.async | |
| 49 | import kotlinx.coroutines.coroutineScope | |
| 50 | import kotlinx.coroutines.flow.distinctUntilChanged | |
| 51 | import kotlinx.coroutines.flow.first | |
| 52 | import kotlinx.coroutines.flow.map | |
| 53 | import kotlinx.coroutines.launch | |
| 54 | import kotlinx.coroutines.withContext | |
| 55 | import okhttp3.OkHttpClient | |
| 56 | import java.util.concurrent.TimeUnit | |
| 57 | ||
| 58 | /** | |
| 59 | * Holds the ExoPlayer and a MediaLibrarySession. Extends [MediaLibraryService] | |
| 60 | * (which IS a MediaSessionService) so that: | |
| 61 | * | |
| 62 | * 1. The TV launcher and notification get the same transport buttons as before. | |
| 63 | * 2. Android Auto can browse the UPnP library tree and play tracks by | |
| 64 | * discovering this service through the manifest's media-browser intent filter. | |
| 65 | * | |
| 66 | * The browse callback bridges the UPnP ContentDirectory (via [ContentDirectoryClient]) | |
| 67 | * to the MediaItem tree that Auto's built-in media UI expects. Each container | |
| 68 | * becomes a browsable MediaItem; each track becomes a playable MediaItem whose | |
| 69 | * mediaId holds the UPnP object ID and whose requestMetadata holds the HTTP URL | |
| 70 | * for playback. | |
| 71 | * | |
| 72 | * Android Auto integration notes: | |
| 73 | * - When no server is preferred, the browse tree shows available servers as top-level | |
| 74 | * items. Selecting one sets it as preferred and refreshes the tree. | |
| 75 | * - onSearch delegates to the UPnP ContentDirectory's Search action. | |
| 76 | * - The service starts UPnP discovery independently of the Activity so Auto can | |
| 77 | * browse even when the TV UI isn't running. | |
| 78 | */ | |
| 79 | /** Notification id for the casting keep-alive foreground notification. | |
| 80 | * Top-level (not in the class companion) because PlaybackService's | |
| 81 | * companion object holds the nav/CMD constants referenced app-wide — | |
| 82 | * a second companion is illegal and broke every one of those refs. */ | |
| 83 | private const val CASTING_NOTIFICATION_ID = 41042 | |
| 84 | ||
| 85 | /** Notification id for the OBSERVING keep-alive foreground notification — | |
| 86 | * raw-cast follow mode. Distinct from the casting id so transitions between | |
| 87 | * the two modes replace rather than leak notifications. */ | |
| 88 | private const val OBSERVING_NOTIFICATION_ID = 41043 | |
| 89 | ||
| 90 | class PlaybackService : MediaLibraryService() { | |
| 91 | ||
| 92 | private var player: ExoPlayer? = null | |
| 93 | ||
| 94 | // ── Casting keep-alive state ────────────────────────────────────── | |
| 95 | private var castingWifiLock: android.net.wifi.WifiManager.WifiLock? = null | |
| 96 | private var castingWakeLock: android.os.PowerManager.WakeLock? = null | |
| 97 | ||
| 98 | private fun enterCastingKeepAlive() { | |
| 99 | // Foreground promotion — a minimal, silent, low-priority | |
| 100 | // notification. Media3 isn't providing one because the local | |
| 101 | // player is paused during cast. | |
| 102 | val channelId = "earhorn_casting" | |
| 103 | val nm = getSystemService(android.app.NotificationManager::class.java) | |
| 104 | if (android.os.Build.VERSION.SDK_INT >= 26 && | |
| 105 | nm.getNotificationChannel(channelId) == null | |
| 106 | ) { | |
| 107 | nm.createNotificationChannel( | |
| 108 | android.app.NotificationChannel( | |
| 109 | channelId, "Casting", | |
| 110 | android.app.NotificationManager.IMPORTANCE_LOW, | |
| 111 | ).apply { setShowBadge(false) } | |
| 112 | ) | |
| 113 | } | |
| 114 | val notif = if (android.os.Build.VERSION.SDK_INT >= 26) { | |
| 115 | android.app.Notification.Builder(this, channelId) | |
| 116 | .setSmallIcon(R.drawable.ic_notif_cast_connected) | |
| 117 | .setContentTitle("Casting") | |
| 118 | .setContentText("Keeping the stream alive for your speakers") | |
| 119 | .setOngoing(true) | |
| 120 | .build() | |
| 121 | } else { | |
| 122 | @Suppress("DEPRECATION") | |
| 123 | android.app.Notification.Builder(this) | |
| 124 | .setSmallIcon(R.drawable.ic_notif_cast_connected) | |
| 125 | .setContentTitle("Casting") | |
| 126 | .setContentText("Keeping the stream alive for your speakers") | |
| 127 | .setOngoing(true) | |
| 128 | .setPriority(android.app.Notification.PRIORITY_LOW) | |
| 129 | .build() | |
| 130 | } | |
| 131 | runCatching { | |
| 132 | if (android.os.Build.VERSION.SDK_INT >= 29) { | |
| 133 | startForeground( | |
| 134 | CASTING_NOTIFICATION_ID, notif, | |
| 135 | android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, | |
| 136 | ) | |
| 137 | } else { | |
| 138 | startForeground(CASTING_NOTIFICATION_ID, notif) | |
| 139 | } | |
| 140 | } | |
| 141 | ||
| 142 | // Network + CPU locks: the proxy must keep serving bytes with the | |
| 143 | // screen off and Wi-Fi power-saving active. | |
| 144 | if (castingWifiLock == null) { | |
| 145 | val wm = applicationContext.getSystemService(android.net.wifi.WifiManager::class.java) | |
| 146 | castingWifiLock = wm?.createWifiLock( | |
| 147 | android.net.wifi.WifiManager.WIFI_MODE_FULL_HIGH_PERF, "earhorn:castProxy", | |
| 148 | ) | |
| 149 | } | |
| 150 | if (castingWakeLock == null) { | |
| 151 | val pm = getSystemService(android.os.PowerManager::class.java) | |
| 152 | castingWakeLock = pm?.newWakeLock( | |
| 153 | android.os.PowerManager.PARTIAL_WAKE_LOCK, "earhorn:castProxy", | |
| 154 | ) | |
| 155 | } | |
| 156 | runCatching { if (castingWifiLock?.isHeld != true) castingWifiLock?.acquire() } | |
| 157 | runCatching { if (castingWakeLock?.isHeld != true) castingWakeLock?.acquire() } | |
| 158 | } | |
| 159 | ||
| 160 | private fun exitCastingKeepAlive() { | |
| 161 | runCatching { if (castingWifiLock?.isHeld == true) castingWifiLock?.release() } | |
| 162 | runCatching { if (castingWakeLock?.isHeld == true) castingWakeLock?.release() } | |
| 163 | // Drop our foreground claim only if local playback isn't running — | |
| 164 | // if the session handed back to local play, Media3's own media | |
| 165 | // notification takes over foreground duty. Same courtesy for | |
| 166 | // observing: if the user hopped from casting to following, the | |
| 167 | // observing keep-alive now owns foreground and we must not yank it. | |
| 168 | val locallyPlaying = runCatching { player?.isPlaying == true }.getOrDefault(false) | |
| 169 | val observing = runCatching { rawCast.observing.value }.getOrDefault(false) | |
| 170 | if (!locallyPlaying && !observing) { | |
| 171 | runCatching { stopForeground(STOP_FOREGROUND_REMOVE) } | |
| 172 | } | |
| 173 | } | |
| 174 | ||
| 175 | // ── Observing keep-alive ────────────────────────────────────────── | |
| 176 | // Raw-cast follow mode ("observer mode") holds a TLS socket to the CCA | |
| 177 | // and nothing else — the local player is idle, so Media3 provides no | |
| 178 | // foreground notification, and on Android 12+ the cached-app freezer | |
| 179 | // freezes the process the moment the user leaves the app. Frozen | |
| 180 | // process = dead socket = observer mode silently gone when the user | |
| 181 | // comes back, with the stale local queue still on screen (the exact | |
| 182 | // confusing UX reported from the field). Mirror of the casting | |
| 183 | // keep-alive: foreground promotion + Wi-Fi lock while observing. No | |
| 184 | // wake lock — unlike casting we serve no audio bytes, so if the CPU | |
| 185 | // dozes off the observer's own reconnect supervisor and the persisted | |
| 186 | // reattach path recover state on wake instead of burning battery | |
| 187 | // holding the CPU up all night. | |
| 188 | private var observingWifiLock: android.net.wifi.WifiManager.WifiLock? = null | |
| 189 | ||
| 190 | private fun buildObservingNotification( | |
| 191 | deviceName: String?, | |
| 192 | trackLine: String?, | |
| 193 | ): android.app.Notification { | |
| 194 | val channelId = "earhorn_observing" | |
| 195 | val nm = getSystemService(android.app.NotificationManager::class.java) | |
| 196 | if (android.os.Build.VERSION.SDK_INT >= 26 && | |
| 197 | nm.getNotificationChannel(channelId) == null | |
| 198 | ) { | |
| 199 | nm.createNotificationChannel( | |
| 200 | android.app.NotificationChannel( | |
| 201 | channelId, "Following a Cast session", | |
| 202 | android.app.NotificationManager.IMPORTANCE_LOW, | |
| 203 | ).apply { setShowBadge(false) } | |
| 204 | ) | |
| 205 | } | |
| 206 | val title = deviceName?.let { "Following $it" } ?: "Following Cast playback" | |
| 207 | val text = trackLine ?: "Keeping the connection alive" | |
| 208 | // Tap → open the app on Now Playing. The launcher activity restores | |
| 209 | // where the user was; with observing alive the NowPlaying screen | |
| 210 | // renders the observed session, which is where a notification tap | |
| 211 | // should land. | |
| 212 | val contentIntent = packageManager.getLaunchIntentForPackage(packageName)?.let { | |
| 213 | android.app.PendingIntent.getActivity( | |
| 214 | this, 0, it, | |
| 215 | android.app.PendingIntent.FLAG_UPDATE_CURRENT or | |
| 216 | android.app.PendingIntent.FLAG_IMMUTABLE, | |
| 217 | ) | |
| 218 | } | |
| 219 | return if (android.os.Build.VERSION.SDK_INT >= 26) { | |
| 220 | android.app.Notification.Builder(this, channelId) | |
| 221 | .setSmallIcon(R.drawable.ic_notif_cast_connected) | |
| 222 | .setContentTitle(title) | |
| 223 | .setContentText(text) | |
| 224 | .setOngoing(true) | |
| 225 | .apply { contentIntent?.let { setContentIntent(it) } } | |
| 226 | .build() | |
| 227 | } else { | |
| 228 | @Suppress("DEPRECATION") | |
| 229 | android.app.Notification.Builder(this) | |
| 230 | .setSmallIcon(R.drawable.ic_notif_cast_connected) | |
| 231 | .setContentTitle(title) | |
| 232 | .setContentText(text) | |
| 233 | .setOngoing(true) | |
| 234 | .setPriority(android.app.Notification.PRIORITY_LOW) | |
| 235 | .apply { contentIntent?.let { setContentIntent(it) } } | |
| 236 | .build() | |
| 237 | } | |
| 238 | } | |
| 239 | ||
| 240 | private fun enterObservingKeepAlive() { | |
| 241 | val notif = buildObservingNotification( | |
| 242 | deviceName = runCatching { rawCast.connectedDeviceName.value }.getOrNull(), | |
| 243 | trackLine = null, | |
| 244 | ) | |
| 245 | runCatching { | |
| 246 | if (android.os.Build.VERSION.SDK_INT >= 29) { | |
| 247 | startForeground( | |
| 248 | OBSERVING_NOTIFICATION_ID, notif, | |
| 249 | android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, | |
| 250 | ) | |
| 251 | } else { | |
| 252 | startForeground(OBSERVING_NOTIFICATION_ID, notif) | |
| 253 | } | |
| 254 | } | |
| 255 | if (observingWifiLock == null) { | |
| 256 | val wm = applicationContext.getSystemService(android.net.wifi.WifiManager::class.java) | |
| 257 | // WIFI_MODE_FULL keeps the connection up exactly as before; it | |
| 258 | // stops forbidding the chip's own power saving on every wall | |
| 259 | // screen all day (I.21, design decision 2026-09-02). | |
| 260 | observingWifiLock = wm?.createWifiLock( | |
| 261 | android.net.wifi.WifiManager.WIFI_MODE_FULL, "earhorn:observe", | |
| 262 | ) | |
| 263 | } | |
| 264 | runCatching { if (observingWifiLock?.isHeld != true) observingWifiLock?.acquire() } | |
| 265 | } | |
| 266 | ||
| 267 | private fun exitObservingKeepAlive() { | |
| 268 | runCatching { if (observingWifiLock?.isHeld == true) observingWifiLock?.release() } | |
| 269 | val locallyPlaying = runCatching { player?.isPlaying == true }.getOrDefault(false) | |
| 270 | val casting = runCatching { cast.isCasting.value }.getOrDefault(false) | |
| 271 | if (!locallyPlaying && !casting) { | |
| 272 | runCatching { stopForeground(STOP_FOREGROUND_REMOVE) } | |
| 273 | } else { | |
| 274 | // Foreground duty belongs to local play / casting; just retire | |
| 275 | // our notification. | |
| 276 | runCatching { | |
| 277 | getSystemService(android.app.NotificationManager::class.java) | |
| 278 | .cancel(OBSERVING_NOTIFICATION_ID) | |
| 279 | } | |
| 280 | } | |
| 281 | } | |
| 282 | private var session: MediaLibrarySession? = null | |
| 283 | // The ForwardingPlayer wrapper that the MediaSession actually reads from — | |
| 284 | // its cast-aware getters return CCA state when casting, exo state otherwise. | |
| 285 | // Kept as a field so the wake receiver can reflectively call its notify* | |
| 286 | // methods to force a notification metadata refresh after deep sleep. | |
| 287 | private var sessionPlayerRef: androidx.media3.common.Player? = null | |
| 288 | private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main) | |
| 289 | ||
| 290 | // Maintainer, 2026-10-29: the server the car is currently browsing, kept in | |
| 291 | // memory only. Opening a server row in the car used to call | |
| 292 | // settings.setPreferredServer and silently change the phone/TV app's | |
| 293 | // saved server (D7). Written/read from the browse coroutines on IO. | |
| 294 | @Volatile | |
| 295 | private var carBrowseUdn: String? = null | |
| 296 | ||
| 297 | @EntryPoint | |
| 298 | @InstallIn(SingletonComponent::class) | |
| 299 | interface ServiceDeps { | |
| 300 | fun contentDirectoryClient(): ContentDirectoryClient | |
| 301 | fun settingsStore(): SettingsStore | |
| 302 | fun upnpServiceHolder(): UpnpServiceHolder | |
| 303 | fun localMediaScanner(): dev.stave.local.LocalMediaScanner | |
| 304 | fun castIntegration(): dev.stave.cast.CastIntegration | |
| 305 | fun queuePersistenceStore(): dev.stave.data.QueuePersistenceStore | |
| 306 | fun rawCastObserver(): dev.stave.cast.raw.RawCastObserver | |
| 307 | } | |
| 308 | ||
| 309 | private lateinit var cdClient: ContentDirectoryClient | |
| 310 | private lateinit var settings: SettingsStore | |
| 311 | private lateinit var upnpHolder: UpnpServiceHolder | |
| 312 | private lateinit var localScanner: dev.stave.local.LocalMediaScanner | |
| 313 | private lateinit var cast: dev.stave.cast.CastIntegration | |
| 314 | private lateinit var queueStore: dev.stave.data.QueuePersistenceStore | |
| 315 | private lateinit var rawCast: dev.stave.cast.raw.RawCastObserver | |
| 316 | ||
| 317 | // ServiceConnection for UPnP — the PlaybackService binds independently of | |
| 318 | // MainActivity so Android Auto can browse even when the TV Activity isn't alive. | |
| 319 | private val upnpConnection = object : android.content.ServiceConnection { | |
| 320 | override fun onServiceConnected(name: android.content.ComponentName?, binder: android.os.IBinder?) { | |
| 321 | (binder as? org.jupnp.android.AndroidUpnpService)?.let { | |
| 322 | upnpHolder.attach(it) | |
| 323 | } | |
| 324 | } | |
| 325 | override fun onServiceDisconnected(name: android.content.ComponentName?) { | |
| 326 | upnpHolder.detach() | |
| 327 | } | |
| 328 | } | |
| 329 | private var upnpBound = false | |
| 330 | ||
| 331 | override fun onCreate() { | |
| 332 | super.onCreate() | |
| 333 | ||
| 334 | val deps = EntryPointAccessors.fromApplication(applicationContext, ServiceDeps::class.java) | |
| 335 | cdClient = deps.contentDirectoryClient() | |
| 336 | settings = deps.settingsStore() | |
| 337 | upnpHolder = deps.upnpServiceHolder() | |
| 338 | localScanner = deps.localMediaScanner() | |
| 339 | cast = deps.castIntegration() | |
| 340 | queueStore = deps.queuePersistenceStore() | |
| 341 | rawCast = deps.rawCastObserver() | |
| 342 | ||
| 343 | // ── Observing keep-alive + reattach ──────────────────────────── | |
| 344 | // The observer socket lives in the process; this service's job is | |
| 345 | // to keep the process alive while observing (foreground promotion, | |
| 346 | // mirroring the casting keep-alive below) and to resurrect a | |
| 347 | // session the process died with (reattachIfPersisted). See | |
| 348 | // enterObservingKeepAlive for the full failure-mode writeup. | |
| 349 | scope.launch { | |
| 350 | rawCast.observing.collect { observing -> | |
| 351 | if (observing) enterObservingKeepAlive() else exitObservingKeepAlive() | |
| 352 | } | |
| 353 | } | |
| 354 | // Keep the keep-alive notification's content current: show the | |
| 355 | // observed track (title — artist) instead of a static line, updated | |
| 356 | // on track change only (not position ticks). | |
| 357 | scope.launch { | |
| 358 | kotlinx.coroutines.flow.combine( | |
| 359 | rawCast.observing, | |
| 360 | rawCast.playbackState | |
| 361 | .map { it.current?.let { t -> t.title to t.artist } } | |
| 362 | .distinctUntilChanged(), | |
| 363 | ) { observing, titleArtist -> observing to titleArtist } | |
| 364 | .collect { (observing, titleArtist) -> | |
| 365 | if (!observing || titleArtist == null) return@collect | |
| 366 | val (title, artist) = titleArtist | |
| 367 | val line = if (artist.isNullOrBlank()) title else "$title — $artist" | |
| 368 | runCatching { | |
| 369 | getSystemService(android.app.NotificationManager::class.java) | |
| 370 | .notify( | |
| 371 | OBSERVING_NOTIFICATION_ID, | |
| 372 | buildObservingNotification( | |
| 373 | rawCast.connectedDeviceName.value, line, | |
| 374 | ), | |
| 375 | ) | |
| 376 | } | |
| 377 | } | |
| 378 | } | |
| 379 | // Reattach: if the process died mid-observation, reconnect and — only | |
| 380 | // if the CCA session is still live — resume following. Runs off-main; | |
| 381 | // failure modes are all handled inside (see RawCastObserver docs). | |
| 382 | scope.launch(Dispatchers.IO) { | |
| 383 | runCatching { rawCast.reattachIfPersisted() } | |
| 384 | .onFailure { android.util.Log.w("EarhornCast", "reattach failed", it) } | |
| 385 | } | |
| 386 | ||
| 387 | // ── Casting keep-alive (background-stall fix) ────────────────── | |
| 388 | // While casting, the CCA streams through this phone's | |
| 389 | // CastStreamProxy, but the LOCAL player is paused — so Media3 | |
| 390 | // drops the service out of foreground, and on Android 12+ the | |
| 391 | // cached-app freezer then freezes the whole process the moment | |
| 392 | // the user switches apps. Frozen process = dead proxy = the | |
| 393 | // speaker group's buffer runs dry and playback stops until the | |
| 394 | // user reopens the app (at which point the receiver, having hit | |
| 395 | // a stream error, skips to the next track). Keep the service | |
| 396 | // foreground with a lightweight "Casting" notification and hold | |
| 397 | // Wifi/partial-wake locks for the duration of the session. | |
| 398 | // Libre flavor: isCasting is constantly false → this is inert. | |
| 399 | scope.launch { | |
| 400 | cast.isCasting.collect { casting -> | |
| 401 | if (casting) enterCastingKeepAlive() else exitCastingKeepAlive() | |
| 402 | } | |
| 403 | } | |
| 404 | ||
| 405 | // Bind UPnP service from the PlaybackService itself — this ensures Auto | |
| 406 | // can discover servers even when the main Activity hasn't been opened. | |
| 407 | // Set the wifi/ethernet-only interface restriction BEFORE bind so jUPnP | |
| 408 | // doesn't bind SSDP multicast to a VPN tun interface (NetGuard etc.) or | |
| 409 | // cellular. See [NetworkInterfaceResolver] for rationale. | |
| 410 | // Unconditional on every device (design decision 2026-09-02, | |
| 411 | // reverting the automation-switch gating): UPnP and kiosk together. | |
| 412 | dev.stave.upnp.NetworkInterfaceResolver.applyToSystemProperties(applicationContext) | |
| 413 | runCatching { | |
| 414 | bindService( | |
| 415 | android.content.Intent(this, org.jupnp.android.AndroidUpnpServiceImpl::class.java), | |
| 416 | upnpConnection, | |
| 417 | android.content.Context.BIND_AUTO_CREATE, | |
| 418 | ) | |
| 419 | upnpBound = true | |
| 420 | }.onFailure { | |
| 421 | android.util.Log.e("EarhornAuto", "Failed to bind UPnP from PlaybackService", it) | |
| 422 | } | |
| 423 | ||
| 424 | val okhttp = OkHttpClient.Builder() | |
| 425 | .connectTimeout(10, TimeUnit.SECONDS) | |
| 426 | .readTimeout(60, TimeUnit.SECONDS) | |
| 427 | .build() | |
| 428 | ||
| 429 | // OkHttp for HTTP fetches — preserves Earhorn user-agent on UPnP requests. | |
| 430 | val httpDataSourceFactory = OkHttpDataSource.Factory(okhttp) | |
| 431 | .setUserAgent(earhornUserAgent()) | |
| 432 | ||
| 433 | // DefaultDataSource.Factory dispatches by URI scheme: | |
| 434 | // - http:// https:// → delegated to httpDataSourceFactory (OkHttp + Earhorn UA) | |
| 435 | // - content:// → ContentDataSource (MediaStore audio for on-device files) | |
| 436 | // - file:// → FileDataSource | |
| 437 | // - asset://, rawresource://, android.resource:// → built-in handlers | |
| 438 | // Without this wrapper, OkHttpDataSource is the *only* data source the player | |
| 439 | // knows about, so any content:// URI from the local-files browser fails to open | |
| 440 | // — player stays in IDLE/ERROR while the MediaController still holds the queue | |
| 441 | // items, producing the silent-playback-with-pause-icon state. TV isn't affected | |
| 442 | // because TV plays UPnP HTTP URLs and the http branch of DefaultDataSource still | |
| 443 | // routes through the OkHttp factory exactly as before. | |
| 444 | val dataSourceFactory = DefaultDataSource.Factory(this, httpDataSourceFactory) | |
| 445 | ||
| 446 | val mediaSourceFactory = DefaultMediaSourceFactory(this) | |
| 447 | .setDataSourceFactory(dataSourceFactory) | |
| 448 | ||
| 449 | val exo = ExoPlayer.Builder(this) | |
| 450 | .setMediaSourceFactory(mediaSourceFactory) | |
| 451 | .setAudioAttributes( | |
| 452 | AudioAttributes.Builder() | |
| 453 | .setUsage(C.USAGE_MEDIA) | |
| 454 | .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC) | |
| 455 | .build(), | |
| 456 | /* handleAudioFocus = */ true | |
| 457 | ) | |
| 458 | .setHandleAudioBecomingNoisy(true) | |
| 459 | .build() | |
| 460 | ||
| 461 | player = exo | |
| 462 | ||
| 463 | // Maintainer, 2026-10-29: skip unplayable tracks instead of stopping | |
| 464 | // silently (D3). ExoPlayer halts the whole queue at the first item it | |
| 465 | // can't play (no <res>, 404, unsupported format) with no message. | |
| 466 | // Skip to the next item keeping playWhenReady, tell the user, and give | |
| 467 | // up after 5 errors in a row (counter resets once something actually | |
| 468 | // plays). Never while casting: the local player is muted/paused then. | |
| 469 | exo.addListener(object : Player.Listener { | |
| 470 | private var consecutiveErrors = 0 | |
| 471 | ||
| 472 | override fun onPlayerError(error: androidx.media3.common.PlaybackException) { | |
| 473 | if (cast.isCasting.value) return | |
| 474 | val title = exo.currentMediaItem?.mediaMetadata?.title?.toString() | |
| 475 | ?.takeIf { it.isNotBlank() } ?: "track" | |
| 476 | android.util.Log.w("EarhornPlayback", "playback error on '$title'", error) | |
| 477 | consecutiveErrors++ | |
| 478 | if (consecutiveErrors >= 5) { | |
| 479 | consecutiveErrors = 0 | |
| 480 | android.widget.Toast.makeText( | |
| 481 | applicationContext, | |
| 482 | "Playback stopped — several tracks couldn't be played", | |
| 483 | android.widget.Toast.LENGTH_LONG, | |
| 484 | ).show() | |
| 485 | return | |
| 486 | } | |
| 487 | if (!exo.hasNextMediaItem()) { | |
| 488 | consecutiveErrors = 0 | |
| 489 | android.widget.Toast.makeText( | |
| 490 | applicationContext, | |
| 491 | "Couldn't play $title", | |
| 492 | android.widget.Toast.LENGTH_SHORT, | |
| 493 | ).show() | |
| 494 | return | |
| 495 | } | |
| 496 | exo.seekToNextMediaItem() | |
| 497 | exo.prepare() | |
| 498 | android.widget.Toast.makeText( | |
| 499 | applicationContext, | |
| 500 | "Couldn't play $title — skipped", | |
| 501 | android.widget.Toast.LENGTH_SHORT, | |
| 502 | ).show() | |
| 503 | } | |
| 504 | ||
| 505 | override fun onIsPlayingChanged(isPlaying: Boolean) { | |
| 506 | if (isPlaying) consecutiveErrors = 0 | |
| 507 | } | |
| 508 | }) | |
| 509 | ||
| 510 | // Pre-warm the local media scanner cache on a background thread. | |
| 511 | // This prevents the first Auto browse from blocking for seconds | |
| 512 | // while MediaStore scans thousands of files. After this completes, | |
| 513 | // all scanAlbums/scanArtists/allTracks calls return instantly from | |
| 514 | // the in-memory cache. | |
| 515 | scope.launch(Dispatchers.IO) { | |
| 516 | runCatching { | |
| 517 | android.util.Log.i("EarhornAuto", "Pre-warming local media cache…") | |
| 518 | val t0 = System.currentTimeMillis() | |
| 519 | localScanner.allTracks() // populates the cache | |
| 520 | val ms = System.currentTimeMillis() - t0 | |
| 521 | android.util.Log.i("EarhornAuto", "Cache warm: ${localScanner.allTracks().size} tracks in ${ms}ms") | |
| 522 | } | |
| 523 | } | |
| 524 | ||
| 525 | // ForwardingPlayer wraps ExoPlayer so the MediaSession (and its | |
| 526 | // notification) routes play/pause/seek/volume commands to the Cast | |
| 527 | // device when a Cast session is active. | |
| 528 | // | |
| 529 | // Listener tracking: we intercept addListener/removeListener to | |
| 530 | // maintain our own set. When cast state changes, we fire | |
| 531 | // onDeviceInfoChanged on all listeners so the MediaSession picks | |
| 532 | // up the PLAYBACK_TYPE_REMOTE → PLAYBACK_TYPE_LOCAL transition | |
| 533 | // (or vice versa) and the system routes background/lockscreen | |
| 534 | // volume keys accordingly. Without this, the session caches the | |
| 535 | // DeviceInfo it read at creation time and never re-checks. | |
| 536 | val sessionPlayer = @OptIn(UnstableApi::class) object : ForwardingPlayer(exo) { | |
| 537 | private val trackedListeners = mutableSetOf<Player.Listener>() | |
| 538 | ||
| 539 | override fun addListener(listener: Player.Listener) { | |
| 540 | super.addListener(listener) | |
| 541 | trackedListeners.add(listener) | |
| 542 | } | |
| 543 | override fun removeListener(listener: Player.Listener) { | |
| 544 | super.removeListener(listener) | |
| 545 | trackedListeners.remove(listener) | |
| 546 | } | |
| 547 | fun notifyDeviceInfoChanged() { | |
| 548 | val info = getDeviceInfo() | |
| 549 | trackedListeners.forEach { runCatching { it.onDeviceInfoChanged(info) } } | |
| 550 | } | |
| 551 | ||
| 552 | /** Fan out the synthetic play-state to all tracked listeners. | |
| 553 | * Called whenever cast play-state or session-active state | |
| 554 | * changes — without this the MediaSession (and therefore | |
| 555 | * the system notification) keeps reporting exo's frozen | |
| 556 | * paused state while the receiver is actually playing. | |
| 557 | * The session reads the player getters when it receives | |
| 558 | * these events; our overrides below return the cast-aware | |
| 559 | * values so the session picks up the right state. */ | |
| 560 | fun notifyPlayStateChanged() { | |
| 561 | val playing = isPlaying | |
| 562 | val pwr = getPlayWhenReady() | |
| 563 | val state = getPlaybackState() | |
| 564 | trackedListeners.forEach { l -> | |
| 565 | runCatching { | |
| 566 | l.onIsPlayingChanged(playing) | |
| 567 | l.onPlayWhenReadyChanged( | |
| 568 | pwr, | |
| 569 | Player.PLAY_WHEN_READY_CHANGE_REASON_REMOTE, | |
| 570 | ) | |
| 571 | l.onPlaybackStateChanged(state) | |
| 572 | } | |
| 573 | } | |
| 574 | } | |
| 575 | ||
| 576 | /** Fan out current-item-changed events to all listeners. The | |
| 577 | * notification reads track metadata (title/artist/art) from | |
| 578 | * the player's current MediaItem — when the receiver | |
| 579 | * advances to a new track our cast-aware getters above | |
| 580 | * return the new index/item/metadata, but the session | |
| 581 | * doesn't know to re-read until a listener event fires. | |
| 582 | * Without this, the lockscreen stays pinned to the track | |
| 583 | * that was current when the cast session started. */ | |
| 584 | fun notifyMediaItemChanged() { | |
| 585 | val item = getCurrentMediaItem() | |
| 586 | val metadata = getMediaMetadata() | |
| 587 | trackedListeners.forEach { l -> | |
| 588 | runCatching { | |
| 589 | l.onMediaItemTransition( | |
| 590 | item, | |
| 591 | Player.MEDIA_ITEM_TRANSITION_REASON_AUTO, | |
| 592 | ) | |
| 593 | l.onMediaMetadataChanged(metadata) | |
| 594 | } | |
| 595 | } | |
| 596 | } | |
| 597 | ||
| 598 | // Hide shuffle/repeat from the notification template. | |
| 599 | // Pixel's media notification automatically adds shuffle and | |
| 600 | // repeat buttons when the Player advertises these commands. | |
| 601 | // The user wants "More by artist" and "Stop" instead — | |
| 602 | // those are in the custom layout. Removing the commands | |
| 603 | // from the Player's advertisement prevents the system from | |
| 604 | // adding its own shuffle/repeat icons. | |
| 605 | override fun getAvailableCommands(): Player.Commands { | |
| 606 | return super.getAvailableCommands().buildUpon() | |
| 607 | .remove(Player.COMMAND_SET_SHUFFLE_MODE) | |
| 608 | .remove(Player.COMMAND_SET_REPEAT_MODE) | |
| 609 | .build() | |
| 610 | } | |
| 611 | ||
| 612 | override fun play() { | |
| 613 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.play() casting=${cast.isCasting.value}") | |
| 614 | // Maintainer, 2026-10-29: while following the group (observing), | |
| 615 | // Play from OUTSIDE the app's own screens — notification, lock | |
| 616 | // screen, headset, car — goes to the observed session, not the | |
| 617 | // local player: local audio under the group's music was the | |
| 618 | // "two songs at once" bug (D6). The app's own controller (its | |
| 619 | // screens, the UPnP renderer service) still drives the local | |
| 620 | // player as before. A headset PLAY_PAUSE arrives as play() | |
| 621 | // (the local player is paused), so it toggles the group. | |
| 622 | if (routeToObservedSession()) { | |
| 623 | scope.launch { | |
| 624 | runCatching { | |
| 625 | if (rawCast.playbackState.value.isPlaying) rawCast.pause() else rawCast.play() | |
| 626 | } | |
| 627 | } | |
| 628 | return | |
| 629 | } | |
| 630 | if (cast.isCasting.value) cast.play() else super.play() | |
| 631 | } | |
| 632 | override fun pause() { | |
| 633 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.pause() casting=${cast.isCasting.value}") | |
| 634 | // Maintainer, 2026-10-29: same routing as play() while observing (D6). | |
| 635 | if (routeToObservedSession()) { | |
| 636 | scope.launch { runCatching { rawCast.pause() } } | |
| 637 | return | |
| 638 | } | |
| 639 | if (cast.isCasting.value) cast.pause() else super.pause() | |
| 640 | } | |
| 641 | /** Maintainer, 2026-10-29 (D6): true while observing when the current | |
| 642 | * request comes from outside the app's own screens (media | |
| 643 | * notification / headset — Media3 attributes both to its | |
| 644 | * notification controller — or another package such as the | |
| 645 | * car). The app's own MediaController (same package, not the | |
| 646 | * notification controller) is never rerouted, so the app's | |
| 647 | * "pause local when observing starts" and the UPnP renderer | |
| 648 | * service keep acting on the local player. */ | |
| 649 | private fun routeToObservedSession(): Boolean { | |
| 650 | if (!rawCast.observing.value) return false | |
| 651 | val s = session ?: return false | |
| 652 | val caller = s.controllerForCurrentRequest ?: return false | |
| 653 | return caller.packageName != packageName || s.isMediaNotificationController(caller) | |
| 654 | } | |
| 655 | override fun seekTo(positionMs: Long) { | |
| 656 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.seekTo($positionMs)") | |
| 657 | if (cast.isCasting.value) cast.seekTo(positionMs) else super.seekTo(positionMs) | |
| 658 | } | |
| 659 | // Lockscreen / headset / notification Next and Previous fork to | |
| 660 | // the receiver like every other transport here (review N.24, | |
| 661 | // design decision 2026-09-02): before, only the hidden local | |
| 662 | // index moved and the speaker kept playing. | |
| 663 | override fun seekToNextMediaItem() { | |
| 664 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.seekToNextMediaItem() casting=${cast.isCasting.value}") | |
| 665 | super.seekToNextMediaItem() | |
| 666 | if (cast.isCasting.value) cast.queueNext() | |
| 667 | } | |
| 668 | override fun seekToPreviousMediaItem() { | |
| 669 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.seekToPreviousMediaItem() casting=${cast.isCasting.value}") | |
| 670 | super.seekToPreviousMediaItem() | |
| 671 | if (cast.isCasting.value) cast.queuePrev() | |
| 672 | } | |
| 673 | override fun stop() { | |
| 674 | android.util.Log.d("EarhornAuto", "ForwardingPlayer.stop() casting=${cast.isCasting.value}") | |
| 675 | if (cast.isCasting.value) { | |
| 676 | cast.stop(); cast.seekTo(0) | |
| 677 | } else super.stop() | |
| 678 | } | |
| 679 | override fun getDeviceInfo(): androidx.media3.common.DeviceInfo { | |
| 680 | if (cast.isCasting.value) { | |
| 681 | return androidx.media3.common.DeviceInfo.Builder( | |
| 682 | androidx.media3.common.DeviceInfo.PLAYBACK_TYPE_REMOTE | |
| 683 | ).setMaxVolume(20).build() | |
| 684 | } | |
| 685 | return super.getDeviceInfo() | |
| 686 | } | |
| 687 | override fun getDeviceVolume(): Int { | |
| 688 | if (cast.isCasting.value) { | |
| 689 | return (cast.getDeviceVolume() * 20).toInt().coerceIn(0, 20) | |
| 690 | } | |
| 691 | return super.getDeviceVolume() | |
| 692 | } | |
| 693 | override fun isDeviceMuted(): Boolean { | |
| 694 | if (cast.isCasting.value) return cast.getDeviceVolume() <= 0.0 | |
| 695 | return super.isDeviceMuted() | |
| 696 | } | |
| 697 | override fun setDeviceVolume(volume: Int, flags: Int) { | |
| 698 | if (cast.isCasting.value) { | |
| 699 | cast.setDeviceVolume(volume / 20.0) | |
| 700 | } else super.setDeviceVolume(volume, flags) | |
| 701 | } | |
| 702 | override fun increaseDeviceVolume(flags: Int) { | |
| 703 | if (cast.isCasting.value) { | |
| 704 | cast.setDeviceVolume(cast.getDeviceVolume() + 0.05) | |
| 705 | } else super.increaseDeviceVolume(flags) | |
| 706 | } | |
| 707 | override fun decreaseDeviceVolume(flags: Int) { | |
| 708 | if (cast.isCasting.value) { | |
| 709 | cast.setDeviceVolume(cast.getDeviceVolume() - 0.05) | |
| 710 | } else super.decreaseDeviceVolume(flags) | |
| 711 | } | |
| 712 | ||
| 713 | // Synthetic play-state during cast. While casting, exo is paused | |
| 714 | // (volume=0, playWhenReady=false) so the phone doesn't decode | |
| 715 | // the stream alongside the receiver — but the MediaSession | |
| 716 | // reads playback state directly from these getters, and a | |
| 717 | // paused exo would make the system notification show paused | |
| 718 | // even though the receiver is playing. Override the trio of | |
| 719 | // getters Media3's notification template reads (isPlaying, | |
| 720 | // playWhenReady, playbackState) so the lockscreen icon | |
| 721 | // matches what the user hears. Listener fan-out via | |
| 722 | // notifyPlayStateChanged() keeps these in sync when cast | |
| 723 | // state actually changes. | |
| 724 | override fun isPlaying(): Boolean { | |
| 725 | return if (cast.isCasting.value) cast.castIsPlaying.value | |
| 726 | else super.isPlaying() | |
| 727 | } | |
| 728 | override fun getPlayWhenReady(): Boolean { | |
| 729 | return if (cast.isCasting.value) cast.castIsPlaying.value | |
| 730 | else super.getPlayWhenReady() | |
| 731 | } | |
| 732 | override fun getPlaybackState(): Int { | |
| 733 | // Always report READY during cast — STATE_IDLE/STATE_ENDED | |
| 734 | // would suppress the notification, and STATE_BUFFERING | |
| 735 | // would show a spinner. The receiver handles its own | |
| 736 | // buffering UI on-screen; we just say "ready" so the | |
| 737 | // session reports a stable playing/paused indicator | |
| 738 | // driven by playWhenReady. | |
| 739 | return if (cast.isCasting.value) Player.STATE_READY | |
| 740 | else super.getPlaybackState() | |
| 741 | } | |
| 742 | ||
| 743 | // Synthetic current-item index/metadata during cast. exo's | |
| 744 | // local timeline still holds every track we loaded into the | |
| 745 | // queue, but exo doesn't advance through it (paused for | |
| 746 | // heat reasons). The notification reads title/artist/art | |
| 747 | // from the player's current media item — without these | |
| 748 | // overrides it'd be stuck on whichever track was current | |
| 749 | // when the cast session started while the receiver moves | |
| 750 | // on to track 2, 3, … and the lockscreen never catches up. | |
| 751 | // We return the receiver's authoritative index, then let | |
| 752 | // the base Player path resolve that to the right MediaItem | |
| 753 | // out of the loaded timeline. Listener fan-out via | |
| 754 | // notifyMediaItemChanged() (below) fires on every receiver | |
| 755 | // queue advance so the session re-reads. | |
| 756 | override fun getCurrentMediaItemIndex(): Int { | |
| 757 | if (cast.isCasting.value) { | |
| 758 | val idx = cast.castCurrentItemIndex.value | |
| 759 | if (idx >= 0 && idx < mediaItemCount) return idx | |
| 760 | } | |
| 761 | return super.getCurrentMediaItemIndex() | |
| 762 | } | |
| 763 | override fun getCurrentMediaItem(): androidx.media3.common.MediaItem? { | |
| 764 | if (cast.isCasting.value) { | |
| 765 | val idx = cast.castCurrentItemIndex.value | |
| 766 | if (idx >= 0 && idx < mediaItemCount) return getMediaItemAt(idx) | |
| 767 | } | |
| 768 | return super.getCurrentMediaItem() | |
| 769 | } | |
| 770 | override fun getMediaMetadata(): androidx.media3.common.MediaMetadata { | |
| 771 | if (cast.isCasting.value) { | |
| 772 | val item = getCurrentMediaItem() | |
| 773 | if (item != null) return item.mediaMetadata | |
| 774 | } | |
| 775 | return super.getMediaMetadata() | |
| 776 | } | |
| 777 | } | |
| 778 | ||
| 779 | // Cast audio-focus manager. When a Cast session starts, disable | |
| 780 | // ExoPlayer's audio focus handling so we can keep playWhenReady=true | |
| 781 | // (for the notification icon) without ExoPlayer losing focus to the | |
| 782 | // Cast SDK and auto-pausing. Volume→0 silences local output. We | |
| 783 | // ALSO pause exo entirely while casting — previously a separate | |
| 784 | // mirror flipped exo.playWhenReady to match castIsPlaying, which | |
| 785 | // meant the local player kept decoding the same UPnP stream the | |
| 786 | // receiver was already decoding. Same bits over the network | |
| 787 | // twice, same CPU spent on FLAC/MP3 demux, audible heat in the | |
| 788 | // user's hand. exo.pause() releases the renderers; when cast | |
| 789 | // ends we let the existing restore path bring it back up. | |
| 790 | // On session end, restore normal focus handling and unmute. | |
| 791 | scope.launch { | |
| 792 | cast.isCasting.collect { casting -> | |
| 793 | if (casting) { | |
| 794 | exo.setAudioAttributes( | |
| 795 | AudioAttributes.Builder() | |
| 796 | .setUsage(C.USAGE_MEDIA) | |
| 797 | .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC) | |
| 798 | .build(), | |
| 799 | /* handleAudioFocus = */ false, | |
| 800 | ) | |
| 801 | exo.volume = 0f | |
| 802 | // Stop active decoding. Queue is preserved (no stop() | |
| 803 | // call), so re-toggling cast off resumes from the | |
| 804 | // current track at position 0. | |
| 805 | exo.playWhenReady = false | |
| 806 | } else { | |
| 807 | // Pause before unmuting — playWhenReady may still be | |
| 808 | // true from the castIsPlaying mirror. Without this, | |
| 809 | // disconnecting from cast instantly resumes playback | |
| 810 | // through the phone speaker at full volume. | |
| 811 | exo.playWhenReady = false | |
| 812 | exo.volume = 1f | |
| 813 | exo.setAudioAttributes( | |
| 814 | AudioAttributes.Builder() | |
| 815 | .setUsage(C.USAGE_MEDIA) | |
| 816 | .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC) | |
| 817 | .build(), | |
| 818 | /* handleAudioFocus = */ true, | |
| 819 | ) | |
| 820 | } | |
| 821 | // Poke the session's listeners so it re-reads DeviceInfo | |
| 822 | // (PLAYBACK_TYPE_REMOTE when casting, LOCAL when not). | |
| 823 | // Without this, the session caches the DeviceInfo from | |
| 824 | // creation time and background volume keys always hit the | |
| 825 | // phone stream instead of the Cast device. | |
| 826 | sessionPlayer.notifyDeviceInfoChanged() | |
| 827 | // Also fire play-state listeners — our overrides return | |
| 828 | // cast state when casting and exo state otherwise, so | |
| 829 | // every casting toggle is a play-state transition the | |
| 830 | // session needs to be told about. | |
| 831 | sessionPlayer.notifyPlayStateChanged() | |
| 832 | // And media-item — current track shifts between exo's | |
| 833 | // pinned index and the receiver's at every cast | |
| 834 | // toggle, so the notification needs to re-read. | |
| 835 | sessionPlayer.notifyMediaItemChanged() | |
| 836 | } | |
| 837 | } | |
| 838 | ||
| 839 | // Cast play-state listener-only mirror. The session reads its | |
| 840 | // play/pause state from the player getters (isPlaying et al.) | |
| 841 | // which we've overridden to return cast values during cast. | |
| 842 | // Listeners need to be told when those values change or the | |
| 843 | // session won't re-read. CRITICAL: this only fans out events, | |
| 844 | // never sets exo.playWhenReady — that's what the old mirror | |
| 845 | // did, and it caused the phone to overheat (exo silently | |
| 846 | // decoding alongside the receiver, same stream, twice the | |
| 847 | // work). Notification accuracy without the heat penalty. | |
| 848 | scope.launch { | |
| 849 | cast.castIsPlaying.collect { | |
| 850 | if (cast.isCasting.value) { | |
| 851 | sessionPlayer.notifyPlayStateChanged() | |
| 852 | } | |
| 853 | } | |
| 854 | } | |
| 855 | ||
| 856 | // Same pattern for the current-track index. When the receiver | |
| 857 | // advances to a new queue item, fire onMediaItemTransition + | |
| 858 | // onMediaMetadataChanged so the session re-reads the player's | |
| 859 | // (now cast-aware) current MediaItem and the lockscreen art / | |
| 860 | // title / artist follow along. Without this collector the | |
| 861 | // overridden getters return correct values but no one knows | |
| 862 | // to call them — the notification stays stuck on the track | |
| 863 | // that was current when the cast session started. | |
| 864 | scope.launch { | |
| 865 | cast.castCurrentItemIndex.collect { | |
| 866 | if (cast.isCasting.value) { | |
| 867 | sessionPlayer.notifyMediaItemChanged() | |
| 868 | } | |
| 869 | } | |
| 870 | } | |
| 871 | ||
| 872 | // Two PendingIntents: | |
| 873 | // - sessionActivityPi: fires when the user taps the body of | |
| 874 | // the system media notification (album art, title area). | |
| 875 | // Per UX spec, this opens the Queue screen — the album art | |
| 876 | // IS the queue button. | |
| 877 | // - openAppPi: fallback for when no specific deep-link is | |
| 878 | // appropriate; just brings the app to foreground. | |
| 879 | val openAppIntent = packageManager.getLaunchIntentForPackage(packageName)?.apply { | |
| 880 | addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) | |
| 881 | } | |
| 882 | val openAppPi = openAppIntent?.let { | |
| 883 | PendingIntent.getActivity( | |
| 884 | this, 0, it, | |
| 885 | PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, | |
| 886 | ) | |
| 887 | } | |
| 888 | val sessionActivityPi = openAppIntent?.let { | |
| 889 | val queueDeepLink = Intent(it).apply { | |
| 890 | putExtra(EXTRA_NAV_ROUTE, NAV_QUEUE) | |
| 891 | } | |
| 892 | PendingIntent.getActivity( | |
| 893 | this, REQUEST_CODE_QUEUE, queueDeepLink, | |
| 894 | PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, | |
| 895 | ) | |
| 896 | } ?: openAppPi | |
| 897 | ||
| 898 | val sessionBuilder = MediaLibrarySession.Builder(this, sessionPlayer, LibraryCallback()) | |
| 899 | .setCustomLayout(buildNotificationLayout(exo)) | |
| 900 | // Custom BitmapLoader: forces 1024x1024 fetches via Coil so | |
| 901 | // Auto's now-playing card and the system notification get a | |
| 902 | // big image regardless of where the URI points. Default | |
| 903 | // DataSourceBitmapLoader decodes whatever the URI returns, | |
| 904 | // which for content://media/external/audio/albumart can be | |
| 905 | // a 256-px thumbnail. Wrapped in CacheBitmapLoader so | |
| 906 | // repeated requests for the same URI hit cache. | |
| 907 | .setBitmapLoader( | |
| 908 | androidx.media3.session.CacheBitmapLoader(CoilBitmapLoader(this)) | |
| 909 | ) | |
| 910 | if (sessionActivityPi != null) { | |
| 911 | sessionBuilder.setSessionActivity(sessionActivityPi) | |
| 912 | } | |
| 913 | session = sessionBuilder.build() | |
| 914 | // Expose the session-player ref for the wake receiver. See class-level | |
| 915 | // doc on sessionPlayerRef for why. | |
| 916 | sessionPlayerRef = sessionPlayer | |
| 917 | // Register the wake-on-screen receiver. RECEIVER_NOT_EXPORTED on R+ — | |
| 918 | // these are system broadcasts so the flag is required but they're | |
| 919 | // exempt from the broadcast-export protection (sourced by the OS). | |
| 920 | if (!wakeReceiverRegistered) { | |
| 921 | val filter = android.content.IntentFilter().apply { | |
| 922 | addAction(android.content.Intent.ACTION_SCREEN_ON) | |
| 923 | addAction(android.content.Intent.ACTION_USER_PRESENT) | |
| 924 | } | |
| 925 | runCatching { | |
| 926 | if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) { | |
| 927 | registerReceiver(wakeReceiver, filter, android.content.Context.RECEIVER_NOT_EXPORTED) | |
| 928 | } else { | |
| 929 | @Suppress("UnspecifiedRegisterReceiverFlag") | |
| 930 | registerReceiver(wakeReceiver, filter) | |
| 931 | } | |
| 932 | wakeReceiverRegistered = true | |
| 933 | } | |
| 934 | } | |
| 935 | // Expose the compat token for the Car App Library. | |
| 936 | sessionCompatToken = getCompatToken(session!!) | |
| 937 | // Initial layout push via Media3 1.4+ API | |
| 938 | @Suppress("NewApi") | |
| 939 | runCatching { session!!.setMediaButtonPreferences(buildNotificationLayout(exo)) } | |
| 940 | ||
| 941 | setMediaNotificationProvider( | |
| 942 | // Subclass that overrides the button selection so the | |
| 943 | // notification action row surfaces our custom layout (one | |
| 944 | // button: Stop) instead of Pixel's auto-prepended | |
| 945 | // prev/play-pause/next. | |
| 946 | // | |
| 947 | // Pixel's MediaStyle template renders a separate | |
| 948 | // primary-action button (the orange play/pause in the | |
| 949 | // upper-right of the notification card) sourced from the | |
| 950 | // media session's PlaybackState — that path is unaffected | |
| 951 | // by getMediaButtons. So returning only customLayout from | |
| 952 | // here drops the redundant prev/play-pause/next from the | |
| 953 | // bottom action row and leaves the central play/pause + | |
| 954 | // skip controls intact via the system path. | |
| 955 | object : DefaultMediaNotificationProvider( | |
| 956 | this, | |
| 957 | NOTIFICATION_ID_PROVIDER, | |
| 958 | "earhorn_playback", | |
| 959 | R.string.notification_channel_name, | |
| 960 | ) { | |
| 961 | @OptIn(UnstableApi::class) | |
| 962 | override fun getMediaButtons( | |
| 963 | session: MediaSession, | |
| 964 | playerCommands: Player.Commands, | |
| 965 | customLayout: ImmutableList<CommandButton>, | |
| 966 | showPauseButton: Boolean, | |
| 967 | ): ImmutableList<CommandButton> { | |
| 968 | // If the custom layout hasn't been built yet | |
| 969 | // (rare, but possible during very-early init), | |
| 970 | // fall through to the default which gives the | |
| 971 | // user *something* (prev/play-pause/next) rather | |
| 972 | // than an empty action row. | |
| 973 | if (customLayout.isEmpty()) { | |
| 974 | return super.getMediaButtons( | |
| 975 | session, playerCommands, customLayout, showPauseButton, | |
| 976 | ) | |
| 977 | } | |
| 978 | return customLayout | |
| 979 | } | |
| 980 | }.apply { | |
| 981 | setSmallIcon(R.drawable.ic_notification) | |
| 982 | } | |
| 983 | ) | |
| 984 | } | |
| 985 | ||
| 986 | /** The notification's custom layout: one button, Stop. Standard | |
| 987 | * prev/play-pause/next come from the media template's built-in | |
| 988 | * slots. */ | |
| 989 | private fun buildNotificationLayout(p: Player): List<CommandButton> { | |
| 990 | return listOf( | |
| 991 | CommandButton.Builder() | |
| 992 | .setDisplayName("Stop") | |
| 993 | .setIconResId(R.drawable.ic_transport_stop) | |
| 994 | .setSessionCommand(SessionCommand(CMD_STOP_ALL, Bundle.EMPTY)) | |
| 995 | .build(), | |
| 996 | ) | |
| 997 | } | |
| 998 | ||
| 999 | override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? = session | |
| 1000 | ||
| 1001 | override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { | |
| 1002 | // Let MediaSessionService process media-button intents first. | |
| 1003 | val result = super.onStartCommand(intent, flags, startId) | |
| 1004 | if (intent?.action == ACTION_OBSERVE_KEEPALIVE) { | |
| 1005 | // Started via startForegroundService — we MUST promote to | |
| 1006 | // foreground promptly or the system kills us with a | |
| 1007 | // ForegroundServiceDidNotStartInTimeException. The observer | |
| 1008 | // sends this only after its connect succeeded, so entering | |
| 1009 | // keep-alive is correct; if observing has already flipped off | |
| 1010 | // in a race, the observing collector's next emission calls | |
| 1011 | // exitObservingKeepAlive and cleans up. | |
| 1012 | enterObservingKeepAlive() | |
| 1013 | } | |
| 1014 | return result | |
| 1015 | } | |
| 1016 | ||
| 1017 | override fun onTaskRemoved(rootIntent: Intent?) { | |
| 1018 | // Swipe-away must NOT kill the service while it has remote duties: | |
| 1019 | // observing (the TLS follow socket lives in this process — stopSelf | |
| 1020 | // here was the "observer mode drops every time I exit the app" bug) | |
| 1021 | // or casting (the stream proxy serves the receiver's bytes). The | |
| 1022 | // user's chosen model: the connection lives with the service, and | |
| 1023 | // relaunching the app reattaches to whatever is still playing. | |
| 1024 | val observing = runCatching { rawCast.observing.value }.getOrDefault(false) | |
| 1025 | val casting = runCatching { cast.isCasting.value }.getOrDefault(false) | |
| 1026 | if (player?.playWhenReady == false && !observing && !casting) stopSelf() | |
| 1027 | } | |
| 1028 | ||
| 1029 | // ── Wake-on-screen notification refresh ───────────────────────── | |
| 1030 | // When the phone goes into deep doze with a cast session active, the | |
| 1031 | // local exo is paused (volume=0, playWhenReady=false) so it produces | |
| 1032 | // no listener events. The notification template renders from the last | |
| 1033 | // event, which can be hours old by the time the user wakes the phone | |
| 1034 | // — they see whichever track was playing when they fell asleep, not | |
| 1035 | // what's currently on the cast speaker. | |
| 1036 | // | |
| 1037 | // Listening for ACTION_SCREEN_ON (and USER_PRESENT for keyguard | |
| 1038 | // dismissal) lets us poke the session's listeners so the notification | |
| 1039 | // re-reads our cast-aware getters and shows the current track. | |
| 1040 | private val wakeReceiver = object : android.content.BroadcastReceiver() { | |
| 1041 | override fun onReceive(context: android.content.Context?, intent: android.content.Intent?) { | |
| 1042 | val action = intent?.action ?: return | |
| 1043 | if (action != android.content.Intent.ACTION_SCREEN_ON && | |
| 1044 | action != android.content.Intent.ACTION_USER_PRESENT | |
| 1045 | ) return | |
| 1046 | android.util.Log.d("EarhornWake", "wakeReceiver: $action") | |
| 1047 | // Force a Cast state refresh first — in doze the sender's | |
| 1048 | // RemoteMediaClient callbacks may have stopped firing, leaving | |
| 1049 | // castCurrentItemIndex / castIsPlaying stale. requestStatus() | |
| 1050 | // round-trips the receiver and triggers onStatusUpdated, which | |
| 1051 | // updates the StateFlows; our existing collectors in onCreate | |
| 1052 | // then call notify* and the session re-reads metadata. | |
| 1053 | runCatching { | |
| 1054 | val deps = EntryPointAccessors.fromApplication( | |
| 1055 | applicationContext, ServiceDeps::class.java | |
| 1056 | ) | |
| 1057 | deps.castIntegration().requestStatusRefresh() | |
| 1058 | } | |
| 1059 | // Belt-and-suspenders: also poke the session listeners directly, | |
| 1060 | // in case the user wasn't casting at all (refresh is a no-op | |
| 1061 | // there) but the notification still went stale for some other | |
| 1062 | // reason (e.g. doze-suspended bitmap loader). | |
| 1063 | val p = sessionPlayerRef ?: return | |
| 1064 | runCatching { | |
| 1065 | // sessionPlayer is an anonymous-object subclass of ForwardingPlayer | |
| 1066 | // defined inline in onCreate(). Its notify* methods can't be | |
| 1067 | // typed-named from out here, so dispatch reflectively. Reflection | |
| 1068 | // cost is irrelevant on a once-per-wake call. | |
| 1069 | val cls = p.javaClass | |
| 1070 | listOf("notifyMediaItemChanged", "notifyPlayStateChanged").forEach { name -> | |
| 1071 | runCatching { | |
| 1072 | cls.getDeclaredMethod(name).apply { isAccessible = true }.invoke(p) | |
| 1073 | } | |
| 1074 | } | |
| 1075 | // (The layout is static — one Stop button — so there is | |
| 1076 | // nothing to rebuild here; the seven-button rebuild was | |
| 1077 | // removed 2026-09-02.) | |
| 1078 | } | |
| 1079 | } | |
| 1080 | } | |
| 1081 | private var wakeReceiverRegistered = false | |
| 1082 | ||
| 1083 | override fun onDestroy() { | |
| 1084 | exitCastingKeepAlive() | |
| 1085 | runCatching { if (observingWifiLock?.isHeld == true) observingWifiLock?.release() } | |
| 1086 | if (wakeReceiverRegistered) { | |
| 1087 | runCatching { unregisterReceiver(wakeReceiver) } | |
| 1088 | wakeReceiverRegistered = false | |
| 1089 | } | |
| 1090 | val s = session | |
| 1091 | val p = player | |
| 1092 | session = null | |
| 1093 | player = null | |
| 1094 | sessionPlayerRef = null | |
| 1095 | s?.release() | |
| 1096 | p?.release() | |
| 1097 | if (upnpBound) { | |
| 1098 | runCatching { unbindService(upnpConnection) } | |
| 1099 | upnpBound = false | |
| 1100 | } | |
| 1101 | super.onDestroy() | |
| 1102 | } | |
| 1103 | ||
| 1104 | // ── Browse callback — bridges UPnP to Android Auto media tree ──── | |
| 1105 | ||
| 1106 | /** Synthetic ID for the server-list node. When Auto arrives with no | |
| 1107 | * preferred server, the root's children are server entries instead of | |
| 1108 | * music containers. Selecting one sets the preference and refreshes. */ | |
| 1109 | /** Real version for the HTTP user agent (the string was "Earhorn/0.0.1" | |
| 1110 | * since the first release; review N.30). */ | |
| 1111 | private fun earhornUserAgent(): String = runCatching { | |
| 1112 | "Earhorn/" + packageManager.getPackageInfo(packageName, 0).versionName | |
| 1113 | }.getOrDefault("Earhorn") | |
| 1114 | ||
| 1115 | companion object { | |
| 1116 | @OptIn(UnstableApi::class) | |
| 1117 | private fun getCompatToken( | |
| 1118 | session: MediaLibraryService.MediaLibrarySession | |
| 1119 | ): android.support.v4.media.session.MediaSessionCompat.Token { | |
| 1120 | return session.sessionCompatToken | |
| 1121 | } | |
| 1122 | ||
| 1123 | // Internal Auto/library identifiers | |
| 1124 | const val NOTIFICATION_ID = 2002 | |
| 1125 | /** Explicit-start action sent by RawCastObserver right after an | |
| 1126 | * observe connect succeeds. Purely observing involves no local | |
| 1127 | * playback, so nothing else guarantees this service even EXISTS — | |
| 1128 | * a MediaController bind only happens around local play. Without | |
| 1129 | * this start, the keep-alive collector in onCreate never runs, the | |
| 1130 | * process is freezer-fair-game the moment the user switches apps, | |
| 1131 | * and observer mode silently dies in the background (field- | |
| 1132 | * reported). startForegroundService also obliges us to call | |
| 1133 | * startForeground promptly — onStartCommand handles that. */ | |
| 1134 | const val ACTION_OBSERVE_KEEPALIVE = "earhorn.action.observe_keepalive" | |
| 1135 | const val BROWSE_ROOT = "earhorn_root" | |
| 1136 | const val SERVER_PREFIX = "earhorn_server:" | |
| 1137 | ||
| 1138 | /** MediaSessionCompat.Token exposed for the Car App Library's | |
| 1139 | * MediaPlaybackManager.registerMediaPlaybackToken(). Set after | |
| 1140 | * the session is built in onCreate(); null before that. */ | |
| 1141 | @Volatile | |
| 1142 | var sessionCompatToken: android.support.v4.media.session.MediaSessionCompat.Token? = null | |
| 1143 | private set | |
| 1144 | ||
| 1145 | // NotificationIdProvider for the protected DefaultMediaNotificationProvider | |
| 1146 | // constructor (required for subclassing). Returns the same constant | |
| 1147 | // ID for every session — Earhorn only ever has one active session. | |
| 1148 | val NOTIFICATION_ID_PROVIDER = | |
| 1149 | androidx.media3.session.DefaultMediaNotificationProvider.NotificationIdProvider { | |
| 1150 | NOTIFICATION_ID | |
| 1151 | } | |
| 1152 | ||
| 1153 | // PendingIntent request codes — must be distinct so | |
| 1154 | // FLAG_UPDATE_CURRENT updates the right one when extras change. | |
| 1155 | const val REQUEST_CODE_QUEUE = 1001 | |
| 1156 | ||
| 1157 | // Custom session commands. The notification is one button (Stop); | |
| 1158 | // the app's in-process controller uses the two setters below. A | |
| 1159 | // seven-button layout and six more commands lived here without a | |
| 1160 | // sender until 2026-09-02 (review N.25; removed on the | |
| 1161 | // design decision). | |
| 1162 | // Explicit-value setters for shuffle / repeat. Used by the app's | |
| 1163 | // UI (NowPlaying toggle, ShuffleAction) which knows the target | |
| 1164 | // value rather than just wanting to flip from the current one. | |
| 1165 | // These exist because ForwardingPlayer.getAvailableCommands() | |
| 1166 | // hides COMMAND_SET_SHUFFLE_MODE / COMMAND_SET_REPEAT_MODE to | |
| 1167 | // keep the system notification template from auto-adding shuffle | |
| 1168 | // and repeat icons — and MediaController.setShuffleModeEnabled | |
| 1169 | // silently drops the call when the command isn't advertised, so | |
| 1170 | // the in-app shuffle button never reached the player. Routing | |
| 1171 | // via a SessionCommand bypasses that gate. | |
| 1172 | const val CMD_SET_SHUFFLE = "earhorn.cmd.set_shuffle" | |
| 1173 | const val CMD_SET_REPEAT_MODE = "earhorn.cmd.set_repeat_mode" | |
| 1174 | const val ARG_SHUFFLE_ENABLED = "enabled" | |
| 1175 | const val ARG_REPEAT_MODE = "mode" // Player.REPEAT_MODE_* int | |
| 1176 | // Stop is a custom command (not Player.COMMAND_STOP) so we can | |
| 1177 | // fork to cast.stop() when a Cast session is active. Player.COMMAND_STOP | |
| 1178 | // would only stop the local controller, leaving the Cast device | |
| 1179 | // playing — confusing UX since the user just told the system | |
| 1180 | // "stop everything". | |
| 1181 | const val CMD_STOP_ALL = "earhorn.cmd.stop_all" | |
| 1182 | ||
| 1183 | // Deep-link extras MainActivity reads on receiving an intent | |
| 1184 | // with the session activity or a notification command launch. | |
| 1185 | // Single string-valued route plus an optional argument (used | |
| 1186 | // by more-by-artist / more-from-album to carry the artist or | |
| 1187 | // album name). Kept simple so the intent payload survives | |
| 1188 | // Android's extras limitations. | |
| 1189 | const val EXTRA_NAV_ROUTE = "earhorn.extra.nav_route" | |
| 1190 | const val EXTRA_NAV_ARG = "earhorn.extra.nav_arg" | |
| 1191 | const val NAV_QUEUE = "queue" | |
| 1192 | const val NAV_LYRICS = "lyrics" | |
| 1193 | const val NAV_NOW_PLAYING = "now_playing" | |
| 1194 | const val NAV_MORE_ARTIST = "more_by_artist" | |
| 1195 | const val NAV_MORE_ALBUM = "more_from_album" | |
| 1196 | /** Land on Browse (root of the preferred server, or Servers when | |
| 1197 | * none is set). Used by the hand-back path when kiosk won't open: | |
| 1198 | * never a blank screen (design decision 2026-09-02). */ | |
| 1199 | const val NAV_BROWSE = "browse" | |
| 1200 | } | |
| 1201 | ||
| 1202 | private inner class LibraryCallback : MediaLibrarySession.Callback { | |
| 1203 | ||
| 1204 | /** Cache of mediaId → playable URI, populated as we browse the library | |
| 1205 | * on Auto's behalf. Auto's IPC strips MediaItem.RequestMetadata when | |
| 1206 | * the controller round-trips items back to the session for | |
| 1207 | * setMediaItem / addMediaItem — so by the time onAddMediaItems sees | |
| 1208 | * the items the user tapped, the only stable identifier is the | |
| 1209 | * mediaId; the URI we put in requestMetadata.mediaUri at toMediaItem | |
| 1210 | * time is gone. Without this cache, taps on UPnP tracks resolve to | |
| 1211 | * itemless playback (silent no-op, controller stays on the prior | |
| 1212 | * track), which is the "tap a song, nothing happens, old track keeps | |
| 1213 | * playing" report. ConcurrentHashMap is safe for the many-readers / | |
| 1214 | * occasional-writer pattern between scope.launch coroutines and the | |
| 1215 | * synchronous onAddMediaItems callback. */ | |
| 1216 | private val uriCache = java.util.concurrent.ConcurrentHashMap<String, android.net.Uri>() | |
| 1217 | ||
| 1218 | /** Advertise our custom session commands to every connecting | |
| 1219 | * controller. Without this, the system notification's | |
| 1220 | * CommandButtons that use SessionCommand can't dispatch — | |
| 1221 | * the session rejects unknown command keys at the | |
| 1222 | * authorization layer before they reach onCustomCommand. */ | |
| 1223 | override fun onConnect( | |
| 1224 | session: MediaSession, | |
| 1225 | controller: MediaSession.ControllerInfo, | |
| 1226 | ): MediaSession.ConnectionResult { | |
| 1227 | val available = MediaSession.ConnectionResult | |
| 1228 | .DEFAULT_SESSION_AND_LIBRARY_COMMANDS | |
| 1229 | .buildUpon() | |
| 1230 | .add(SessionCommand(CMD_SET_SHUFFLE, Bundle.EMPTY)) | |
| 1231 | .add(SessionCommand(CMD_SET_REPEAT_MODE, Bundle.EMPTY)) | |
| 1232 | .add(SessionCommand(CMD_STOP_ALL, Bundle.EMPTY)) | |
| 1233 | .build() | |
| 1234 | return MediaSession.ConnectionResult.AcceptedResultBuilder(session) | |
| 1235 | .setAvailableSessionCommands(available) | |
| 1236 | .build() | |
| 1237 | } | |
| 1238 | ||
| 1239 | /** Route custom commands. Toggle commands modify the | |
| 1240 | * ExoPlayer directly — the Player.Listener registered in | |
| 1241 | * onCreate picks up the change and rebuilds the layout, so | |
| 1242 | * the icon updates without an explicit setCustomLayout call | |
| 1243 | * here. Nav commands launch MainActivity with deep-link | |
| 1244 | * extras the activity reads in onNewIntent. */ | |
| 1245 | override fun onCustomCommand( | |
| 1246 | session: MediaSession, | |
| 1247 | controller: MediaSession.ControllerInfo, | |
| 1248 | customCommand: SessionCommand, | |
| 1249 | args: Bundle, | |
| 1250 | ): ListenableFuture<SessionResult> { | |
| 1251 | val p = player | |
| 1252 | when (customCommand.customAction) { | |
| 1253 | CMD_SET_SHUFFLE -> { | |
| 1254 | // Args carry the explicit desired value. See the comment on | |
| 1255 | // CMD_SET_SHUFFLE for why the in-app shuffle button can't | |
| 1256 | // use MediaController.setShuffleModeEnabled directly. | |
| 1257 | val enabled = args.getBoolean(ARG_SHUFFLE_ENABLED) | |
| 1258 | if (p != null) p.shuffleModeEnabled = enabled | |
| 1259 | } | |
| 1260 | CMD_SET_REPEAT_MODE -> { | |
| 1261 | val mode = args.getInt(ARG_REPEAT_MODE, Player.REPEAT_MODE_OFF) | |
| 1262 | if (p != null) p.repeatMode = mode | |
| 1263 | } | |
| 1264 | CMD_STOP_ALL -> { | |
| 1265 | // Fork to cast first so the remote audio actually | |
| 1266 | // stops; cast.stop() is a no-op in libre flavor | |
| 1267 | // and harmless when no session is active. | |
| 1268 | if (cast.isCasting.value) { | |
| 1269 | runCatching { cast.stop() } | |
| 1270 | runCatching { cast.seekTo(0) } | |
| 1271 | } | |
| 1272 | // The observed house session too — the notification's | |
| 1273 | // Stop used to leave it running (I.19, design decision | |
| 1274 | // 2026-09-02): same routing as the on-screen Stop. | |
| 1275 | if (rawCast.observing.value) { | |
| 1276 | scope.launch { runCatching { rawCast.stop() } } | |
| 1277 | } | |
| 1278 | // Always pause+rewind local so the MediaSession | |
| 1279 | // transitions to STATE_READY (paused at 0). Uses | |
| 1280 | // pause+seek instead of player.stop() to preserve | |
| 1281 | // queue/track state — pressing Play afterward | |
| 1282 | // restarts the current track from the beginning, | |
| 1283 | // matching the "old-school stop button" semantics | |
| 1284 | // used elsewhere in LocalRenderer.stop(). | |
| 1285 | if (p != null) { | |
| 1286 | p.pause() | |
| 1287 | p.seekTo(0) | |
| 1288 | } | |
| 1289 | } | |
| 1290 | } | |
| 1291 | return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS)) | |
| 1292 | } | |
| 1293 | ||
| 1294 | override fun onGetLibraryRoot( | |
| 1295 | session: MediaLibrarySession, | |
| 1296 | browser: MediaSession.ControllerInfo, | |
| 1297 | params: LibraryParams?, | |
| 1298 | ): ListenableFuture<LibraryResult<MediaItem>> { | |
| 1299 | // params may carry hints — `params.isRecent`, `params.isSuggested`, | |
| 1300 | // `params.isOffline` — that Auto uses to populate "For You" / | |
| 1301 | // "Recommendations" / "Recents" tabs. Auto's "For You" panel that | |
| 1302 | // shows up in the launcher is populated from a SUGGESTED-rooted | |
| 1303 | // sub-tree if the app provides one. Earhorn doesn't currently | |
| 1304 | // build a suggestion graph (no listening-history derived | |
| 1305 | // recommendations), so we return the same generic root for all | |
| 1306 | // hint flavors. Auto falls back to the user's recently-played | |
| 1307 | // session items, which is why "For You" shows whatever was last | |
| 1308 | // playing rather than curated picks. | |
| 1309 | // | |
| 1310 | // To populate For You meaningfully we'd need to: | |
| 1311 | // 1. Track playback history (recently-played albums/tracks). | |
| 1312 | // 2. Return a hierarchy when params.isSuggested with mediaIds | |
| 1313 | // like "earhorn_recent:album:N" / "earhorn_recent:track:N". | |
| 1314 | // 3. Implement onGetChildren for those IDs. | |
| 1315 | // Punted as future scope. | |
| 1316 | val root = MediaItem.Builder() | |
| 1317 | .setMediaId(BROWSE_ROOT) | |
| 1318 | .setMediaMetadata( | |
| 1319 | MediaMetadata.Builder() | |
| 1320 | .setTitle("Earhorn Music") | |
| 1321 | .setIsBrowsable(true) | |
| 1322 | .setIsPlayable(false) | |
| 1323 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED) | |
| 1324 | .build() | |
| 1325 | ) | |
| 1326 | .build() | |
| 1327 | return Futures.immediateFuture(LibraryResult.ofItem(root, params)) | |
| 1328 | } | |
| 1329 | ||
| 1330 | override fun onGetChildren( | |
| 1331 | session: MediaLibrarySession, | |
| 1332 | browser: MediaSession.ControllerInfo, | |
| 1333 | parentId: String, | |
| 1334 | page: Int, | |
| 1335 | pageSize: Int, | |
| 1336 | params: LibraryParams?, | |
| 1337 | ): ListenableFuture<LibraryResult<ImmutableList<MediaItem>>> { | |
| 1338 | val t0 = System.currentTimeMillis() | |
| 1339 | android.util.Log.i("EarhornAuto", "onGetChildren parentId=$parentId page=$page pageSize=$pageSize") | |
| 1340 | val future = SettableFuture.create<LibraryResult<ImmutableList<MediaItem>>>() | |
| 1341 | scope.launch(Dispatchers.IO) { | |
| 1342 | try { | |
| 1343 | // ── Local media branches ──────────────────────────── | |
| 1344 | if (parentId.startsWith(dev.stave.local.LocalMediaScanner.LOCAL_PREFIX)) { | |
| 1345 | handleLocalBrowse(parentId, params, future) | |
| 1346 | return@launch | |
| 1347 | } | |
| 1348 | ||
| 1349 | // ── Server-selection from the root list ───────────── | |
| 1350 | if (parentId.startsWith(SERVER_PREFIX)) { | |
| 1351 | val udn = parentId.removePrefix(SERVER_PREFIX) | |
| 1352 | // Maintainer, 2026-10-29: remember the car's choice in | |
| 1353 | // memory instead of overwriting the app's saved server (D7). | |
| 1354 | carBrowseUdn = udn | |
| 1355 | browseContainer(udn, "0", params, future) | |
| 1356 | return@launch | |
| 1357 | } | |
| 1358 | ||
| 1359 | // ── Root-level children ───────────────────────────── | |
| 1360 | if (parentId == BROWSE_ROOT) { | |
| 1361 | // Source-level layout: Local Music sits next to the | |
| 1362 | // configured (or discovered) UPnP server(s) as | |
| 1363 | // siblings, NOT mixed with each server's root | |
| 1364 | // containers. Prior layout inlined the configured | |
| 1365 | // server's container-0 children at the top level | |
| 1366 | // alongside Local Music — when the server's root has | |
| 1367 | // ten entries (folder view, tag view, albums, | |
| 1368 | // artists, genres, …) this buried Local Music below | |
| 1369 | // a wall of server entries that looked like the only | |
| 1370 | // thing available, and tapping any of them entered | |
| 1371 | // server browse rather than a clear "I want my phone | |
| 1372 | // music" / "I want my home server" choice. | |
| 1373 | // | |
| 1374 | // New: top level always shows source picks. Tap Local | |
| 1375 | // Music → local hierarchy. Tap a server → that | |
| 1376 | // server's root container. | |
| 1377 | val items = mutableListOf<MediaItem>() | |
| 1378 | ||
| 1379 | items.add( | |
| 1380 | MediaItem.Builder() | |
| 1381 | .setMediaId(dev.stave.local.LocalMediaScanner.LOCAL_ROOT) | |
| 1382 | .setMediaMetadata( | |
| 1383 | MediaMetadata.Builder() | |
| 1384 | .setTitle("Local Music") | |
| 1385 | .setSubtitle("Music stored on this device") | |
| 1386 | .setIsBrowsable(true) | |
| 1387 | .setIsPlayable(false) | |
| 1388 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_ALBUMS) | |
| 1389 | .build() | |
| 1390 | ) | |
| 1391 | .build() | |
| 1392 | ) | |
| 1393 | ||
| 1394 | val configuredUdn = settings.preferredServerUdn.first() | |
| 1395 | val knownServers = upnpHolder.servers.value | |
| 1396 | // Don't block the browse tree waiting for SSDP discovery. | |
| 1397 | // Use whatever servers are already known. If empty, the | |
| 1398 | // user sees only "Local Music" — they can retry after | |
| 1399 | // discovery completes. | |
| 1400 | val servers = knownServers | |
| 1401 | if (knownServers.isEmpty()) { | |
| 1402 | // Kick a rescan in the background for next time | |
| 1403 | upnpHolder.rescan() | |
| 1404 | } | |
| 1405 | ||
| 1406 | // Always include the configured server (even if not | |
| 1407 | // currently in the live discovery list — it might | |
| 1408 | // come back). Then append any other discovered | |
| 1409 | // servers. Dedup by UDN. | |
| 1410 | val seen = mutableSetOf<String>() | |
| 1411 | configuredUdn?.let { udn -> | |
| 1412 | val match = servers.firstOrNull { it.udn == udn } | |
| 1413 | // Maintainer, 2026-10-29: say plainly when the saved | |
| 1414 | // server isn't on this network (D7). No name is | |
| 1415 | // stored for it, so the title falls back to "Saved server". | |
| 1416 | val title = match?.friendlyName ?: "Saved server" | |
| 1417 | val subtitle = if (match == null) "Not found on this network" | |
| 1418 | else match.modelName ?: "Configured server" | |
| 1419 | items.add( | |
| 1420 | MediaItem.Builder() | |
| 1421 | .setMediaId("$SERVER_PREFIX$udn") | |
| 1422 | .setMediaMetadata( | |
| 1423 | MediaMetadata.Builder() | |
| 1424 | .setTitle(title) | |
| 1425 | .setSubtitle(subtitle) | |
| 1426 | .setIsBrowsable(true) | |
| 1427 | .setIsPlayable(false) | |
| 1428 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED) | |
| 1429 | .build() | |
| 1430 | ) | |
| 1431 | .build() | |
| 1432 | ) | |
| 1433 | seen.add(udn) | |
| 1434 | } | |
| 1435 | servers.forEach { server -> | |
| 1436 | if (server.udn in seen) return@forEach | |
| 1437 | items.add( | |
| 1438 | MediaItem.Builder() | |
| 1439 | .setMediaId("$SERVER_PREFIX${server.udn}") | |
| 1440 | .setMediaMetadata( | |
| 1441 | MediaMetadata.Builder() | |
| 1442 | .setTitle(server.friendlyName) | |
| 1443 | .setSubtitle(server.modelName ?: "UPnP Server") | |
| 1444 | .setIsBrowsable(true) | |
| 1445 | .setIsPlayable(false) | |
| 1446 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED) | |
| 1447 | .build() | |
| 1448 | ) | |
| 1449 | .build() | |
| 1450 | ) | |
| 1451 | seen.add(server.udn) | |
| 1452 | } | |
| 1453 | ||
| 1454 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1455 | return@launch | |
| 1456 | } | |
| 1457 | ||
| 1458 | // ── UPnP container browse ─────────────────────────── | |
| 1459 | // Maintainer, 2026-10-29: browse the server the car opened, | |
| 1460 | // falling back to the app's saved server (D7). | |
| 1461 | val udn = carBrowseUdn ?: settings.preferredServerUdn.first() | |
| 1462 | if (udn != null) { | |
| 1463 | browseContainer(udn, parentId, params, future) | |
| 1464 | } else { | |
| 1465 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_NOT_SUPPORTED)) | |
| 1466 | } | |
| 1467 | } catch (e: Exception) { | |
| 1468 | android.util.Log.e("EarhornAuto", "onGetChildren failed in ${System.currentTimeMillis() - t0}ms", e) | |
| 1469 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_UNKNOWN)) | |
| 1470 | } | |
| 1471 | } | |
| 1472 | future.addListener({ | |
| 1473 | android.util.Log.i("EarhornAuto", "onGetChildren $parentId completed in ${System.currentTimeMillis() - t0}ms") | |
| 1474 | }, MoreExecutors.directExecutor()) | |
| 1475 | return paged(future, page, pageSize) // Maintainer, 2026-10-29: see paged() | |
| 1476 | } | |
| 1477 | ||
| 1478 | /** Maintainer, 2026-10-29: every browse/search path above sets the FULL | |
| 1479 | * list, but Media3 throws IllegalStateException on its main handler | |
| 1480 | * (process death) when a result holds more than pageSize items — the | |
| 1481 | * car asks in pages. Return a future carrying only the requested page | |
| 1482 | * of whatever [source] resolves to. Only [source] is ever completed | |
| 1483 | * (set(), never failed or cancelled), so get() here doesn't throw. */ | |
| 1484 | private fun paged( | |
| 1485 | source: SettableFuture<LibraryResult<ImmutableList<MediaItem>>>, | |
| 1486 | page: Int, | |
| 1487 | pageSize: Int, | |
| 1488 | ): ListenableFuture<LibraryResult<ImmutableList<MediaItem>>> { | |
| 1489 | val out = SettableFuture.create<LibraryResult<ImmutableList<MediaItem>>>() | |
| 1490 | source.addListener({ out.set(pageOf(source.get(), page, pageSize)) }, MoreExecutors.directExecutor()) | |
| 1491 | return out | |
| 1492 | } | |
| 1493 | ||
| 1494 | /** Maintainer, 2026-10-29: items.drop(page * pageSize).take(pageSize) of a | |
| 1495 | * successful item list; anything else (errors, pageSize Int.MAX_VALUE = | |
| 1496 | * "all", invalid paging) passes through untouched. */ | |
| 1497 | private fun pageOf( | |
| 1498 | result: LibraryResult<ImmutableList<MediaItem>>, | |
| 1499 | page: Int, | |
| 1500 | pageSize: Int, | |
| 1501 | ): LibraryResult<ImmutableList<MediaItem>> { | |
| 1502 | val items = result.value | |
| 1503 | if (result.resultCode != LibraryResult.RESULT_SUCCESS || items == null) return result | |
| 1504 | if (pageSize <= 0 || page < 0 || pageSize == Int.MAX_VALUE) return result | |
| 1505 | val from = page.toLong() * pageSize | |
| 1506 | if (from == 0L && items.size <= pageSize) return result | |
| 1507 | val slice = if (from >= items.size) emptyList() else items.drop(from.toInt()).take(pageSize) | |
| 1508 | return LibraryResult.ofItemList(slice, result.params) | |
| 1509 | } | |
| 1510 | ||
| 1511 | /** Handle all local media browse paths. */ | |
| 1512 | private suspend fun handleLocalBrowse( | |
| 1513 | parentId: String, | |
| 1514 | params: LibraryParams?, | |
| 1515 | future: SettableFuture<LibraryResult<ImmutableList<MediaItem>>>, | |
| 1516 | ) { | |
| 1517 | val lms = dev.stave.local.LocalMediaScanner | |
| 1518 | // Permission gate. MediaStore.Audio queries return zero rows | |
| 1519 | // (cleanly, no exception) when the app has not been granted | |
| 1520 | // READ_MEDIA_AUDIO (API 33+) / READ_EXTERNAL_STORAGE (API <33). | |
| 1521 | // In Earhorn, the runtime grant flow lives in the phone-side | |
| 1522 | // LocalHubScreen — if the user has never visited that screen, | |
| 1523 | // permission has never been requested and Auto's local browse | |
| 1524 | // returns silent empty lists at every level (Albums → "No | |
| 1525 | // items", Artists → "No items"). User reads this as "the app | |
| 1526 | // doesn't have my files." Surface the actual cause: a | |
| 1527 | // single browsable-but-not-actionable hint item at the root | |
| 1528 | // that tells them where to go. | |
| 1529 | val perm = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) | |
| 1530 | android.Manifest.permission.READ_MEDIA_AUDIO | |
| 1531 | else | |
| 1532 | android.Manifest.permission.READ_EXTERNAL_STORAGE | |
| 1533 | val hasPerm = androidx.core.content.ContextCompat.checkSelfPermission( | |
| 1534 | applicationContext, perm, | |
| 1535 | ) == android.content.pm.PackageManager.PERMISSION_GRANTED | |
| 1536 | if (!hasPerm) { | |
| 1537 | future.set(LibraryResult.ofItemList( | |
| 1538 | ImmutableList.of( | |
| 1539 | MediaItem.Builder() | |
| 1540 | .setMediaId("earhorn_local_no_permission") | |
| 1541 | .setMediaMetadata( | |
| 1542 | MediaMetadata.Builder() | |
| 1543 | // Maintainer, 2026-10-29: clearer hint wording (D7). | |
| 1544 | .setTitle("Allow Music access on your phone") | |
| 1545 | .setSubtitle("Open Earhorn → Choose server → On this device") | |
| 1546 | .setIsBrowsable(false) | |
| 1547 | .setIsPlayable(false) | |
| 1548 | .build() | |
| 1549 | ) | |
| 1550 | .build() | |
| 1551 | ), | |
| 1552 | params, | |
| 1553 | )) | |
| 1554 | return | |
| 1555 | } | |
| 1556 | when { | |
| 1557 | parentId == lms.LOCAL_ROOT -> { | |
| 1558 | val items = listOf( | |
| 1559 | MediaItem.Builder() | |
| 1560 | .setMediaId(lms.LOCAL_ALBUMS) | |
| 1561 | .setMediaMetadata( | |
| 1562 | MediaMetadata.Builder() | |
| 1563 | .setTitle("Albums") | |
| 1564 | .setIsBrowsable(true) | |
| 1565 | .setIsPlayable(false) | |
| 1566 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_ALBUMS) | |
| 1567 | .build() | |
| 1568 | ) | |
| 1569 | .build(), | |
| 1570 | MediaItem.Builder() | |
| 1571 | .setMediaId(lms.LOCAL_ARTISTS) | |
| 1572 | .setMediaMetadata( | |
| 1573 | MediaMetadata.Builder() | |
| 1574 | .setTitle("Artists") | |
| 1575 | .setIsBrowsable(true) | |
| 1576 | .setIsPlayable(false) | |
| 1577 | .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_ARTISTS) | |
| 1578 | .build() | |
| 1579 | ) | |
| 1580 | .build(), | |
| 1581 | ) | |
| 1582 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1583 | } | |
| 1584 | ||
| 1585 | parentId == lms.LOCAL_ALBUMS -> { | |
| 1586 | val albums = localScanner.scanAlbums() | |
| 1587 | val items = albums.map { album -> | |
| 1588 | MediaItem.Builder() | |
| 1589 | .setMediaId("${lms.LOCAL_ALBUM}${album.id}") | |
| 1590 | .setMediaMetadata( | |
| 1591 | MediaMetadata.Builder() | |
| 1592 | .setTitle(album.title) | |
| 1593 | .setArtist(album.artist) | |
| 1594 | .setIsBrowsable(true) | |
| 1595 | .setIsPlayable(false) | |
| 1596 | .setMediaType(MediaMetadata.MEDIA_TYPE_ALBUM) | |
| 1597 | .apply { | |
| 1598 | album.artUri?.let { setArtworkUri(it) } | |
| 1599 | } | |
| 1600 | .build() | |
| 1601 | ) | |
| 1602 | .build() | |
| 1603 | } | |
| 1604 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1605 | } | |
| 1606 | ||
| 1607 | parentId == lms.LOCAL_ARTISTS -> { | |
| 1608 | val artists = localScanner.scanArtists() | |
| 1609 | val items = artists.map { (id, name) -> | |
| 1610 | MediaItem.Builder() | |
| 1611 | .setMediaId("${lms.LOCAL_ARTIST}$id") | |
| 1612 | .setMediaMetadata( | |
| 1613 | MediaMetadata.Builder() | |
| 1614 | .setTitle(name) | |
| 1615 | .setIsBrowsable(true) | |
| 1616 | .setIsPlayable(false) | |
| 1617 | .setMediaType(MediaMetadata.MEDIA_TYPE_ARTIST) | |
| 1618 | .build() | |
| 1619 | ) | |
| 1620 | .build() | |
| 1621 | } | |
| 1622 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1623 | } | |
| 1624 | ||
| 1625 | parentId.startsWith(lms.LOCAL_ALBUM) -> { | |
| 1626 | val albumId = parentId.removePrefix(lms.LOCAL_ALBUM).toLongOrNull() | |
| 1627 | if (albumId == null) { | |
| 1628 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_BAD_VALUE)) | |
| 1629 | return | |
| 1630 | } | |
| 1631 | val tracks = localScanner.tracksForAlbum(albumId) | |
| 1632 | val items = tracks.map { track -> | |
| 1633 | val mediaId = "${lms.LOCAL_PREFIX}track:${track.id}" | |
| 1634 | // Populate URI cache — Auto's IPC strips the | |
| 1635 | // RequestMetadata between onGetChildren and the | |
| 1636 | // tap-to-play setMediaItem callback. Cache by | |
| 1637 | // mediaId so onAddMediaItems can resolve. | |
| 1638 | uriCache[mediaId] = track.contentUri | |
| 1639 | MediaItem.Builder() | |
| 1640 | .setMediaId(mediaId) | |
| 1641 | .setRequestMetadata( | |
| 1642 | MediaItem.RequestMetadata.Builder() | |
| 1643 | .setMediaUri(track.contentUri) | |
| 1644 | .build() | |
| 1645 | ) | |
| 1646 | .setMediaMetadata( | |
| 1647 | MediaMetadata.Builder() | |
| 1648 | .setTitle(track.title) | |
| 1649 | .setArtist(track.artist ?: track.albumArtist) | |
| 1650 | .setAlbumTitle(track.album) | |
| 1651 | .setTrackNumber(track.trackNumber) | |
| 1652 | .setDiscNumber(track.discNumber) | |
| 1653 | .setIsBrowsable(false) | |
| 1654 | .setIsPlayable(true) | |
| 1655 | .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) | |
| 1656 | .apply { | |
| 1657 | track.artUri?.let { setArtworkUri(it) } | |
| 1658 | setExtras(Bundle().apply { | |
| 1659 | putLong("duration_ms", track.duration) | |
| 1660 | }) | |
| 1661 | } | |
| 1662 | .build() | |
| 1663 | ) | |
| 1664 | .build() | |
| 1665 | } | |
| 1666 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1667 | } | |
| 1668 | ||
| 1669 | parentId.startsWith(lms.LOCAL_ARTIST) -> { | |
| 1670 | // Show albums for this artist. We query all albums and filter | |
| 1671 | // by artist name match since MediaStore doesn't have a clean | |
| 1672 | // artist→album join. | |
| 1673 | val artistId = parentId.removePrefix(lms.LOCAL_ARTIST).toLongOrNull() | |
| 1674 | if (artistId == null) { | |
| 1675 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_BAD_VALUE)) | |
| 1676 | return | |
| 1677 | } | |
| 1678 | val artists = localScanner.scanArtists() | |
| 1679 | val artistName = artists.firstOrNull { it.first == artistId }?.second | |
| 1680 | if (artistName == null) { | |
| 1681 | future.set(LibraryResult.ofItemList(ImmutableList.of(), params)) | |
| 1682 | return | |
| 1683 | } | |
| 1684 | val albums = localScanner.scanAlbums() | |
| 1685 | .filter { it.artist.equals(artistName, ignoreCase = true) } | |
| 1686 | val items = albums.map { album -> | |
| 1687 | MediaItem.Builder() | |
| 1688 | .setMediaId("${lms.LOCAL_ALBUM}${album.id}") | |
| 1689 | .setMediaMetadata( | |
| 1690 | MediaMetadata.Builder() | |
| 1691 | .setTitle(album.title) | |
| 1692 | .setArtist(album.artist) | |
| 1693 | .setIsBrowsable(true) | |
| 1694 | .setIsPlayable(false) | |
| 1695 | .setMediaType(MediaMetadata.MEDIA_TYPE_ALBUM) | |
| 1696 | .apply { | |
| 1697 | album.artUri?.let { setArtworkUri(it) } | |
| 1698 | } | |
| 1699 | .build() | |
| 1700 | ) | |
| 1701 | .build() | |
| 1702 | } | |
| 1703 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1704 | } | |
| 1705 | ||
| 1706 | else -> { | |
| 1707 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_BAD_VALUE)) | |
| 1708 | } | |
| 1709 | } | |
| 1710 | } | |
| 1711 | ||
| 1712 | /** Shared helper — browses a UPnP container and resolves the future. | |
| 1713 | * Caches each playable result's URI by mediaId so onAddMediaItems | |
| 1714 | * can resolve when Auto strips RequestMetadata over IPC. */ | |
| 1715 | private suspend fun browseContainer( | |
| 1716 | udn: String, | |
| 1717 | containerId: String, | |
| 1718 | params: LibraryParams?, | |
| 1719 | future: SettableFuture<LibraryResult<ImmutableList<MediaItem>>>, | |
| 1720 | ) { | |
| 1721 | when (val result = cdClient.browse(udn, containerId)) { | |
| 1722 | is BrowseResult.Success -> { | |
| 1723 | result.items.forEach { didl -> | |
| 1724 | if (didl is DidlItem.Track) { | |
| 1725 | runCatching { | |
| 1726 | uriCache[didl.id] = android.net.Uri.parse(didl.resourceUrl) | |
| 1727 | } | |
| 1728 | } | |
| 1729 | } | |
| 1730 | val items = result.items.map { it.toMediaItem() } | |
| 1731 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1732 | } | |
| 1733 | is BrowseResult.Failure -> { | |
| 1734 | future.set(LibraryResult.ofError(LibraryResult.RESULT_ERROR_IO)) | |
| 1735 | } | |
| 1736 | } | |
| 1737 | } | |
| 1738 | ||
| 1739 | override fun onGetItem( | |
| 1740 | session: MediaLibrarySession, | |
| 1741 | browser: MediaSession.ControllerInfo, | |
| 1742 | mediaId: String, | |
| 1743 | ): ListenableFuture<LibraryResult<MediaItem>> { | |
| 1744 | return Futures.immediateFuture( | |
| 1745 | LibraryResult.ofError(LibraryResult.RESULT_ERROR_NOT_SUPPORTED) | |
| 1746 | ) | |
| 1747 | } | |
| 1748 | ||
| 1749 | override fun onSearch( | |
| 1750 | session: MediaLibrarySession, | |
| 1751 | browser: MediaSession.ControllerInfo, | |
| 1752 | query: String, | |
| 1753 | params: LibraryParams?, | |
| 1754 | ): ListenableFuture<LibraryResult<Void>> { | |
| 1755 | // Acknowledge the search — Auto calls onGetSearchResult for results. | |
| 1756 | return Futures.immediateFuture(LibraryResult.ofVoid()) | |
| 1757 | } | |
| 1758 | ||
| 1759 | override fun onGetSearchResult( | |
| 1760 | session: MediaLibrarySession, | |
| 1761 | browser: MediaSession.ControllerInfo, | |
| 1762 | query: String, | |
| 1763 | page: Int, | |
| 1764 | pageSize: Int, | |
| 1765 | params: LibraryParams?, | |
| 1766 | ): ListenableFuture<LibraryResult<ImmutableList<MediaItem>>> { | |
| 1767 | val future = SettableFuture.create<LibraryResult<ImmutableList<MediaItem>>>() | |
| 1768 | scope.launch(Dispatchers.IO) { | |
| 1769 | try { | |
| 1770 | val items = mutableListOf<MediaItem>() | |
| 1771 | val lms = dev.stave.local.LocalMediaScanner | |
| 1772 | ||
| 1773 | // Local albums — browsable results so the user can tap | |
| 1774 | // to see the album's track list. | |
| 1775 | val localAlbums = localScanner.searchAlbums(query) | |
| 1776 | localAlbums.take(10).forEach { album -> | |
| 1777 | items.add( | |
| 1778 | MediaItem.Builder() | |
| 1779 | .setMediaId("${lms.LOCAL_ALBUM}${album.id}") | |
| 1780 | .setMediaMetadata( | |
| 1781 | MediaMetadata.Builder() | |
| 1782 | .setTitle(album.title) | |
| 1783 | .setArtist(album.artist) | |
| 1784 | .setIsBrowsable(true) | |
| 1785 | .setIsPlayable(false) | |
| 1786 | .setMediaType(MediaMetadata.MEDIA_TYPE_ALBUM) | |
| 1787 | .apply { album.artUri?.let { setArtworkUri(it) } } | |
| 1788 | .build() | |
| 1789 | ) | |
| 1790 | .build() | |
| 1791 | ) | |
| 1792 | } | |
| 1793 | ||
| 1794 | // Local files first — always available, no network round-trip. | |
| 1795 | val localTracks = localScanner.searchTracks(query) | |
| 1796 | localTracks.take(20).forEach { track -> | |
| 1797 | val mediaId = "${dev.stave.local.LocalMediaScanner.LOCAL_PREFIX}track:${track.id}" | |
| 1798 | uriCache[mediaId] = track.contentUri | |
| 1799 | items.add( | |
| 1800 | MediaItem.Builder() | |
| 1801 | .setMediaId(mediaId) | |
| 1802 | .setRequestMetadata( | |
| 1803 | MediaItem.RequestMetadata.Builder() | |
| 1804 | .setMediaUri(track.contentUri) | |
| 1805 | .build() | |
| 1806 | ) | |
| 1807 | .setMediaMetadata( | |
| 1808 | MediaMetadata.Builder() | |
| 1809 | .setTitle(track.title) | |
| 1810 | .setArtist(track.artist ?: track.albumArtist) | |
| 1811 | .setAlbumTitle(track.album) | |
| 1812 | .setIsBrowsable(false) | |
| 1813 | .setIsPlayable(true) | |
| 1814 | .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) | |
| 1815 | .apply { track.artUri?.let { setArtworkUri(it) } } | |
| 1816 | .build() | |
| 1817 | ) | |
| 1818 | .build() | |
| 1819 | ) | |
| 1820 | } | |
| 1821 | ||
| 1822 | // UPnP server search if connected. Prior implementation | |
| 1823 | // used `searchBucketAlbumsByTitle` (album titles | |
| 1824 | // containing the query — rarely matches a person's name) | |
| 1825 | // + `searchTracksByArtist` (artist EXACTLY equal to the | |
| 1826 | // query — never matches partial names like "dave"). | |
| 1827 | // Both returned 0 results for typical user queries, | |
| 1828 | // producing the "search never finds anything" behavior. | |
| 1829 | // Replaced with parallel `contains`-based bucket searches | |
| 1830 | // that mirror the phone UI's search semantics. Fired in | |
| 1831 | // parallel so total latency is the slowest single leg, | |
| 1832 | // not the sum. | |
| 1833 | val udn = carBrowseUdn ?: settings.preferredServerUdn.first() // Maintainer, 2026-10-29: search the server the car is browsing | |
| 1834 | if (udn != null) { | |
| 1835 | val results = coroutineScope { | |
| 1836 | val a = async { cdClient.searchBucketAlbumsByTitle(udn, query) } | |
| 1837 | val b = async { cdClient.searchBucketAlbumsByArtist(udn, query) } | |
| 1838 | val c = async { cdClient.searchBucketArtists(udn, query) } | |
| 1839 | val d = async { cdClient.searchBucketTracksByTitle(udn, query) } | |
| 1840 | val e = async { cdClient.searchBucketTracksByArtist(udn, query) } | |
| 1841 | listOf(a.await(), b.await(), c.await(), d.await(), e.await()) | |
| 1842 | } | |
| 1843 | // Merge with dedup by mediaId. Cap each leg at 20 and | |
| 1844 | // total at 100 so a wide search doesn't ship megabytes | |
| 1845 | // back to Auto. | |
| 1846 | val seen = mutableSetOf<String>() | |
| 1847 | results.forEach { result -> | |
| 1848 | if (result is BrowseResult.Success) { | |
| 1849 | result.items.take(20).forEach { didl -> | |
| 1850 | if (didl is DidlItem.Track) { | |
| 1851 | runCatching { | |
| 1852 | uriCache[didl.id] = android.net.Uri.parse(didl.resourceUrl) | |
| 1853 | } | |
| 1854 | } | |
| 1855 | if (didl.id !in seen && items.size < 100) { | |
| 1856 | items.add(didl.toMediaItem()) | |
| 1857 | seen.add(didl.id) | |
| 1858 | } | |
| 1859 | } | |
| 1860 | } | |
| 1861 | } | |
| 1862 | } | |
| 1863 | ||
| 1864 | future.set(LibraryResult.ofItemList(ImmutableList.copyOf(items), params)) | |
| 1865 | } catch (e: Exception) { | |
| 1866 | android.util.Log.e("EarhornAuto", "onGetSearchResult failed", e) | |
| 1867 | // Return empty results so Auto stops spinning rather than | |
| 1868 | // showing a permanent "searching" state. | |
| 1869 | future.set(LibraryResult.ofItemList(ImmutableList.of(), params)) | |
| 1870 | } | |
| 1871 | } | |
| 1872 | // Maintainer, 2026-10-29: up to ~130 items came back regardless of | |
| 1873 | // pageSize — same Media3 crash as onGetChildren; see paged(). | |
| 1874 | return paged(future, page, pageSize) | |
| 1875 | } | |
| 1876 | ||
| 1877 | /** | |
| 1878 | * Playback resumption — called by Auto (or the system) when it wants | |
| 1879 | * to restore the last session after the service was killed (e.g. car | |
| 1880 | * turned off then back on). Loads the persisted queue snapshot so Auto | |
| 1881 | * shows the Now Playing screen immediately instead of falling back to | |
| 1882 | * raw Bluetooth audio. | |
| 1883 | */ | |
| 1884 | override fun onPlaybackResumption( | |
| 1885 | mediaSession: MediaSession, | |
| 1886 | controller: MediaSession.ControllerInfo, | |
| 1887 | ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> { | |
| 1888 | val future = SettableFuture.create<MediaSession.MediaItemsWithStartPosition>() | |
| 1889 | scope.launch(Dispatchers.IO) { | |
| 1890 | try { | |
| 1891 | val saved = queueStore.load() | |
| 1892 | // Maintainer, 2026-10-29: Media3 hands these items straight to | |
| 1893 | // player.setMediaItems, so each one must carry a URI — | |
| 1894 | // toMediaItem now sets it, and tracks with a blank | |
| 1895 | // resourceUrl are skipped (they crashed ExoPlayer's | |
| 1896 | // DefaultMediaSourceFactory on the main thread). The start | |
| 1897 | // index moves to the first kept track at or after the saved | |
| 1898 | // one; the saved position applies only if that track survived (D1). | |
| 1899 | val tracks = saved?.tracks.orEmpty().map { it.toDomain() } | |
| 1900 | val keptIndices = tracks.indices.filter { tracks[it].resourceUrl.isNotBlank() } | |
| 1901 | if (saved != null && keptIndices.isNotEmpty()) { | |
| 1902 | val mediaItems = keptIndices.map { tracks[it].toMediaItem() } | |
| 1903 | val startIndex = keptIndices.indexOfFirst { it >= saved.currentIndex } | |
| 1904 | .let { if (it < 0) mediaItems.lastIndex else it } | |
| 1905 | .coerceIn(0, mediaItems.lastIndex) | |
| 1906 | val startPositionMs = | |
| 1907 | if (keptIndices[startIndex] == saved.currentIndex) saved.positionMs.coerceAtLeast(0L) | |
| 1908 | else 0L | |
| 1909 | future.set( | |
| 1910 | MediaSession.MediaItemsWithStartPosition( | |
| 1911 | mediaItems, startIndex, startPositionMs, | |
| 1912 | ) | |
| 1913 | ) | |
| 1914 | } else { | |
| 1915 | future.set(MediaSession.MediaItemsWithStartPosition(emptyList(), 0, 0L)) | |
| 1916 | } | |
| 1917 | } catch (e: Exception) { | |
| 1918 | android.util.Log.e("EarhornAuto", "Playback resumption failed", e) | |
| 1919 | future.set(MediaSession.MediaItemsWithStartPosition(emptyList(), 0, 0L)) | |
| 1920 | } | |
| 1921 | } | |
| 1922 | return future | |
| 1923 | } | |
| 1924 | ||
| 1925 | override fun onAddMediaItems( | |
| 1926 | mediaSession: MediaSession, | |
| 1927 | controller: MediaSession.ControllerInfo, | |
| 1928 | mediaItems: List<MediaItem>, | |
| 1929 | ): ListenableFuture<List<MediaItem>> { | |
| 1930 | // Resolve playback URIs. Decision tree per item: | |
| 1931 | // 1. requestMetadata.mediaUri set (own session call)? Use it. | |
| 1932 | // 2. uriCache contains mediaId (we browsed it earlier)? Use it. | |
| 1933 | // 3. mediaId looks like local-track? Reconstruct content URI. | |
| 1934 | // 4. Else: pass through unchanged (best effort). | |
| 1935 | // | |
| 1936 | // Step 2 is the critical one for Auto. When Auto's controller | |
| 1937 | // round-trips items back to the session via setMediaItem / | |
| 1938 | // addMediaItem, the IPC marshalling drops RequestMetadata. The | |
| 1939 | // mediaId is the only field reliably preserved. Without the | |
| 1940 | // cache, UPnP tracks from Auto's browse tree resolve to a null | |
| 1941 | // URI and the player silently no-ops, leaving the previously | |
| 1942 | // playing track in place — the "tap a song, nothing happens, | |
| 1943 | // old track keeps playing" report. | |
| 1944 | // | |
| 1945 | // Maintainer, 2026-10-29 (D2): step 4 is no longer "pass through". | |
| 1946 | // An item with no URI reached ExoPlayer and crashed it | |
| 1947 | // (checkNotNull(localConfiguration) on the main thread), e.g. | |
| 1948 | // "play X on Earhorn", which arrives as an empty mediaId plus | |
| 1949 | // requestMetadata.searchQuery. Now: | |
| 1950 | // 4. Item already carries a URI (in-process controller)? Keep it. | |
| 1951 | // 5. searchQuery set? Search (local files first, then the | |
| 1952 | // preferred UPnP server) — asynchronous, on IO. | |
| 1953 | // 6. Else: DROPPED, never handed to the player. | |
| 1954 | return Futures.transform<List<List<MediaItem>>, List<MediaItem>>( | |
| 1955 | resolvePerItem(mediaItems), | |
| 1956 | { perItem -> perItem.flatten() }, | |
| 1957 | MoreExecutors.directExecutor(), | |
| 1958 | ) | |
| 1959 | } | |
| 1960 | ||
| 1961 | /** Maintainer, 2026-10-29 (D2): same resolution as [onAddMediaItems] | |
| 1962 | * (the default implementation delegates there too), plus the start | |
| 1963 | * index is mapped onto the resolved list — a dropped item would | |
| 1964 | * otherwise shift it past the end and ExoPlayer throws | |
| 1965 | * IllegalSeekPositionException. When nothing at all is playable the | |
| 1966 | * request fails (Media3 reports it to the controller) instead of | |
| 1967 | * replacing the current queue with an empty one. */ | |
| 1968 | override fun onSetMediaItems( | |
| 1969 | mediaSession: MediaSession, | |
| 1970 | controller: MediaSession.ControllerInfo, | |
| 1971 | mediaItems: List<MediaItem>, | |
| 1972 | startIndex: Int, | |
| 1973 | startPositionMs: Long, | |
| 1974 | ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> { | |
| 1975 | return Futures.transformAsync<List<List<MediaItem>>, MediaSession.MediaItemsWithStartPosition>( | |
| 1976 | resolvePerItem(mediaItems), | |
| 1977 | { perItem -> | |
| 1978 | val flat = perItem.flatten() | |
| 1979 | if (flat.isEmpty() && mediaItems.isNotEmpty()) { | |
| 1980 | Futures.immediateFailedFuture<MediaSession.MediaItemsWithStartPosition>( | |
| 1981 | UnsupportedOperationException("No playable item in the request") | |
| 1982 | ) | |
| 1983 | } else { | |
| 1984 | val startDropped = startIndex != C.INDEX_UNSET && | |
| 1985 | perItem.getOrNull(startIndex).isNullOrEmpty() | |
| 1986 | val newStart = if (startIndex == C.INDEX_UNSET || flat.isEmpty()) startIndex | |
| 1987 | else perItem.take(startIndex).sumOf { it.size }.coerceAtMost(flat.lastIndex) | |
| 1988 | Futures.immediateFuture( | |
| 1989 | MediaSession.MediaItemsWithStartPosition( | |
| 1990 | flat, newStart, | |
| 1991 | if (startDropped) C.TIME_UNSET else startPositionMs, | |
| 1992 | ) | |
| 1993 | ) | |
| 1994 | } | |
| 1995 | }, | |
| 1996 | MoreExecutors.directExecutor(), | |
| 1997 | ) | |
| 1998 | } | |
| 1999 | ||
| 2000 | /** Maintainer, 2026-10-29 (D2): resolve each requested item to the | |
| 2001 | * playable items it stands for — one for a URI/cache/local-id hit, | |
| 2002 | * several for a search query, none when unresolvable. Synchronous | |
| 2003 | * (immediate future) unless a search is needed; searches run on IO | |
| 2004 | * and complete the future from the service scope, like onGetChildren. */ | |
| 2005 | private fun resolvePerItem(mediaItems: List<MediaItem>): ListenableFuture<List<List<MediaItem>>> { | |
| 2006 | val direct = mediaItems.map { resolveDirect(it) } | |
| 2007 | val queries = mediaItems.map { it.requestMetadata.searchQuery?.trim().orEmpty() } | |
| 2008 | val needsSearch = mediaItems.indices.any { direct[it] == null && queries[it].isNotEmpty() } | |
| 2009 | if (!needsSearch) { | |
| 2010 | direct.forEachIndexed { i, d -> | |
| 2011 | if (d == null) android.util.Log.w("EarhornAuto", "onAddMediaItems: no URI for ${mediaItems[i].mediaId} — dropped") | |
| 2012 | } | |
| 2013 | return Futures.immediateFuture(direct.map { listOfNotNull(it) }) | |
| 2014 | } | |
| 2015 | val future = SettableFuture.create<List<List<MediaItem>>>() | |
| 2016 | scope.launch(Dispatchers.IO) { | |
| 2017 | try { | |
| 2018 | val perItem = mediaItems.indices.map { i -> | |
| 2019 | val d = direct[i] | |
| 2020 | when { | |
| 2021 | d != null -> listOf(d) | |
| 2022 | queries[i].isNotEmpty() -> searchPlayable(queries[i]) | |
| 2023 | else -> emptyList() | |
| 2024 | } | |
| 2025 | } | |
| 2026 | future.set(perItem) | |
| 2027 | } catch (e: Exception) { | |
| 2028 | android.util.Log.e("EarhornAuto", "search-to-play failed", e) | |
| 2029 | future.setException(e) | |
| 2030 | } | |
| 2031 | } | |
| 2032 | return future | |
| 2033 | } | |
| 2034 | ||
| 2035 | /** Steps 1–4 of the [onAddMediaItems] decision tree; null = unresolved. */ | |
| 2036 | private fun resolveDirect(item: MediaItem): MediaItem? { | |
| 2037 | val direct = item.requestMetadata.mediaUri | |
| 2038 | if (direct != null) { | |
| 2039 | return item.buildUpon().setUri(direct).build() | |
| 2040 | } | |
| 2041 | val cached = uriCache[item.mediaId] | |
| 2042 | if (cached != null) { | |
| 2043 | return item.buildUpon().setUri(cached).build() | |
| 2044 | } | |
| 2045 | val mid = item.mediaId | |
| 2046 | val lms = dev.stave.local.LocalMediaScanner | |
| 2047 | if (mid.startsWith("${lms.LOCAL_PREFIX}track:")) { | |
| 2048 | val trackId = mid.removePrefix("${lms.LOCAL_PREFIX}track:").toLongOrNull() | |
| 2049 | if (trackId != null) { | |
| 2050 | val contentUri = android.content.ContentUris.withAppendedId( | |
| 2051 | android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, | |
| 2052 | trackId, | |
| 2053 | ) | |
| 2054 | return item.buildUpon().setUri(contentUri).build() | |
| 2055 | } | |
| 2056 | } | |
| 2057 | if (item.localConfiguration != null) return item | |
| 2058 | return null | |
| 2059 | } | |
| 2060 | ||
| 2061 | /** Tracks matching [query] as playable items (URI set): local files | |
| 2062 | * first; if none, the preferred UPnP server's track search (title | |
| 2063 | * and artist), bounded so a silent server can't stall the request. */ | |
| 2064 | private suspend fun searchPlayable(query: String): List<MediaItem> { | |
| 2065 | val limit = 50 | |
| 2066 | val lms = dev.stave.local.LocalMediaScanner | |
| 2067 | val local = localScanner.searchTracks(query).take(limit).map { track -> | |
| 2068 | MediaItem.Builder() | |
| 2069 | .setMediaId("${lms.LOCAL_PREFIX}track:${track.id}") | |
| 2070 | .setUri(track.contentUri) | |
| 2071 | .setMediaMetadata( | |
| 2072 | MediaMetadata.Builder() | |
| 2073 | .setTitle(track.title) | |
| 2074 | .setArtist(track.artist ?: track.albumArtist) | |
| 2075 | .setAlbumTitle(track.album) | |
| 2076 | .setIsBrowsable(false) | |
| 2077 | .setIsPlayable(true) | |
| 2078 | .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) | |
| 2079 | .apply { track.artUri?.let { setArtworkUri(it) } } | |
| 2080 | .build() | |
| 2081 | ) | |
| 2082 | .build() | |
| 2083 | } | |
| 2084 | if (local.isNotEmpty()) return local | |
| 2085 | val udn = carBrowseUdn ?: settings.preferredServerUdn.first() ?: return emptyList() // Maintainer, 2026-10-29: same server as car browsing | |
| 2086 | val results = kotlinx.coroutines.withTimeoutOrNull(15_000L) { | |
| 2087 | coroutineScope { | |
| 2088 | val byTitle = async { cdClient.searchBucketTracksByTitle(udn, query) } | |
| 2089 | val byArtist = async { cdClient.searchBucketTracksByArtist(udn, query) } | |
| 2090 | listOf(byTitle.await(), byArtist.await()) | |
| 2091 | } | |
| 2092 | }.orEmpty() | |
| 2093 | return results | |
| 2094 | .flatMap { (it as? BrowseResult.Success)?.items.orEmpty() } | |
| 2095 | .filterIsInstance<DidlItem.Track>() | |
| 2096 | .filter { it.resourceUrl.isNotBlank() } | |
| 2097 | .distinctBy { it.id } | |
| 2098 | .take(limit) | |
| 2099 | .map { it.toMediaItem() } | |
| 2100 | } | |
| 2101 | } | |
| 2102 | } | |
| 2103 | ||
| 2104 | /** Convert a UPnP DidlItem to a Media3 MediaItem for the Auto browse tree. */ | |
| 2105 | private fun DidlItem.toMediaItem(): MediaItem { | |
| 2106 | return when (this) { | |
| 2107 | is DidlItem.Container -> { | |
| 2108 | MediaItem.Builder() | |
| 2109 | .setMediaId(id) | |
| 2110 | .setMediaMetadata( | |
| 2111 | MediaMetadata.Builder() | |
| 2112 | .setTitle(title) | |
| 2113 | .setArtist(artist) | |
| 2114 | .setIsBrowsable(true) | |
| 2115 | .setIsPlayable(false) | |
| 2116 | .setMediaType( | |
| 2117 | if (isAlbum) MediaMetadata.MEDIA_TYPE_ALBUM | |
| 2118 | else MediaMetadata.MEDIA_TYPE_FOLDER_MIXED | |
| 2119 | ) | |
| 2120 | .apply { | |
| 2121 | albumArtUri?.let { | |
| 2122 | setArtworkUri(android.net.Uri.parse(it)) | |
| 2123 | } | |
| 2124 | } | |
| 2125 | .build() | |
| 2126 | ) | |
| 2127 | .build() | |
| 2128 | } | |
| 2129 | is DidlItem.Track -> { | |
| 2130 | MediaItem.Builder() | |
| 2131 | .setMediaId(id) | |
| 2132 | // Maintainer, 2026-10-29: a real playback URI, not only | |
| 2133 | // RequestMetadata.mediaUri — items that reach the player | |
| 2134 | // directly (playback resumption, search-resolved plays) need | |
| 2135 | // localConfiguration or ExoPlayer throws (D1). | |
| 2136 | .apply { if (resourceUrl.isNotBlank()) setUri(resourceUrl) } | |
| 2137 | .setRequestMetadata( | |
| 2138 | MediaItem.RequestMetadata.Builder() | |
| 2139 | .setMediaUri(android.net.Uri.parse(resourceUrl)) | |
| 2140 | .build() | |
| 2141 | ) | |
| 2142 | .setMediaMetadata( | |
| 2143 | MediaMetadata.Builder() | |
| 2144 | .setTitle(title) | |
| 2145 | .setArtist(artist ?: albumArtist) | |
| 2146 | .setAlbumTitle(album) | |
| 2147 | .setTrackNumber(trackNumber) | |
| 2148 | .setDiscNumber(discNumber) | |
| 2149 | .setGenre(genre) | |
| 2150 | .setRecordingYear( | |
| 2151 | date?.let { Regex("""\d{4}""").find(it)?.value?.toIntOrNull() } | |
| 2152 | ) | |
| 2153 | .setIsBrowsable(false) | |
| 2154 | .setIsPlayable(true) | |
| 2155 | .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) | |
| 2156 | .apply { | |
| 2157 | albumArtUri?.let { | |
| 2158 | setArtworkUri(android.net.Uri.parse(it)) | |
| 2159 | } | |
| 2160 | duration?.inWholeMilliseconds?.let { | |
| 2161 | setExtras(Bundle().apply { putLong("duration_ms", it) }) | |
| 2162 | } | |
| 2163 | } | |
| 2164 | .build() | |
| 2165 | ) | |
| 2166 | .build() | |
| 2167 | } | |
| 2168 | } | |
| 2169 | } |