Skip to content

Native Android client for Spotify, built with Jetpack Compose

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.md
index 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.6
diff --git a/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.kt b/base/api-spotify/src/main/kotlin/app/myspoti/spotify/Mappers.kt
index 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 null
return 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.kt
index 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.size
return 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.kt
index 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.kt
index 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: CoroutineScop
when (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? = null
var since = 0L
var attempts = 0
var adAttempts = 0
var adReloaded = false
+ var frozenCheckAt = 0L
+ var frozenReloadAt = 0L
+ var tick = 0
while (true) {
delay(WATCH_TICK_MS)
+ tick++
val s = _state.value
val 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: CoroutineScop
adAttempts = 0
adReloaded = true
bridge.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: CoroutineScop
since = now
attempts++
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 = 2
if (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: CoroutineScop
val 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?.uri
fadeBackTo = target
fadeBack?.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 ?: target
runCatching { 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.0
bridge.call("volume.set", buildJsonObject { put("level", 0.0) })
}
@@ -228,9 +289,11 @@ class SpotifyPlayer(private val bridge: Bridge, private val scope: CoroutineScop
override 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 = false
pausedByUser = false
withFade {
- 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: CoroutineScop
override suspend fun volume(): Double = bridge.call("volume.get").jsonPrimitive.double
override 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: CoroutineScop
val 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_500L
const val STUCK_MS = 8_000L
diff --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.kt
index 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.kt
index 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(): Account
suspend 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): TopContent
suspend 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.kt
index 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.xml
index 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.kt
index 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.kt
index 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.kt
index 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.kt
index 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.kt
index 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.kt
index 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) return
stateSeen = 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
index 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.kt
index 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.pressable
import androidx.compose.ui.res.stringResource
import androidx.compose.material.icons.filled.Check
+import kotlinx.coroutines.flow.first
+import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.MoreVert
import android.annotation.SuppressLint
import androidx.compose.foundation.ExperimentalFoundationApi
@@ -49,6 +51,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.toArgb
import 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.nowPlaying
val 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.kt
index 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.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.drawWithContent
import 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, p
if (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.api
val state = Graph.currentSongState
on.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 = false
state.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.kt
new file mode 100644
index 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.kt
index 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.kt
index 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.onSizeChanged
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.gestures.detectHorizontalDragGestures
import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.ui.input.pointer.positionChange
import android.content.Context
import android.content.Intent
import android.net.Uri
@@ -34,6 +36,7 @@ import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import 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(
@Composable
fun 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.kt
index 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: String
com.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 = following
if (!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.kt
index 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.screens
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Box
import 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.semantics
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import 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) {
@Composable
private 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)
@Composable
diff --git a/base/app/src/main/res/values-fr/myspoti_strings.xml b/base/app/src/main/res/values-fr/myspoti_strings.xml
index 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.xml
index 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.xml
index 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.xml
new file mode 100644
index 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.kt
index 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.kt
index 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_DESCENDANTS
if (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 = 4
const 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"