Native Android client for Spotify, built with Jetpack Compose
Kotlin ad-freeadblockandroidjetpack-composekotlinlyricsmusic-playermusic-videomyspotispotifyspotify-adblockerspotify-clientspotify-connectspotui
Frozen player page reloaded at once; volume guard; faster sound after skips; refused plays retried; GrapheneOS load watchdog; smart shuffle fixes; followers lists, artist liked songs, playlist episodes, greyed unavailable songs, fast scrollbar, share as image, swipe up for lyrics, foldable player, autoplay, accent colour, rotation
kota-zocd03d1f0b7e4
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex dd2e2214..e5d86136 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -5,6 +5,15 @@ Each release on GitHub shows its section below. The app shows it too when it off## Unreleased- **Myspoti's icon in the notification** and in Samsung's Now Bar, instead of a generic music note.+- **Music no longer stops for a minute**: a Web Player page that stops answering is reloaded at once, and playback goes on.+- **No more silent songs**: the sound comes back by itself if a skip or a muted ad left it at zero; after a skip it comes back as soon as the next song is there.+- **Smart shuffle** goes on from where the song is (no restart), adds songs to every playlist, and has its own icon in the player.+- **Free accounts refused by Spotify** (some countries): the list plays from its start instead, and a message explains why.+- **GrapheneOS**: the player loads with "secure app spawning" on.+- **Followers and following** lists on profiles; **your liked songs** on artist pages; **episodes** in playlists; unavailable songs greyed out.+- **Fast scrollbar** on long playlists and the library.+- **Share as image** (Instagram story and more); swipe up on the cover for the lyrics; player fits foldables and wide screens.+- **Settings**: autoplay on or off, accent colour, screen rotation (portrait, automatic, landscape).## 2.0.0-beta.6diff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.ktindex 5b90e245..5a6631fe 100644--- a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.kt+++ b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.kt@@ -47,6 +47,23 @@ internal fun track(d: JsonElement?, uid: String? = null): Track? {)}+/** A playlist row: a track, or an episode shaped as a `Track` (show name as the artist, show/episode art as the album). */+internal fun playlistItem(d: JsonElement?, uid: String? = null): Track? {+ if (d.str("uri")?.startsWith("spotify:episode:") != true) return track(d, uid)+ val e = episode(d) ?: return null+ val cover = e.images.ifEmpty { e.show?.images.orEmpty() }+ return Track(+ uri = e.uri,+ name = e.name,+ durationMs = e.durationMs,+ artists = e.show?.let { listOf(ArtistRef(it.uri, it.name)) }.orEmpty(),+ album = AlbumRef("", e.show?.name ?: "", cover),+ explicit = e.explicit,+ playable = e.playable,+ uid = uid,+ )+}+internal fun artist(d: JsonElement?): Artist? {val uri = d.str("uri") ?: return nullreturn Artist(@@ -118,6 +135,7 @@ internal fun nowPlaying(t: JsonElement?): NowPlaying? {imageUrl = t.str("image"),durationMs = t.long("durationMs") ?: 0,explicit = t.bool("explicit") ?: false,+ provider = t.str("provider"),)}diff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyLibrary.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyLibrary.ktindex 50fbcef4..afba5b1c 100644--- a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyLibrary.kt+++ b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyLibrary.kt@@ -169,7 +169,7 @@ class SpotifyPlaylists(private val gql: Gql, private val bridge: Bridge, private"uri" to uri, "offset" to offset, "limit" to limit, "includeEpisodeContentRatingsV2" to true,)).entity("data.playlistV2", "fetchPlaylistContents")val content = p.at("content")- val items = content.list("items").mapNotNull { track(it.at("itemV2.data"), it.str("uid"))?.copy(addedAt = it.str("addedAt.isoString")) }+ val items = content.list("items").mapNotNull { playlistItem(it.at("itemV2.data"), it.str("uid"))?.copy(addedAt = it.str("addedAt.isoString")) }val total = content.int("totalCount") ?: items.sizereturn Page(items, offset, total, (offset + limit).takeIf { it < total })}diff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyMore.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyMore.ktindex e6c9355c..bab20d62 100644--- a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyMore.kt+++ b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyMore.kt@@ -206,6 +206,18 @@ class SpotifyUsers(private val gql: Gql, private val bridge: Bridge, private val)}+ override suspend fun followers(userUri: Uri): List<UserRef> = profileList(userUri, "followers")+ override suspend fun following(userUri: Uri): List<UserRef> = profileList(userUri, "following")++ private suspend fun profileList(userUri: Uri, kind: String): List<UserRef> {+ val id = URLEncoder.encode(idOf(userUri), "UTF-8")+ val r = http.getJson("https://spclient.wg.spotify.com/user-profile-view/v3/profile/$id/$kind?market=from_token") ?: return emptyList()+ return r.list("profiles").mapNotNull { f ->+ val uri = f.str("uri") ?: return@mapNotNull null+ UserRef(uri, f.str("name") ?: idOf(uri), f.str("image_url"))+ }.distinctBy { it.uri }+ }+override suspend fun top(range: TimeRange, limit: Int): TopContent {val input = mapOf("offset" to 0, "limit" to limit, "sortBy" to "AFFINITY", "timeRange" to range.name)val p = gql.query("userTopContent", vars(diff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyPlayer.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyPlayer.ktindex c464b35f..2fc1bb53 100644--- a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyPlayer.kt+++ b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/SpotifyPlayer.kt@@ -57,6 +57,18 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScop/** The order given to the last [play] (context uri to songs), kept for a stall restart. */@Volatile private var lastOrder: Pair<Uri, List<Uri>>? = null+ /** The volume the user wants (0..1), put back when the page is left silent by mistake. */+ @Volatile private var wantedVolume: Double? = null+ /** The last [play] sent: (context, track, when), for a refused command's retry. */+ @Volatile private var lastPlay: Triple<Uri, Uri?, Long>? = null+ @Volatile private var refusedRetried = false+ private val _refused = kotlinx.coroutines.flow.MutableSharedFlow<Unit>(extraBufferCapacity = 1)+ /**+ * Spotify refused a play even after the retry (free accounts in some countries can't+ * pick a song): the UI says so.+ */+ val refused: kotlinx.coroutines.flow.SharedFlow<Unit> = _refused+/** Reloads the Web Player page (set by the host); used when a stalled player does not recover. */@Volatile var reloadHost: (suspend () -> Unit)? = null@@ -70,6 +82,7 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopwhen (type) {"state" -> onState(playerState(payload))"queue" -> queue(payload)?.let { q -> _queue.value = q.copy(nextUp = q.nextUp.filter { it.kind != ItemKind.AD }) }+ "refused" -> onRefused()}}}@@ -87,16 +100,44 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScop}}+ /** Reloads the page, waits for it, then plays on from [s]. */+ private suspend fun reloadAndPlayOn(s: PlayerState?) {+ val reload = reloadHost ?: return+ runCatching {+ reload()+ withTimeoutOrNull(45_000) { delay(1_500); bridge.ready.first { it } } ?: return@runCatching+ delay(1_500)+ s?.let { playOn(it) }+ }+ }+private suspend fun watchStalls() {var key: String? = nullvar since = 0Lvar attempts = 0var adAttempts = 0var adReloaded = false+ var frozenCheckAt = 0L+ var frozenReloadAt = 0L+ var tick = 0while (true) {delay(WATCH_TICK_MS)+ tick++val s = _state.valueval now = System.currentTimeMillis()+ // A call timed out: is the page frozen (nothing answers, not even a sync call)?+ // Then reload at once instead of waiting for each 20 s timeout to pass.+ if (bridge.ready.value && now - bridge.lastTimeoutAt < FROZEN_WINDOW_MS && now - frozenCheckAt > FROZEN_WINDOW_MS) {+ frozenCheckAt = now+ if (!bridge.ping() && now - frozenReloadAt > FROZEN_RELOAD_GAP_MS) {+ frozenReloadAt = now+ bridge.logger?.invoke("page not answering: reloading the player")+ reloadAndPlayOn(if (pausedByUser) null else lastTrackState)+ key = null; attempts = 0+ continue+ }+ }+ if (tick % VOLUME_CHECK_TICKS == 0) guardVolume(s)if (_adPlaying.value) {val ad = adState// A refused ad sits at 0:00, buffering; a real one plays to its end.@@ -114,13 +155,7 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopadAttempts = 0adReloaded = truebridge.logger?.invoke("ad stuck on ${ad?.item?.name}: reloading the player")- val reload = reloadHost- if (reload != null) runCatching {- reload()- withTimeoutOrNull(45_000) { delay(1_500); bridge.ready.first { it } } ?: return@runCatching- delay(1_500)- last?.let { playOn(it) }- } else last?.let { runCatching { playOn(it) } }+ if (reloadHost != null) reloadAndPlayOn(last) else last?.let { runCatching { playOn(it) } }}adSince = System.currentTimeMillis()}@@ -137,20 +172,41 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopsince = nowattempts++bridge.logger?.invoke("player stalled ($reason) on ${s.item?.name}, attempt $attempts")+ // A frozen page answers nothing: straight to the reload.+ if (attempts == 1 && !bridge.ping()) attempts = 2if (attempts == 1) runCatching { playOn(s) }else {attempts = 0- val reload = reloadHost ?: continue- runCatching {- reload()- withTimeoutOrNull(45_000) { delay(1_500); bridge.ready.first { it } } ?: return@runCatching- delay(1_500)- playOn(s)- }+ reloadAndPlayOn(s)}}}+ /**+ * The page left silent while a song plays: a fade or an ad mute whose volume call was+ * lost (page busy, reloaded). The sound comes back to what the user wants.+ */+ private suspend fun guardVolume(s: PlayerState?) {+ if (s == null || s.isPaused || s.isBuffering || _adPlaying.value || fadeBackTo != null || fadeBack?.isActive == true) return+ val wanted = wantedVolume ?: 1.0+ if (wanted <= 0.0) return+ val v = runCatching { volume() }.getOrNull() ?: return+ if (v > 0.0) { if (volumeBeforeAd != null) volumeBeforeAd = null; return }+ bridge.logger?.invoke("page silent during a song: volume back to $wanted")+ volumeBeforeAd = null+ runCatching { setLevel(wanted) }+ }++ /** Spotify refused the last play: once, the list is played from its start instead. */+ private fun onRefused() {+ val last = lastPlay ?: return+ if (System.currentTimeMillis() - last.third > REFUSED_WINDOW_MS) return+ if (refusedRetried || last.second == null) { _refused.tryEmit(Unit); return }+ refusedRetried = true+ bridge.logger?.invoke("play refused by Spotify: playing the list without picking the song")+ scope.launch { runCatching { bridge.call("player.play", buildJsonObject { put("contextUri", last.first) }, timeoutMs = PLAY_TIMEOUT_MS) } }+ }+/** Plays the song after [s] (or [s] again when it is the last one) in its context. */private suspend fun playOn(s: PlayerState) {val ctx = s.contextUri@@ -195,7 +251,8 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopval s = _state.value// Nothing heard (paused, an ad muted): nothing to fade.if (s == null || s.isPaused || _adPlaying.value || volumeBeforeAd != null) { block(); return }- val target = fadeBackTo ?: runCatching { volume() }.getOrNull()?.takeIf { it > 0.0 } ?: run { block(); return }+ val target = fadeBackTo ?: runCatching { volume() }.getOrNull()?.takeIf { it > 0.0 }?.also { wantedVolume = it } ?: run { block(); return }+ val from = s.item?.urifadeBackTo = targetfadeBack?.cancel()runCatching { for (f in FADE_STEPS) { setLevel(target * f); delay(FADE_STEP_MS) } }@@ -204,8 +261,12 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScop} finally {fadeBack = scope.launch {delay(FADE_STEP_MS * 3)- // The next song really plays (or give up waiting): the sound comes back.- withTimeoutOrNull(FADE_BACK_MAX_MS) { _state.first { it != null && !it.isBuffering && !it.isPaused } }+ // The next song is there (or give up waiting): the sound comes back. Buffering+ // is not waited for: nothing is heard meanwhile, and a page that keeps saying+ // "buffering" while it plays would leave the song's start muted.+ withTimeoutOrNull(FADE_BACK_MAX_MS) {+ _state.first { it != null && !it.isPaused && (it.item?.uri != from || it.positionMs < 1_500) }+ }if (_adPlaying.value) { if (volumeBeforeAd == null) volumeBeforeAd = target; fadeBackTo = null; return@launch }val back = fadeBackTo ?: targetrunCatching { for (f in FADE_STEPS.reversed().drop(1)) { setLevel(back * f); delay(FADE_STEP_MS) }; setLevel(back) }@@ -216,7 +277,7 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScop}private suspend fun muteForAd() = runCatching {- if (volumeBeforeAd == null) volumeBeforeAd = fadeBackTo ?: volume().takeIf { it > 0.0 } ?: 1.0+ if (volumeBeforeAd == null) volumeBeforeAd = fadeBackTo ?: volume().takeIf { it > 0.0 } ?: wantedVolume?.takeIf { it > 0.0 } ?: 1.0bridge.call("volume.set", buildJsonObject { put("level", 0.0) })}@@ -228,9 +289,11 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopoverride suspend fun play(contextUri: Uri, trackUri: Uri?, index: Int?, positionMs: Long?, order: List<Uri>?) {lastOrder = order?.let { contextUri to it }+ lastPlay = Triple(contextUri, trackUri, System.currentTimeMillis())+ refusedRetried = falsepausedByUser = falsewithFade {- bridge.call("player.play", buildJsonObject {+ bridge.call("player.play", timeoutMs = PLAY_TIMEOUT_MS, args = buildJsonObject {put("contextUri", contextUri)order?.let { uris -> putJsonArray("order") { uris.forEach { add(kotlinx.serialization.json.JsonPrimitive(it)) } } }trackUri?.let { put("trackUri", it) }@@ -292,6 +355,7 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopoverride suspend fun volume(): Double = bridge.call("volume.get").jsonPrimitive.doubleoverride suspend fun setVolume(level: Double) {+ wantedVolume = level.coerceIn(0.0, 1.0)if (fadeBackTo != null) fadeBackTo = level.coerceIn(0.0, 1.0)bridge.call("volume.set", buildJsonObject { put("level", level.coerceIn(0.0, 1.0)) })}@@ -328,7 +392,17 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScopval FADE_STEPS = listOf(0.55, 0.25, 0.08, 0.0)const val FADE_STEP_MS = 25L/** The sound always comes back after that long, whatever the page does. */- const val FADE_BACK_MAX_MS = 4_000L+ const val FADE_BACK_MAX_MS = 2_500L+ /** Play commands: the page answers within a few seconds or not at all. */+ const val PLAY_TIMEOUT_MS = 10_000L+ /** A refusal that long after a play belongs to it. */+ const val REFUSED_WINDOW_MS = 5_000L+ /** After a timed-out call, the page is pinged at most once per window. */+ const val FROZEN_WINDOW_MS = 25_000L+ /** Never two "frozen page" reloads closer than that. */+ const val FROZEN_RELOAD_GAP_MS = 60_000L+ /** The volume is checked every that many ticks. */+ const val VOLUME_CHECK_TICKS = 3/** An ad that really plays (muted) is skipped after that long. */const val AD_PLAYING_SKIP_MS = 1_500Lconst val STUCK_MS = 8_000Ldiff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/bridge/Bridge.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/bridge/Bridge.ktindex 9b96bbc0..cb96de05 100644--- a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/bridge/Bridge.kt+++ b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/bridge/Bridge.kt@@ -71,6 +71,8 @@ class Bridge(private val host: BridgeHost, scope: CoroutineScope) {}"state" -> _events.tryEmit("state" to (msg["state"] ?: JsonNull))"queue" -> _events.tryEmit("queue" to (msg["queue"] ?: JsonNull))+ // Spotify refused a playback command (HTTP 402/403 on Connect), see ControlRelay.+ "refused" -> _events.tryEmit("refused" to msg)"error" -> _ready.value = false}}@@ -81,6 +83,16 @@ class Bridge(private val host: BridgeHost, scope: CoroutineScope) {host.evaluate(BridgeScript.source)}+ /** When a call last timed out (0: never). A frozen page times out every call. */+ @Volatile var lastTimeoutAt = 0L+ private set++ /**+ * True when the page answers a trivial call within [timeoutMs]. `bridge.version` is+ * synchronous in the page: no answer means the page itself is frozen, not the player busy.+ */+ suspend fun ping(timeoutMs: Long = 3_000): Boolean = runCatching { call("bridge.version", timeoutMs = timeoutMs) }.isSuccess+suspend fun call(method: String, args: JsonObject = JsonObject(emptyMap()), timeoutMs: Long = 20_000): JsonElement {val id = ids.incrementAndGet()val waiter = CompletableDeferred<JsonElement>()@@ -101,6 +113,7 @@ class Bridge(private val host: BridgeHost, scope: CoroutineScope) {logger?.invoke("call #$id $method ok in ${System.currentTimeMillis() - started} ms: $shown")}} catch (e: Exception) {+ if (e is BridgeException && e.message?.startsWith("timeout") == true) lastTimeoutAt = System.currentTimeMillis()logger?.invoke("call #$id $method FAILED after ${System.currentTimeMillis() - started} ms: ${e.message}")throw e}diff --git a/base/api/src/main/kotlin/app/myspoti/api/Api.kt b/base/api/src/main/kotlin/app/myspoti/api/Api.ktindex 9a68283e..98435218 100644--- a/base/api/src/main/kotlin/app/myspoti/api/Api.kt+++ b/base/api/src/main/kotlin/app/myspoti/api/Api.kt@@ -178,6 +178,10 @@ interface Podcasts {interface Users {suspend fun me(): Accountsuspend fun profile(userUri: Uri): UserProfile+ /** People following this user. */+ suspend fun followers(userUri: Uri): List<UserRef>+ /** People this user follows. */+ suspend fun following(userUri: Uri): List<UserRef>suspend fun top(range: TimeRange = TimeRange.SHORT_TERM, limit: Int = 10): TopContentsuspend fun follow(userUris: List<Uri>)suspend fun unfollow(userUris: List<Uri>)diff --git a/base/api/src/main/kotlin/app/myspoti/api/Models.kt b/base/api/src/main/kotlin/app/myspoti/api/Models.ktindex 170b1461..fb026997 100644--- a/base/api/src/main/kotlin/app/myspoti/api/Models.kt+++ b/base/api/src/main/kotlin/app/myspoti/api/Models.kt@@ -113,6 +113,8 @@ data class NowPlaying(val imageUrl: String?,val durationMs: Long,val explicit: Boolean = false,+ /** Where the player took this item from ("context", "queue", "autoplay"...), when it says. */+ val provider: String? = null,)data class PlayerRestrictions(diff --git a/base/app/src/main/AndroidManifest.xml b/base/app/src/main/AndroidManifest.xmlindex a2ce9e89..c39520ce 100644--- a/base/app/src/main/AndroidManifest.xml+++ b/base/app/src/main/AndroidManifest.xml@@ -35,6 +35,16 @@android:name="com.music.spotui.di.ArtworkProvider"android:authorities="${applicationId}.artwork"android:exported="true" />+ <!-- Share-as-image cards, handed to the target app through a read grant. -->+ <provider+ android:name="androidx.core.content.FileProvider"+ android:authorities="${applicationId}.fileprovider"+ android:exported="false"+ android:grantUriPermissions="true">+ <meta-data+ android:name="android.support.FILE_PROVIDER_PATHS"+ android:resource="@xml/file_paths" />+ </provider><!-- Lets the system profiler (Perfetto, Android Studio) trace release builds; no debugging. --><profileable android:shell="true" />@@ -57,7 +67,7 @@android:name="app.myspoti.MainActivity"android:exported="true"android:launchMode="singleTask"- android:screenOrientation="portrait"+ android:screenOrientation="unspecified"android:supportsPictureInPicture="true"android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"android:windowSoftInputMode="adjustResize"diff --git a/base/app/src/main/java/app/myspoti/MainActivity.kt b/base/app/src/main/java/app/myspoti/MainActivity.ktindex 2331fa83..63ec969a 100644--- a/base/app/src/main/java/app/myspoti/MainActivity.kt+++ b/base/app/src/main/java/app/myspoti/MainActivity.kt@@ -48,12 +48,18 @@ class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)+ // The user's rotation choice (portrait by default); changes are applied from the UI below.+ requestedOrientation = com.music.spotui.data.preferences.OrientationPref.requested()signedIn = prefs.getBoolean("LoggedIn", false)setupNeeded = com.music.spotui.ui.screens.Setup.needed(this)root = FrameLayout(this)val compose = ComposeView(this).apply {setContent {SpotuiTheme {+ val orientation = com.music.spotui.data.preferences.OrientationPref.mode+ androidx.compose.runtime.LaunchedEffect(orientation) {+ requestedOrientation = com.music.spotui.data.preferences.OrientationPref.requested()+ }androidx.compose.foundation.layout.Box(androidx.compose.ui.Modifier.fillMaxSize()) {when {showSpotiflac -> com.music.spotui.ui.screens.SpotiflacScreen(onClose = { showSpotiflac = false })diff --git a/base/app/src/main/java/com/music/spotui/data/api/Api.kt b/base/app/src/main/java/com/music/spotui/data/api/Api.ktindex cb82f4cc..fd110aad 100644--- a/base/app/src/main/java/com/music/spotui/data/api/Api.kt+++ b/base/app/src/main/java/com/music/spotui/data/api/Api.kt@@ -114,6 +114,18 @@ class Api constructor(fun songOf(t: Track): SongsModel {val id = t.uri.substringAfterLast(':')val singer = t.artists.joinToString(", ") { it.name }+ if (t.uri.startsWith("spotify:episode:")) return SongsModel(+ id = stableId("episode:$id"),+ title = t.name.take(128),+ album = t.album?.name.orEmpty(),+ singer = singer,+ coverUri = cover(t.album?.images.orEmpty()),+ url = "episode:$id",+ explicit = t.explicit,+ durationMs = t.durationMs.toInt(),+ addedAt = t.addedAt.orEmpty(),+ playable = t.playable,+ )return SongsModel(id = stableId("track:$id"),title = t.name.take(128),@@ -126,6 +138,8 @@ class Api constructor(durationMs = t.durationMs.toInt(),albumId = t.album?.uri?.substringAfterLast(':').orEmpty(),addedAt = t.addedAt.orEmpty(),+ playable = t.playable,+ artistIds = t.artists.map { it.uri.substringAfterLast(':') },)}diff --git a/base/app/src/main/java/com/music/spotui/data/api/SupportReminder.kt b/base/app/src/main/java/com/music/spotui/data/api/SupportReminder.ktindex 1cac2191..123d4d7b 100644--- a/base/app/src/main/java/com/music/spotui/data/api/SupportReminder.kt+++ b/base/app/src/main/java/com/music/spotui/data/api/SupportReminder.kt@@ -49,8 +49,8 @@ object SupportReminder {var icon by mutableStateOf(Accent.GREEN)private set- /** The colour the whole app uses for its accent (Spotify green unless a supporter chose another). */- val accentColor: Color get() = if (level != Level.NONE) accent.color else Accent.GREEN.color+ /** The colour the whole app uses for its accent (Spotify green unless another was chosen in Settings). */+ val accentColor: Color get() = accent.color/** When the next reminder is due. */fun nextAt(firstSeen: Long, lastShown: Long, level: Level, supportedAt: Long): Long = when (level) {diff --git a/base/app/src/main/java/com/music/spotui/data/entity/SongsModel.kt b/base/app/src/main/java/com/music/spotui/data/entity/SongsModel.ktindex eafb09f9..c9ff7623 100644--- a/base/app/src/main/java/com/music/spotui/data/entity/SongsModel.kt+++ b/base/app/src/main/java/com/music/spotui/data/entity/SongsModel.kt@@ -21,6 +21,10 @@ data class SongsModel(val albumId : String = "",// When it was added to the playlist or to Liked Songs (ISO 8601), for "Sort by date added".val addedAt : String = "",+ // False when Spotify marks the track unavailable (region, removed); rows are dimmed.+ val playable : Boolean = true,+ // Spotify ids of the artists, for "liked songs by this artist". Empty in older caches.+ val artistIds : List<String> = emptyList(),){constructor() : this(-1 ,"" ,"" ,"" ,"" ,"", "")}diff --git a/base/app/src/main/java/com/music/spotui/data/preferences/SettingsPref.kt b/base/app/src/main/java/com/music/spotui/data/preferences/SettingsPref.ktindex 1e675890..b9f3ecad 100644--- a/base/app/src/main/java/com/music/spotui/data/preferences/SettingsPref.kt+++ b/base/app/src/main/java/com/music/spotui/data/preferences/SettingsPref.kt@@ -30,6 +30,40 @@ object SolidNavBar {}}+/** "When your music ends, keep playing similar songs" (on by default). Read by the player. */+object AutoplayPref {+ private const val KEY = "autoplay_similar"+ var on by androidx.compose.runtime.mutableStateOf(prefs(com.music.spotui.di.Graph.app).getBoolean(KEY, true))+ private set++ fun set(c: Context, value: Boolean) {+ on = value+ prefs(c).edit().putBoolean(KEY, value).apply()+ }+}++/** Screen rotation: portrait (the default), automatic (follows the system), or landscape. */+object OrientationPref {+ private const val KEY = "screen_orientation"+ const val PORTRAIT = "portrait"+ const val AUTO = "auto"+ const val LANDSCAPE = "landscape"+ var mode by androidx.compose.runtime.mutableStateOf(prefs(com.music.spotui.di.Graph.app).getString(KEY, PORTRAIT) ?: PORTRAIT)+ private set++ fun set(c: Context, value: String) {+ mode = value+ prefs(c).edit().putString(KEY, value).apply()+ }++ /** The [android.content.pm.ActivityInfo] value for the chosen mode. */+ fun requested(): Int = when (mode) {+ AUTO -> android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED+ LANDSCAPE -> android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE+ else -> android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT+ }+}+/** Library layout: false = rows (default), true = Spotify-style 3-column grid. */fun isLibraryGridView(c: Context): Boolean = prefs(c).getBoolean(KEY_LIBRARY_GRID, false)fun setLibraryGridView(c: Context, v: Boolean) = prefs(c).edit().putBoolean(KEY_LIBRARY_GRID, v).apply()diff --git a/base/app/src/main/java/com/music/spotui/di/SongPlayer.kt b/base/app/src/main/java/com/music/spotui/di/SongPlayer.ktindex 60132338..c528fad3 100644--- a/base/app/src/main/java/com/music/spotui/di/SongPlayer.kt+++ b/base/app/src/main/java/com/music/spotui/di/SongPlayer.kt@@ -149,6 +149,11 @@ object SongPlayer {}scope.launch { api.player.queue.collect { q -> if (acceptsSessionUpdates()) applyQueue(q) } }scope.launch { api.library.changes.collect { refreshCurrentLiked() } }+ scope.launch {+ MyspotiRuntime.spotify.player.refused.collect {+ android.widget.Toast.makeText(Graph.app, app.myspoti.engine.R.string.play_refused, android.widget.Toast.LENGTH_LONG).show()+ }+ }PlaybackService.controls = Controls}@@ -282,6 +287,9 @@ object SongPlayer {playing = isPlaying())}+ /** The autoplay item already paused on, so it is paused once, not on every state. */+ private var autoplayHandledUri = ""+private fun applyState(s: PlayerState?) {if (s == null) returnstateSeen = true@@ -316,6 +324,11 @@ object SongPlayer {positionAt = SystemClock.elapsedRealtime()}val trackChanged = uri != _nowPlaying.value.uri+ // Autoplay off: stop once, when the player moves on to a track it picked itself.+ if (item != null && item.provider == "autoplay" && uri != autoplayHandledUri && !com.music.spotui.data.preferences.AutoplayPref.on) {+ autoplayHandledUri = uri+ if (!s.isPaused) pauseSilently()+ }currentContextUri = s.contextUri.orEmpty()if (item != null) { checkEndOfTrackTimer(id); currentTrackId = id }_nowPlaying.value = NowPlaying(@@ -486,7 +499,7 @@ object SongPlayer {* the list it was picked from; when null, the last list that registered this track is used.*//** [order]: the context's track uris in the order to play them (a sorted playlist). */- fun playSong(song: String, context: Context? = null, contextUri: String? = null, order: List<String>? = null) {+ fun playSong(song: String, context: Context? = null, contextUri: String? = null, order: List<String>? = null, positionMs: Long? = null) {// Data saver on mobile data: Spotify can't stream, only downloads and Local Files play.if (com.music.spotui.data.DataSaver.active) {main.post {@@ -502,7 +515,7 @@ object SongPlayer {markPending(if (episodeId != null) "" else trackId, itemUri)transport { isLatest ->playChecked(itemUri, isLatest) {- if (ctx != null) api.player.play(ctx, trackUri = itemUri, order = order?.takeIf { ctx == contextUri })+ if (ctx != null) api.player.play(ctx, trackUri = itemUri, positionMs = positionMs, order = order?.takeIf { ctx == contextUri })else api.player.play(itemUri)}}diff --git a/base/app/src/main/java/com/music/spotui/ui/components/FastScrollbar.kt b/base/app/src/main/java/com/music/spotui/ui/components/FastScrollbar.ktnew file mode 100644index 00000000..87c7c32d--- /dev/null+++ b/base/app/src/main/java/com/music/spotui/ui/components/FastScrollbar.kt@@ -0,0 +1,84 @@+package com.music.spotui.ui.components++import androidx.compose.foundation.background+import androidx.compose.foundation.gestures.detectVerticalDragGestures+import androidx.compose.foundation.layout.Box+import androidx.compose.foundation.layout.fillMaxHeight+import androidx.compose.foundation.layout.offset+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.size+import androidx.compose.foundation.layout.width+import androidx.compose.foundation.lazy.LazyListState+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.rememberCoroutineScope+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.draw.alpha+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.input.pointer.pointerInput+import androidx.compose.ui.platform.LocalDensity+import androidx.compose.ui.unit.IntOffset+import androidx.compose.ui.unit.dp+import kotlinx.coroutines.delay+import kotlinx.coroutines.launch+import kotlin.math.roundToInt++/**+ * A thin draggable thumb on the right edge of a long [LazyListState] list: shown while the+ * list scrolls or the thumb is dragged, hidden otherwise. Place it in a Box over the list.+ */+@Composable+fun FastScrollbar(state: LazyListState, modifier: Modifier = Modifier, minItems: Int = 30) {+ val total = state.layoutInfo.totalItemsCount+ if (total <= minItems) return+ var dragging by remember { mutableStateOf(false) }+ var visible by remember { mutableStateOf(false) }+ val scrolling = state.isScrollInProgress+ LaunchedEffect(scrolling, dragging) {+ if (scrolling || dragging) visible = true else { delay(1200); visible = false }+ }+ val alpha by androidx.compose.animation.core.animateFloatAsState(if (visible) 1f else 0f, label = "scrollbar")+ if (alpha == 0f) return+ val scope = rememberCoroutineScope()+ val density = LocalDensity.current+ val thumbPx = with(density) { 56.dp.toPx() }+ Box(modifier.fillMaxHeight().width(28.dp).alpha(alpha)) {+ val trackPx = state.layoutInfo.viewportSize.height.toFloat()+ val fraction = if (total <= 1) 0f else {+ val first = state.firstVisibleItemIndex.toFloat()+ (first / (total - 1)).coerceIn(0f, 1f)+ }+ val travel = (trackPx - thumbPx).coerceAtLeast(0f)+ Box(+ Modifier+ .align(androidx.compose.ui.Alignment.TopEnd)+ .offset { IntOffset(0, (fraction * travel).roundToInt()) }+ .padding(end = 3.dp)+ .size(width = 5.dp, height = 56.dp)+ .background(Color.White.copy(alpha = if (dragging) 0.8f else 0.5f), RoundedCornerShape(50))+ )+ // A wider invisible strip so the thin thumb is easy to grab.+ Box(+ Modifier+ .fillMaxHeight()+ .width(28.dp)+ .pointerInput(total) {+ detectVerticalDragGestures(+ onDragStart = { dragging = true },+ onDragEnd = { dragging = false },+ onDragCancel = { dragging = false },+ ) { change, _ ->+ change.consume()+ val h = (size.height - thumbPx).coerceAtLeast(1f)+ val f = ((change.position.y - thumbPx / 2) / h).coerceIn(0f, 1f)+ scope.launch { state.scrollToItem((f * (total - 1)).roundToInt()) }+ }+ }+ )+ }+}diff --git a/base/app/src/main/java/com/music/spotui/ui/components/ShareCard.kt b/base/app/src/main/java/com/music/spotui/ui/components/ShareCard.ktnew file mode 100644index 00000000..46855abf--- /dev/null+++ b/base/app/src/main/java/com/music/spotui/ui/components/ShareCard.kt@@ -0,0 +1,119 @@+package com.music.spotui.ui.components++import android.content.Context+import android.content.Intent+import android.graphics.Bitmap+import android.graphics.Canvas+import android.graphics.Color+import android.graphics.LinearGradient+import android.graphics.Paint+import android.graphics.RectF+import android.graphics.Shader+import android.graphics.Typeface+import android.text.Layout+import android.text.StaticLayout+import android.text.TextPaint+import android.text.TextUtils+import androidx.core.content.FileProvider+import com.bumptech.glide.Glide+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.withContext+import java.io.File++/**+ * "Share as image": a 1080x1920 story card (blurred cover background, large cover, title,+ * artist, Myspoti wordmark) written to cache/shared/ and handed out through the FileProvider,+ * so Instagram / WhatsApp stories and the like can pick it up.+ */+object ShareCard {+ private const val W = 1080+ private const val H = 1920++ /** Renders and shares the card; does nothing if the image cannot be produced. */+ suspend fun share(context: Context, title: String, artist: String, coverUri: String, chooserTitle: String) {+ val file = withContext(Dispatchers.IO) {+ runCatching {+ val cover = loadCover(context, coverUri)+ val card = render(title, artist, cover)+ val dir = File(context.cacheDir, "shared").apply { mkdirs() }+ dir.listFiles()?.forEach { it.delete() }+ File(dir, "myspoti_card.png").also { f ->+ f.outputStream().use { card.compress(Bitmap.CompressFormat.PNG, 100, it) }+ }+ }.getOrNull()+ } ?: return+ val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)+ val send = Intent(Intent.ACTION_SEND).apply {+ type = "image/png"+ putExtra(Intent.EXTRA_STREAM, uri)+ addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)+ }+ val chooser = Intent.createChooser(send, chooserTitle).apply {+ if (context !is android.app.Activity) addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)+ }+ context.startActivity(chooser)+ }++ private fun loadCover(context: Context, uri: String): Bitmap? {+ if (uri.isBlank()) return null+ val bmp = runCatching {+ Glide.with(context.applicationContext).asBitmap().load(uri).submit(1000, 1000).get()+ }.getOrNull() ?: return null+ return if (bmp.config == Bitmap.Config.HARDWARE) bmp.copy(Bitmap.Config.ARGB_8888, false) else bmp+ }++ private fun render(title: String, artist: String, cover: Bitmap?): Bitmap {+ val out = Bitmap.createBitmap(W, H, Bitmap.Config.ARGB_8888)+ val c = Canvas(out)+ val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)++ // Background: the cover shrunk to a few pixels and stretched back is a cheap blur.+ c.drawColor(Color.rgb(18, 18, 18))+ if (cover != null) {+ val tiny = Bitmap.createScaledBitmap(cover, 16, 16, true)+ c.drawBitmap(tiny, null, RectF(-200f, -200f, W + 200f, H + 200f), paint)+ }+ paint.shader = LinearGradient(0f, 0f, 0f, H.toFloat(),+ intArrayOf(Color.argb(120, 0, 0, 0), Color.argb(170, 0, 0, 0), Color.argb(230, 0, 0, 0)), null, Shader.TileMode.CLAMP)+ c.drawRect(0f, 0f, W.toFloat(), H.toFloat(), paint)+ paint.shader = null++ // Cover: large, centred, rounded.+ val side = 840f+ val left = (W - side) / 2f+ val top = 380f+ val box = RectF(left, top, left + side, top + side)+ if (cover != null) {+ val layer = c.saveLayer(box, null)+ c.drawRoundRect(box, 36f, 36f, paint.apply { color = Color.BLACK })+ paint.xfermode = android.graphics.PorterDuffXfermode(android.graphics.PorterDuff.Mode.SRC_IN)+ c.drawBitmap(cover, null, box, paint)+ paint.xfermode = null+ c.restoreToCount(layer)+ } else {+ paint.color = Color.rgb(40, 40, 40)+ c.drawRoundRect(box, 36f, 36f, paint)+ }++ // Title (up to two lines) and artist.+ val textW = (W - 160)+ val titlePaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {+ color = Color.WHITE; textSize = 62f; typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD)+ }+ val titleLayout = StaticLayout.Builder.obtain(title, 0, title.length, titlePaint, textW)+ .setAlignment(Layout.Alignment.ALIGN_CENTER).setMaxLines(2).setEllipsize(TextUtils.TruncateAt.END).build()+ c.save(); c.translate(80f, top + side + 80f); titleLayout.draw(c); c.restore()+ val artistPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { color = Color.argb(200, 255, 255, 255); textSize = 46f }+ val artistLayout = StaticLayout.Builder.obtain(artist, 0, artist.length, artistPaint, textW)+ .setAlignment(Layout.Alignment.ALIGN_CENTER).setMaxLines(1).setEllipsize(TextUtils.TruncateAt.END).build()+ c.save(); c.translate(80f, top + side + 80f + titleLayout.height + 24f); artistLayout.draw(c); c.restore()++ // Wordmark.+ val mark = TextPaint(Paint.ANTI_ALIAS_FLAG).apply {+ color = Color.argb(170, 255, 255, 255); textSize = 40f; textAlign = Paint.Align.CENTER+ typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD); letterSpacing = 0.12f+ }+ c.drawText("Myspoti", W / 2f, H - 150f, mark)+ return out+ }+}diff --git a/base/app/src/main/java/com/music/spotui/ui/navigation/MyNavHost.kt b/base/app/src/main/java/com/music/spotui/ui/navigation/MyNavHost.ktindex 8b23e6d2..901cf484 100644--- a/base/app/src/main/java/com/music/spotui/ui/navigation/MyNavHost.kt+++ b/base/app/src/main/java/com/music/spotui/ui/navigation/MyNavHost.kt@@ -239,6 +239,18 @@ fun MyNavHost(uId?.let { com.music.spotui.ui.screens.ProfileScreen(navHostController, userId = it, userName = name) }}+ page(+ "${com.music.spotui.ui.screens.FOLLOW_LIST_ROUTE}/{uId}/{mode}",+ ) { navBackStackEntry ->+ LaunchedEffect(playerState) {+ bottomBarState.value = true+ bottomBarPlayerState.value = playerState != ""+ }+ val uId = navBackStackEntry.arguments?.getString("uId")+ val mode = navBackStackEntry.arguments?.getString("mode")+ uId?.let { com.music.spotui.ui.screens.FollowListScreen(navHostController, userId = it, followers = mode == "followers") }+ }+page("${Routes.Show.route}/{sId}?name={name}",arguments = listOf(navArgument("name") { defaultValue = "" }),diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/ArtistScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/ArtistScreen.ktindex b17bfe82..5b015e7d 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/ArtistScreen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/ArtistScreen.kt@@ -5,6 +5,8 @@ import com.music.spotui.ui.components.pressableimport androidx.compose.ui.res.stringResourceimport androidx.compose.material.icons.filled.Check+import kotlinx.coroutines.flow.first+import androidx.compose.material.icons.filled.Favoriteimport androidx.compose.material.icons.filled.MoreVertimport android.annotation.SuppressLintimport androidx.compose.foundation.ExperimentalFoundationApi@@ -49,6 +51,7 @@ import androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.draw.clipimport androidx.compose.ui.graphics.Brush+import androidx.compose.ui.text.style.TextOverflowimport androidx.compose.ui.graphics.Colorimport androidx.compose.ui.graphics.toArgbimport androidx.compose.ui.layout.ContentScale@@ -149,6 +152,22 @@ private fun ArtistOverviewContent(following = "spotify:artist:${overview.id}" in res}var showAllPopular by remember { mutableStateOf(false) }+ // The user's liked songs by this artist: from the session cache, else loaded once in the background.+ var likedByArtist by remember(overview.id) { mutableStateOf<List<com.music.spotui.data.entity.SongsModel>>(emptyList()) }+ var showLiked by remember(overview.id) { mutableStateOf(false) }+ LaunchedEffect(overview.id) {+ val all = com.music.spotui.data.api.Api.LikedCache.tracks+ ?: runCatching {+ com.music.spotui.di.Graph.api.getLikedPage()+ .first { it is Response.Success && it.data.complete }+ .let { (it as? Response.Success)?.data?.tracks }+ }.getOrNull()+ ?: return@LaunchedEffect+ likedByArtist = all.filter { s ->+ if (s.artistIds.isNotEmpty()) overview.id in s.artistIds+ else displayName.isNotBlank() && s.singer.split(", ").any { it.equals(displayName, ignoreCase = true) }+ }+ }val np by SongPlayer.nowPlayingval isThisArtist = np.contextUri == "spotify:artist:${overview.id}"val playingNow = artistViewModel.currentSongPlayingState.value@@ -376,6 +395,52 @@ private fun ArtistOverviewContent(}}+ // ── Liked songs by this artist ──+ if (likedByArtist.isNotEmpty()) {+ item(key = "liked-by-artist") {+ Row(+ verticalAlignment = Alignment.CenterVertically,+ modifier = Modifier.fillMaxWidth().clickable { showLiked = !showLiked }.padding(16.dp, 8.dp),+ ) {+ Box(+ contentAlignment = Alignment.Center,+ modifier = Modifier.size(52.dp).clip(RoundedCornerShape(4.dp))+ .background(Brush.linearGradient(listOf(Color(0xFF450AF5), Color(0xFF8E8EE5), Color(0xFFC4EFD9)))),+ ) {+ androidx.compose.material3.Icon(Icons.Default.Favorite, contentDescription = null, tint = Color.White, modifier = Modifier.size(22.dp))+ }+ Spacer(Modifier.width(12.dp))+ Column(Modifier.weight(1f)) {+ Text(stringResource(R.string.artist_liked_songs), color = Color.White, fontSize = 16.sp, fontWeight = FontWeight.Bold)+ Text(+ androidx.compose.ui.res.pluralStringResource(R.plurals.artist_liked_songs_count, likedByArtist.size, likedByArtist.size, displayName),+ color = Color.White.copy(alpha = 0.7f), fontSize = 14.sp, maxLines = 1, overflow = TextOverflow.Ellipsis,+ )+ }+ }+ }+ if (showLiked) itemsIndexed(likedByArtist, key = { i, s -> "liked:$i:${s.id}" }) { _, song ->+ Row(+ verticalAlignment = Alignment.CenterVertically,+ modifier = Modifier.fillMaxWidth()+ .clickable {+ SongPlayer.registerLikedSongs(com.music.spotui.data.api.Api.LikedCache.tracks.orEmpty().map { it.url })+ artistViewModel.updateQueue(likedByArtist)+ SongPlayer.playSong(song.url, context, contextUri = "spotify:collection:tracks")+ artistViewModel.updateSongState(song.coverUri, song.title, song.singer, true, song.id, 0, song.album)+ }+ .padding(16.dp, 8.dp),+ ) {+ GlideImage(model = song.coverUri, contentDescription = "", contentScale = ContentScale.Crop, modifier = Modifier.size(44.dp))+ Spacer(Modifier.width(12.dp))+ Column(Modifier.weight(1f)) {+ Text(song.title, color = Color.White, fontSize = 15.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)+ Text(song.album, color = Color.White.copy(alpha = 0.7f), fontSize = 13.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)+ }+ }+ }+ }+// ── Popular releases (discography) — vertical list, first few + "Show all" ──if (overview.popularReleases.isNotEmpty()) {item { SectionHeader(stringResource(R.string.popular_releases_section_title)) }diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/ContextScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/ContextScreen.ktindex e3f8f1bd..acacdee2 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/ContextScreen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/ContextScreen.kt@@ -45,6 +45,7 @@ import androidx.compose.runtime.rememberimport androidx.compose.runtime.setValueimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifier+import androidx.compose.ui.draw.alphaimport androidx.compose.ui.draw.clipimport androidx.compose.ui.draw.drawWithContentimport androidx.compose.ui.draw.shadow@@ -346,7 +347,9 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p)}- LazyColumn(modifier = Modifier.fillMaxSize()) {+ val listState = androidx.compose.foundation.lazy.rememberLazyListState()+ Box(Modifier.fillMaxSize()) {+ LazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {item {Column(modifier = Modifier@@ -571,6 +574,8 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, pif (p.type == "album") item(key = "similar") { SimilarAlbums(navController, p.tracks.firstOrNull()?.spotifyTrackId.orEmpty(), p.uri) }item { Spacer(Modifier.height(com.music.spotui.ui.components.bottomBarsSpace())) }}+ com.music.spotui.ui.components.FastScrollbar(listState, Modifier.align(Alignment.CenterEnd))+ }}@OptIn(ExperimentalGlideComposeApi::class)@@ -589,6 +594,7 @@ private fun TrackRow(horizontalArrangement = Arrangement.Start,modifier = Modifier.fillMaxWidth()+ .then(if (song.playable) Modifier else Modifier.alpha(0.4f)).clickable(onClick = onClick).padding(horizontal = 16.dp, vertical = 8.dp)) {@@ -670,7 +676,7 @@ object SmartShuffle {* Smart shuffle (Spotify keeps its own for Premium): the playlist shuffled, with one of* Spotify's recommendations for it after every [EVERY] songs.*/- suspend fun start(p: ContextPageModel, first: SongsModel?) {+ suspend fun start(p: ContextPageModel, first: SongsModel?, fromPositionMs: Long? = null) {val api = Graph.apival state = Graph.currentSongStateon.value = p.uri@@ -680,6 +686,8 @@ object SmartShuffle {// Spotify's playlist extender refuses Liked Songs: the radios of a few liked songs instead.p.tracks.shuffled().take(3).flatMap { api.getRecommendations(listOf(it.spotifyTrackId)).take(8) }} else runCatching { MyspotiRuntime.api.playlists.recommended(p.uri, limit = 20) }.getOrDefault(emptyList()).map(api::songOf)+ // Spotify's extender gives nothing for some playlists: the radios of a few of its songs.+ .ifEmpty { p.tracks.shuffled().take(3).flatMap { runCatching { api.getRecommendations(listOf(it.spotifyTrackId)).take(8) }.getOrDefault(emptyList()) } }}.filter { it.spotifyTrackId !in inList }.distinctBy { it.spotifyTrackId }.shuffled()val shuffled = p.tracks.shuffled().let { list -> first?.let { f -> listOf(f) + (list - f) } ?: list }if (shuffled.isEmpty()) return@@ -694,7 +702,9 @@ object SmartShuffle {SongPlayer.setShuffle(false); state.shuffle.value = falsestate.updateQueue(mixed)val startSong = mixed.first()- SongPlayer.playSong(startSong.url, contextUri = p.uri, order = mixed.map { "spotify:track:${it.spotifyTrackId}" })+ // Turned on from the player: the song playing goes on where it is, not from its start.+ val position = fromPositionMs?.takeIf { first != null && it > 0 }+ SongPlayer.playSong(startSong.url, contextUri = p.uri, order = mixed.map { "spotify:track:${it.spotifyTrackId}" }, positionMs = position)state.updateSongState(startSong.coverUri, startSong.title, startSong.singer, true, startSong.id, 0, startSong.album)}@@ -707,7 +717,7 @@ object SmartShuffle {else -> return false}val page = (withContext(Dispatchers.IO) { flow.first { it !is Response.Loading } } as? Response.Success)?.data ?: return false- start(page, page.tracks.firstOrNull { it.spotifyTrackId == currentTrackId })+ start(page, page.tracks.firstOrNull { it.spotifyTrackId == currentTrackId }, SongPlayer.getCurrentPosition())return true}}diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/FollowListScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/FollowListScreen.ktnew file mode 100644index 00000000..d253d685--- /dev/null+++ b/base/app/src/main/java/com/music/spotui/ui/screens/FollowListScreen.kt@@ -0,0 +1,113 @@+package com.music.spotui.ui.screens++import androidx.compose.foundation.background+import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Box+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.Spacer+import androidx.compose.foundation.layout.fillMaxSize+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.size+import androidx.compose.foundation.layout.statusBarsPadding+import androidx.compose.foundation.layout.width+import androidx.compose.foundation.lazy.LazyColumn+import androidx.compose.foundation.lazy.items+import androidx.compose.foundation.shape.CircleShape+import androidx.compose.material.icons.Icons+import androidx.compose.material.icons.automirrored.filled.ArrowBack+import androidx.compose.material3.CircularProgressIndicator+import androidx.compose.material3.Icon+import androidx.compose.material3.Text+import androidx.compose.runtime.Composable+import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Alignment+import androidx.compose.ui.Modifier+import androidx.compose.ui.draw.clip+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.layout.ContentScale+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.text.font.FontWeight+import androidx.compose.ui.text.style.TextOverflow+import androidx.compose.ui.unit.dp+import androidx.compose.ui.unit.sp+import androidx.navigation.NavController+import app.myspoti.api.UserRef+import app.myspoti.engine.R+import app.myspoti.host.android.MyspotiRuntime+import com.bumptech.glide.integration.compose.ExperimentalGlideComposeApi+import com.bumptech.glide.integration.compose.GlideImage+import com.bumptech.glide.integration.compose.placeholder+import com.music.spotui.ui.components.pressable+import com.music.spotui.ui.navigation.profileRoute+import com.music.spotui.ui.theme.AppAccent+import com.music.spotui.ui.theme.AppBackground++const val FOLLOW_LIST_ROUTE = "followlist"++/** Route to the followers (or following) list of a user id. */+fun followListRoute(userId: String, followers: Boolean): String =+ "$FOLLOW_LIST_ROUTE/${android.net.Uri.encode(userId)}/${if (followers) "followers" else "following"}"++/** The people who follow a user, or the people that user follows; tap opens the profile. */+@OptIn(ExperimentalGlideComposeApi::class)+@Composable+fun FollowListScreen(navController: NavController, userId: String, followers: Boolean) {+ var people by remember(userId, followers) { mutableStateOf<List<UserRef>?>(null) }+ LaunchedEffect(userId, followers) {+ val uri = "spotify:user:$userId"+ people = runCatching {+ if (followers) MyspotiRuntime.api.users.followers(uri) else MyspotiRuntime.api.users.following(uri)+ }.getOrDefault(emptyList())+ }+ val list = people+ LazyColumn(+ contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),+ modifier = Modifier.fillMaxSize().background(AppBackground).statusBarsPadding(),+ ) {+ item {+ Row(verticalAlignment = Alignment.CenterVertically) {+ Icon(+ Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.accessibility_navigate_back), tint = Color.White,+ modifier = Modifier.pressable(0.96f) { navController.navigateUp() }.padding(16.dp).size(26.dp),+ )+ Text(+ stringResource(if (followers) R.string.profile_followers_title else R.string.profile_following_title),+ color = Color.White, fontSize = 22.sp, fontWeight = FontWeight.Bold,+ )+ }+ }+ when {+ list == null -> item {+ Box(Modifier.fillMaxWidth().padding(32.dp), contentAlignment = Alignment.Center) {+ CircularProgressIndicator(color = AppAccent)+ }+ }+ list.isEmpty() -> item {+ Text(stringResource(R.string.profile_list_empty), color = Color(0xFFB3B3B3), fontSize = 15.sp,+ modifier = Modifier.padding(16.dp))+ }+ else -> items(list, key = { it.uri }) { u ->+ Row(+ verticalAlignment = Alignment.CenterVertically,+ horizontalArrangement = Arrangement.Start,+ modifier = Modifier.fillMaxWidth()+ .pressable(0.98f) { navController.navigate(profileRoute(u.uri.substringAfterLast(':'), u.name)) }+ .padding(16.dp, 8.dp),+ ) {+ GlideImage(+ model = u.imageUrl, contentDescription = null, contentScale = ContentScale.Crop,+ failure = placeholder(R.drawable.placeholder), loading = placeholder(R.drawable.placeholder),+ modifier = Modifier.size(52.dp).clip(CircleShape),+ )+ Spacer(Modifier.width(12.dp))+ Text(u.name, color = Color.White, fontSize = 16.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)+ }+ }+ }+ }+}diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/LibraryScreeen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/LibraryScreeen.ktindex f02993c4..bb94f65a 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/LibraryScreeen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/LibraryScreeen.kt@@ -415,12 +415,12 @@ fun SumUpLibraryScreen(}}+ Box(Modifier.fillMaxSize().padding(padding)) {LazyColumn(state = listState,contentPadding = PaddingValues(top = 10.dp, bottom = com.music.spotui.ui.components.bottomBarsSpace()),modifier = Modifier.fillMaxSize()- .padding(padding).background(com.music.spotui.ui.theme.AppBackground)) {itemsIndexed(rows, key = { _, e -> LibraryOrder.key(e) }) { index, entry ->@@ -511,6 +511,8 @@ fun SumUpLibraryScreen(}}}+ com.music.spotui.ui.components.FastScrollbar(listState, Modifier.align(Alignment.CenterEnd))+ }}/** An entry's artwork: Spotify's image, or the drawn cover of the app's own folders. */diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/PlayerScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/PlayerScreen.ktindex 9bd93e3a..79837997 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/PlayerScreen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/PlayerScreen.kt@@ -6,6 +6,8 @@ import androidx.compose.ui.layout.onSizeChangedimport androidx.compose.foundation.gestures.detectTapGesturesimport androidx.compose.foundation.gestures.detectHorizontalDragGesturesimport androidx.compose.ui.input.pointer.pointerInput+import androidx.compose.foundation.gestures.awaitFirstDown+import androidx.compose.ui.input.pointer.positionChangeimport android.content.Contextimport android.content.Intentimport android.net.Uri@@ -34,6 +36,7 @@ import androidx.compose.foundation.layout.Spacerimport androidx.compose.foundation.layout.fillMaxSizeimport androidx.compose.foundation.layout.fillMaxWidthimport androidx.compose.foundation.layout.height+import androidx.compose.foundation.layout.fillMaxHeightimport androidx.compose.foundation.layout.paddingimport androidx.compose.foundation.layout.sizeimport androidx.compose.foundation.layout.navigationBarsPadding@@ -313,10 +316,19 @@ fun PlayerScreen(navController: NavController) {horizontalAlignment = Alignment.CenterHorizontally) {item {+ // Sized from the real space (foldables, tablets), not the screen: wide windows centre+ // the content in a capped column and the cover fits both the width and the height.+ androidx.compose.foundation.layout.BoxWithConstraints(+ modifier = Modifier.fillParentMaxHeight().fillMaxWidth(),+ contentAlignment = Alignment.TopCenter,+ ) {+ val wide = maxWidth > 600.dp && maxWidth > maxHeight+ val contentWidth = if (wide) maxWidth.coerceAtMost(520.dp) else maxWidth+ val artSide = minOf(contentWidth, maxHeight - PLAYER_CONTROLS_DP.dp).coerceAtLeast(160.dp)Column(modifier = Modifier- .fillParentMaxHeight()- .fillMaxWidth()+ .fillMaxHeight()+ .width(contentWidth).navigationBarsPadding(),horizontalAlignment = Alignment.CenterHorizontally) {@@ -331,9 +343,28 @@ fun PlayerScreen(navController: NavController) {// Spotify's "Passer à la vidéo" pill over it (black, like the official app).// Square, but never taller than what the controls leave (foldables, landscape-ish// screens): otherwise play / pause ends up under the lyrics card.- val screen = androidx.compose.ui.platform.LocalConfiguration.current- val artMax = (screen.screenHeightDp - PLAYER_CONTROLS_DP).coerceAtLeast(160).dp- Box(modifier = Modifier.widthIn(max = artMax).fillMaxWidth().aspectRatio(1f)) {+ // A clear upward drag on the artwork opens the lyrics (observed on the initial pass,+ // never consumed, so the pager and the pull-to-close keep working).+ Box(modifier = Modifier.size(artSide).pointerInput(Unit) {+ val threshold = 80.dp.toPx()+ while (true) awaitPointerEventScope {+ val down = awaitFirstDown(requireUnconsumed = false, pass = androidx.compose.ui.input.pointer.PointerEventPass.Initial)+ var dx = 0f+ var dy = 0f+ var fired = false+ while (true) {+ val event = awaitPointerEvent(androidx.compose.ui.input.pointer.PointerEventPass.Initial)+ val change = event.changes.firstOrNull { it.id == down.id } ?: break+ if (!change.pressed) break+ val d = change.positionChange()+ dx += d.x; dy += d.y+ if (!fired && -dy > threshold && -dy > kotlin.math.abs(dx) * 2f) {+ fired = true+ showLyrics = true+ }+ }+ }+ }) {if (showVideo) Box(contentAlignment = Alignment.Center,modifier = Modifier.fillMaxSize(),@@ -445,12 +476,16 @@ fun PlayerScreen(navController: NavController) {PlayerConnectRow(context = context,+ title = songTitle,+ artist = songSinger,+ coverUri = songCoverUri,onDevices = { showDevices = true },onQueue = { showQueue = true },)Spacer(modifier = Modifier.height(20.dp))}}+ }item {if (!audioBuffering) InlineLyrics(title = songTitle,@@ -848,6 +883,7 @@ fun PlayerFull(modifier = Modifier.fillMaxWidth().padding(20.dp)+ .height(64.dp)) {Icon(modifier = Modifier@@ -882,7 +918,8 @@ fun PlayerFull(else{Color.White},- painter = painterResource(id = R.drawable.ic_player_shuffle),+ // Smart shuffle has its own glyph (shuffle + sparkle), so it reads differently from plain shuffle.+ painter = painterResource(id = if (smartOn) R.drawable.ic_shuffle_smart_active else R.drawable.ic_player_shuffle),contentDescription = stringResource(when { smartOn -> R.string.notif_shuffle_disable_smart; shuffle -> R.string.notif_shuffle_disable; else -> R.string.notif_shuffle_enable }))Icon(@@ -901,7 +938,7 @@ fun PlayerFull(modifier = Modifier// requiredSize forces an exact 64×64 square even if the parent Column// constrains height — .size() alone let it get squished into an ellipse.- .requiredSize(64.dp)+ .requiredSize(64.dp) // never below 56dp.pressable(pressedScale = 0.92f) {if (songPlayingState) {SongPlayer.pause()@@ -980,6 +1017,9 @@ fun PlayerFull(@Composablefun PlayerConnectRow(context: Context,+ title: String,+ artist: String,+ coverUri: String,onDevices: () -> Unit,onQueue: () -> Unit,) {@@ -1016,28 +1056,50 @@ fun PlayerConnectRow()}Row(verticalAlignment = Alignment.CenterVertically) {- Icon(- painter = painterResource(id = R.drawable.ic_share),- tint = Color.White,- modifier = Modifier- .size(22.dp)- .clickable(- interactionSource = remember { MutableInteractionSource() },- indication = null,- ) {- // Songs and episodes alike: the link follows what plays (spotify:<kind>:<id>).- val parts = SongPlayer.nowPlaying.value.uri.split(':')- val link = if (parts.size == 3 && parts[0] == "spotify") "https://open.spotify.com/${parts[1]}/${parts[2]}"- else SongPlayer.currentTrackId.takeIf { it.isNotBlank() }?.let { "https://open.spotify.com/track/$it" }- if (link == null) return@clickable- val send = Intent(Intent.ACTION_SEND).apply {- type = "text/plain"- putExtra(Intent.EXTRA_TEXT, link)- }- context.startActivity(Intent.createChooser(send, context.getString(R.string.action_share_label)))- },- contentDescription = stringResource(R.string.action_share_label),- )+ var shareMenu by remember { mutableStateOf(false) }+ val shareScope = androidx.compose.runtime.rememberCoroutineScope()+ Box {+ Icon(+ painter = painterResource(id = R.drawable.ic_share),+ tint = Color.White,+ modifier = Modifier+ .size(22.dp)+ .clickable(+ interactionSource = remember { MutableInteractionSource() },+ indication = null,+ ) { shareMenu = true },+ contentDescription = stringResource(R.string.action_share_label),+ )+ androidx.compose.material3.DropdownMenu(expanded = shareMenu, onDismissRequest = { shareMenu = false }) {+ androidx.compose.material3.DropdownMenuItem(+ text = { Text(stringResource(R.string.share_link)) },+ onClick = {+ shareMenu = false+ // Songs and episodes alike: the link follows what plays (spotify:<kind>:<id>).+ val parts = SongPlayer.nowPlaying.value.uri.split(':')+ val link = if (parts.size == 3 && parts[0] == "spotify") "https://open.spotify.com/${parts[1]}/${parts[2]}"+ else SongPlayer.currentTrackId.takeIf { it.isNotBlank() }?.let { "https://open.spotify.com/track/$it" }+ if (link != null) {+ val send = Intent(Intent.ACTION_SEND).apply {+ type = "text/plain"+ putExtra(Intent.EXTRA_TEXT, link)+ }+ context.startActivity(Intent.createChooser(send, context.getString(R.string.action_share_label)))+ }+ },+ )+ androidx.compose.material3.DropdownMenuItem(+ text = { Text(stringResource(R.string.share_as_image)) },+ onClick = {+ shareMenu = false+ shareScope.launch {+ com.music.spotui.ui.components.ShareCard.share(+ context, title, artist, coverUri, context.getString(R.string.action_share_label))+ }+ },+ )+ }+ }Spacer(modifier = Modifier.width(24.dp))Icon(imageVector = Icons.AutoMirrored.Filled.List,diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/ProfileScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/ProfileScreen.ktindex 7e427ca7..c0a7296f 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/ProfileScreen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/ProfileScreen.kt@@ -100,12 +100,21 @@ fun ProfileScreen(navController: NavController, userId: String, userName: Stringcom.music.spotui.ui.components.FitText(p?.name ?: userName, fontSize = 28.sp, minSize = 18.sp,fontWeight = FontWeight.Bold, maxLines = 2, textAlign = androidx.compose.ui.text.style.TextAlign.Center)if (p != null) {- val parts = listOfNotNull(- p.followers?.let { pluralStringResource(R.plurals.profile_followers, it, it) },- p.following?.let { stringResource(R.string.profile_following_count, it) },- )- if (parts.isNotEmpty()) Text(parts.joinToString(" • "), color = Color(0xFFB3B3B3), fontSize = 14.sp,- modifier = Modifier.padding(top = 6.dp))+ Row(Modifier.padding(top = 6.dp), verticalAlignment = Alignment.CenterVertically) {+ p.followers?.let {+ Text(pluralStringResource(R.plurals.profile_followers, it, it), color = Color(0xFFB3B3B3), fontSize = 14.sp,+ modifier = Modifier.clip(RoundedCornerShape(6.dp))+ .pressable(0.96f) { navController.navigate(followListRoute(userId, followers = true)) }+ .padding(horizontal = 6.dp, vertical = 4.dp))+ }+ if (p.followers != null && p.following != null) Text("•", color = Color(0xFFB3B3B3), fontSize = 14.sp)+ p.following?.let {+ Text(stringResource(R.string.profile_following_count, it), color = Color(0xFFB3B3B3), fontSize = 14.sp,+ modifier = Modifier.clip(RoundedCornerShape(6.dp))+ .pressable(0.96f) { navController.navigate(followListRoute(userId, followers = false)) }+ .padding(horizontal = 6.dp, vertical = 4.dp))+ }+ }}val f = followingif (!me && f != null) {diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/SettingsScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/SettingsScreen.ktindex 22d45507..348dccda 100644--- a/base/app/src/main/java/com/music/spotui/ui/screens/SettingsScreen.kt+++ b/base/app/src/main/java/com/music/spotui/ui/screens/SettingsScreen.kt@@ -2,7 +2,15 @@ package com.music.spotui.ui.screensimport androidx.compose.foundation.backgroundimport androidx.compose.foundation.clickable+import androidx.compose.foundation.border+import androidx.compose.foundation.layout.Boximport androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.size+import androidx.compose.foundation.shape.CircleShape+import androidx.compose.ui.draw.clip+import androidx.compose.ui.semantics.contentDescription+import androidx.compose.ui.semantics.role+import androidx.compose.ui.semantics.semanticsimport androidx.compose.foundation.layout.Rowimport androidx.compose.foundation.layout.Spacerimport androidx.compose.foundation.layout.fillMaxSize@@ -59,6 +67,12 @@ fun SettingsScreen(navController: NavController) {Column(Modifier.fillMaxWidth().weight(1f).verticalScroll(rememberScrollState()).navigationBarsPadding()) {Section(R.string.settings_section_playback)StreamingQualityPicker()+ OptionRow(+ label = stringResource(R.string.settings_autoplay_title),+ detail = stringResource(R.string.settings_autoplay_detail),+ checked = com.music.spotui.data.preferences.AutoplayPref.on,+ onChecked = { com.music.spotui.data.preferences.AutoplayPref.set(ctx, it) },+ )Divider()Section(R.string.settings_section_downloads)@@ -129,6 +143,8 @@ fun SettingsScreen(navController: NavController) {checked = com.music.spotui.data.preferences.SolidNavBar.on,onChecked = { com.music.spotui.data.preferences.SolidNavBar.set(ctx, it) },)+ AccentRow()+ OrientationRow()LanguageRow()Divider()@@ -155,6 +171,61 @@ private fun Section(title: Int) {@Composableprivate fun Divider() = HorizontalDivider(color = Color(0xFF2A2A2A), modifier = Modifier.padding(top = 8.dp))+/** The app's accent colour, for everyone (the same palette the supporter sheet uses). */+@Composable+private fun AccentRow() {+ val ctx = androidx.compose.ui.platform.LocalContext.current+ Column(Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 10.dp)) {+ Text(stringResource(R.string.supporter_accent), color = Color.White, fontSize = 16.sp)+ Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(14.dp), modifier = Modifier.padding(top = 10.dp)) {+ for (a in com.music.spotui.data.api.SupportReminder.Accent.entries) {+ val selected = com.music.spotui.data.api.SupportReminder.accent == a+ val name = stringResource(when (a) {+ com.music.spotui.data.api.SupportReminder.Accent.GREEN -> R.string.color_green+ com.music.spotui.data.api.SupportReminder.Accent.BLUE -> R.string.color_blue+ com.music.spotui.data.api.SupportReminder.Accent.PURPLE -> R.string.color_purple+ com.music.spotui.data.api.SupportReminder.Accent.PINK -> R.string.color_pink+ com.music.spotui.data.api.SupportReminder.Accent.ORANGE -> R.string.color_orange+ })+ Box(+ Modifier.size(40.dp)+ .semantics { contentDescription = name; role = Role.RadioButton }+ .clip(CircleShape).background(a.color)+ .then(if (selected) Modifier.border(3.dp, Color.White, CircleShape) else Modifier)+ .clickable { com.music.spotui.data.api.SupportReminder.setAccent(ctx, a) },+ )+ }+ }+ }+}++/** Screen rotation: portrait (default), automatic or landscape. */+@Composable+private fun OrientationRow() {+ val ctx = androidx.compose.ui.platform.LocalContext.current+ val pref = com.music.spotui.data.preferences.OrientationPref+ Column(Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 10.dp)) {+ Text(stringResource(R.string.settings_rotation_title), color = Color.White, fontSize = 16.sp)+ Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(8.dp), modifier = Modifier.padding(top = 10.dp)) {+ for ((value, label) in listOf(+ pref.PORTRAIT to R.string.settings_rotation_portrait,+ pref.AUTO to R.string.settings_rotation_auto,+ pref.LANDSCAPE to R.string.settings_rotation_landscape,+ )) {+ val selected = pref.mode == value+ Text(+ stringResource(label),+ color = if (selected) Color.Black else Color.White, fontSize = 14.sp,+ modifier = Modifier.clip(androidx.compose.foundation.shape.RoundedCornerShape(50))+ .background(if (selected) com.music.spotui.ui.theme.AppAccent else Color(0xFF2A2A2A))+ .clickable { pref.set(ctx, value) }+ .padding(horizontal = 16.dp, vertical = 8.dp),+ )+ }+ }+ }+}+/** "App language": Automatic (French or English) or any language with Spotify's labels. */@OptIn(androidx.compose.material3.ExperimentalMaterial3Api::class)@Composablediff --git a/base/app/src/main/res/values-fr/myspoti_strings.xml b/base/app/src/main/res/values-fr/myspoti_strings.xmlindex 57812002..ea95e10e 100644--- a/base/app/src/main/res/values-fr/myspoti_strings.xml+++ b/base/app/src/main/res/values-fr/myspoti_strings.xml@@ -281,6 +281,9 @@</plurals><string name="profile_following_count">%1$d abonnements</string><string name="profile_public_playlists">Playlists publiques</string>+ <string name="profile_followers_title">Abonnés</string>+ <string name="profile_following_title">Abonnements</string>+ <string name="profile_list_empty">Personne pour l\'instant</string><string name="artist_ban">Ne pas jouer cet artiste</string><string name="artist_unban">Rejouer cet artiste</string><string name="artist_banned">%1$s ne passera plus dans vos mix et radios</string>@@ -306,4 +309,18 @@<string name="retry_button">Réessayer</string><string name="page_load_failed">Impossible de charger cette page.\nVérifie ta connexion et réessaie.</string><string name="jam_paste_link">Rejoindre avec un lien copié</string>+ <string name="play_refused">Spotify a refusé cette lecture sur ton compte. Dans certains pays, un compte gratuit ne joue qu’en aléatoire : essaie le bouton aléatoire.</string>+ <string name="artist_liked_songs">Titres likés</string>+ <plurals name="artist_liked_songs_count">+ <item quantity="one">%1$d titre de %2$s</item>+ <item quantity="other">%1$d titres de %2$s</item>+ </plurals>+ <string name="share_link">Partager le lien</string>+ <string name="share_as_image">Partager en image</string>+ <string name="settings_autoplay_title">Lecture automatique</string>+ <string name="settings_autoplay_detail">Quand ta musique se termine, continuer avec des titres similaires</string>+ <string name="settings_rotation_title">Rotation de l\'écran</string>+ <string name="settings_rotation_portrait">Portrait</string>+ <string name="settings_rotation_auto">Automatique</string>+ <string name="settings_rotation_landscape">Paysage</string></resources>diff --git a/base/app/src/main/res/values-it/myspoti_strings.xml b/base/app/src/main/res/values-it/myspoti_strings.xmlindex fbd91e4c..ef353b97 100644--- a/base/app/src/main/res/values-it/myspoti_strings.xml+++ b/base/app/src/main/res/values-it/myspoti_strings.xml@@ -281,6 +281,9 @@</plurals><string name="profile_following_count">%1$d seguiti</string><string name="profile_public_playlists">Playlist pubbliche</string>+ <string name="profile_followers_title">Follower</string>+ <string name="profile_following_title">Seguiti</string>+ <string name="profile_list_empty">Ancora nessuno</string><string name="artist_ban">Non riprodurre questo artista</string><string name="artist_unban">Riproduci di nuovo questo artista</string><string name="artist_banned">%1$s non verrà più riprodotto nei tuoi mix e radio</string>@@ -306,4 +309,18 @@<string name="retry_button">Riprova</string><string name="page_load_failed">Impossibile caricare questa pagina.\nControlla la connessione e riprova.</string><string name="jam_paste_link">Partecipa con un link copiato</string>+ <string name="play_refused">Spotify ha rifiutato questa riproduzione sul tuo account. In alcuni paesi gli account gratuiti riproducono solo in ordine casuale: prova il pulsante casuale.</string>+ <string name="artist_liked_songs">Brani che ti piacciono</string>+ <plurals name="artist_liked_songs_count">+ <item quantity="one">%1$d brano di %2$s</item>+ <item quantity="other">%1$d brani di %2$s</item>+ </plurals>+ <string name="share_link">Condividi il link</string>+ <string name="share_as_image">Condividi come immagine</string>+ <string name="settings_autoplay_title">Riproduzione automatica</string>+ <string name="settings_autoplay_detail">Quando la musica finisce, continua con brani simili</string>+ <string name="settings_rotation_title">Rotazione dello schermo</string>+ <string name="settings_rotation_portrait">Verticale</string>+ <string name="settings_rotation_auto">Automatica</string>+ <string name="settings_rotation_landscape">Orizzontale</string></resources>diff --git a/base/app/src/main/res/values/myspoti_strings.xml b/base/app/src/main/res/values/myspoti_strings.xmlindex 6d4d4a17..93df6655 100644--- a/base/app/src/main/res/values/myspoti_strings.xml+++ b/base/app/src/main/res/values/myspoti_strings.xml@@ -281,6 +281,9 @@</plurals><string name="profile_following_count">%1$d following</string><string name="profile_public_playlists">Public playlists</string>+ <string name="profile_followers_title">Followers</string>+ <string name="profile_following_title">Following</string>+ <string name="profile_list_empty">Nobody here yet</string><string name="artist_ban">Don\'t play this artist</string><string name="artist_unban">Allow playing this artist</string><string name="artist_banned">%1$s won\'t play in your mixes and radios</string>@@ -306,4 +309,18 @@<string name="retry_button">Try again</string><string name="page_load_failed">Couldn\'t load this page.\nCheck your connection and try again.</string><string name="jam_paste_link">Join with a copied link</string>+ <string name="play_refused">Spotify refused to play this on your account. Free accounts in some countries can only play shuffled: try the shuffle button.</string>+ <string name="artist_liked_songs">Liked songs</string>+ <plurals name="artist_liked_songs_count">+ <item quantity="one">%1$d song by %2$s</item>+ <item quantity="other">%1$d songs by %2$s</item>+ </plurals>+ <string name="share_link">Share link</string>+ <string name="share_as_image">Share as image</string>+ <string name="settings_autoplay_title">Autoplay</string>+ <string name="settings_autoplay_detail">When your music ends, keep playing similar songs</string>+ <string name="settings_rotation_title">Screen rotation</string>+ <string name="settings_rotation_portrait">Portrait</string>+ <string name="settings_rotation_auto">Automatic</string>+ <string name="settings_rotation_landscape">Landscape</string></resources>diff --git a/base/app/src/main/res/xml/file_paths.xml b/base/app/src/main/res/xml/file_paths.xmlnew file mode 100644index 00000000..24427d04--- /dev/null+++ b/base/app/src/main/res/xml/file_paths.xml@@ -0,0 +1,5 @@+<?xml version="1.0" encoding="utf-8"?>+<paths>+ <!-- Share-as-image cards (ShareCard.kt). -->+ <cache-path name="shared" path="shared/" />+</paths>diff --git a/base/host-android/src/main/kotlin/app/myspoti/host/android/ControlRelay.kt b/base/host-android/src/main/kotlin/app/myspoti/host/android/ControlRelay.ktindex 46a3bfd1..d9eda29f 100644--- a/base/host-android/src/main/kotlin/app/myspoti/host/android/ControlRelay.kt+++ b/base/host-android/src/main/kotlin/app/myspoti/host/android/ControlRelay.kt@@ -119,6 +119,10 @@ internal class ControlRelay(private val view: WebView) {if (!p) return;pending.delete(id);if (!status) return p.reject(new TypeError('Failed to fetch'));+ // A refused play or transfer (free accounts in some countries): the app tries another way.+ if ((status === 402 || status === 403) && /player\/command|connect\/transfer/.test(p.url) && window.MyspotiHost) {+ try { window.MyspotiHost.postMessage(JSON.stringify({ type: 'refused', status, path: p.url.split('?')[0].replace(/^.*\/v1\//, '').replace(/\/from\/.*$/, '') })); } catch (e) { /* host gone */ }+ }const noBody = status === 204 || status === 205 || status === 304;p.resolve(new Response(noBody ? null : body, { status, headers: JSON.parse(headers) }));};@@ -132,7 +136,7 @@ internal class ControlRelay(private val view: WebView) {const method = ((init && init.method) || 'GET').toUpperCase();return new Promise((resolve, reject) => {const id = ++seq;- pending.set(id, { resolve, reject });+ pending.set(id, { resolve, reject, url });window.MyspotiNet.postMessage(JSON.stringify({ id, url, method, headers, body: body == null ? null : body }));});};diff --git a/base/host-android/src/main/kotlin/app/myspoti/host/android/WebPlayerHost.kt b/base/host-android/src/main/kotlin/app/myspoti/host/android/WebPlayerHost.ktindex 7eafd8d6..7ee5d39b 100644--- a/base/host-android/src/main/kotlin/app/myspoti/host/android/WebPlayerHost.kt+++ b/base/host-android/src/main/kotlin/app/myspoti/host/android/WebPlayerHost.kt@@ -125,6 +125,7 @@ class WebPlayerHost(context: Context) : BridgeHost {override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {android.util.Log.d(LOG, "page start ${url.take(120)}")+ pageStarts++_url.value = url_loginRequired.value = isLoginPage(url)if (url.startsWith(PLAYER_URL)) relay.injectNow()@@ -161,7 +162,32 @@ class WebPlayerHost(context: Context) : BridgeHost {private fun isLoginPage(url: String?) =url != null && (url.contains("accounts.spotify.com") || url.contains("/login") || url.contains("challenge.spotify.com"))- fun load() = main.post { view.loadUrl(PLAYER_URL) }+ fun load() = main.post {+ pageStarts = 0+ loadAsked = true+ view.loadUrl(PLAYER_URL)+ watchLoad(PLAYER_URL, attempt = 1)+ }++ /** Page starts since the last [load]; the load watchdog looks at it. */+ private var pageStarts = 0+ /** [load] was called and no [unload] since (data saver keeps the page off). */+ private var loadAsked = false++ /**+ * An exec-spawned process (GrapheneOS "secure app spawning") can lose the first+ * navigation of a WebView made in Application.onCreate: no page start, ever. When+ * nothing started after a while, the page is asked for again (a few times, further apart).+ */+ private fun watchLoad(url: String, attempt: Int) {+ main.postDelayed({+ if (pageStarts > 0 || !loadAsked || attempt > LOAD_RETRIES) return@postDelayed+ android.util.Log.d(LOG, "page never started: loading again (attempt $attempt)")+ if (attempt > 1) view.stopLoading()+ view.loadUrl(url)+ watchLoad(url, attempt + 1)+ }, LOAD_WATCH_MS * attempt)+ }fun reload() = main.post { view.reload() }@@ -207,17 +233,21 @@ class WebPlayerHost(context: Context) : BridgeHost {view.descendantFocusability = if (visible) ViewGroup.FOCUS_AFTER_DESCENDANTS else ViewGroup.FOCUS_BLOCK_DESCENDANTSif (visible) view.requestFocus()view.requestLayout()+ // Now in a window: a first navigation that never started gets another go.+ if (loadAsked && _url.value.isEmpty() && pageStarts == 0) view.loadUrl(PLAYER_URL)}fun detach() = main.post { (view.parent as? ViewGroup)?.removeView(view) }/** Frees the page (data saver, low memory). [load] brings it back. */- fun unload() = main.post { view.loadUrl("about:blank") }+ fun unload() = main.post { loadAsked = false; view.loadUrl("about:blank") }companion object {/** Logcat tag of the engine: `adb logcat -s Myspoti`. */const val LOG = "Myspoti"const val PLAYER_URL = "https://open.spotify.com/"+ private const val LOAD_WATCH_MS = 4_000L+ private const val LOAD_RETRIES = 4const val LOGIN_URL = "https://accounts.spotify.com/login?continue=https%3A%2F%2Fopen.spotify.com%2F"const val DESKTOP_UA ="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36"