Skip to content

Native Android client for Spotify, built with Jetpack Compose

Wire Spotify's features into the app: playlist editing, profiles, artist ban, episodes, suggestions, similar albums, library actions; Discord fixes

kota-zo08835c003658
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 66bd4d25..3ab3441e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,11 @@ Each release on GitHub shows its section below. The app shows it too when it off
- **Downloaded songs are no longer reported to Spotify**: no more album starting over a downloaded song.
- **In-app updates**: download and install without leaving the app.
- **Jam QR scan** no longer crashes; a banner tells when downloads need the SpotiFLAC verification.
+- **Your playlists, edited in the app**: name, description, cover (from your photos), public, private or collaborative, delete.
+- **Profiles**: search people, open a profile (followers, public playlists), follow; a playlist's owner opens theirs.
+- **More from Spotify**: "Don't play this artist", save episodes, search suggestions, "More like this" under albums, library sorted by recents or recently added, pin and move items into folders.
+- **Sort in both directions** (tap the chosen sort again), remembered for each playlist.
+- **Fixes**: AMOLED black everywhere, lists no longer end under the mini player, full-screen music videos show, the Spotify account page stays under the status bar, "Saved in" confirms each change, fast skips no longer jam the player, no white screen on phones in light mode.
- **Security and reliability fixes** (Android Auto, library pages, logout, links, video lookups).
## 2.0.0
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 cd41981a..50fbcef4 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
@@ -8,6 +8,7 @@ import app.myspoti.api.LibrarySort
import app.myspoti.api.MediaKind
import app.myspoti.api.Page
import app.myspoti.api.Playlist
+import app.myspoti.api.PlaylistAccess
import app.myspoti.api.PlaylistSort
import app.myspoti.api.Playlists
import app.myspoti.api.SavedTrack
@@ -213,9 +214,17 @@ class SpotifyPlaylists(private val gql: Gql, private val bridge: Bridge, private
override suspend fun setDescription(uri: Uri, description: String) = updateDetails(uri, "description", JsonPrimitive(description))
- override suspend fun setPublic(uri: Uri, public: Boolean) = updateDetails(uri, "public", JsonPrimitive(public))
+ /** The base permission the page's "Make private" and "Invite collaborators" set. */
+ override suspend fun access(uri: Uri): PlaylistAccess =
+ PlaylistAccess.of((bridge.service("PlaylistPermissionsAPI", "getBasePermission", JsonPrimitive(uri)) as? JsonPrimitive)?.content)
- override suspend fun setCollaborative(uri: Uri, collaborative: Boolean) = updateDetails(uri, "collaborative", JsonPrimitive(collaborative))
+ override suspend fun setAccess(uri: Uri, access: PlaylistAccess) {
+ bridge.service("PlaylistPermissionsAPI", "setBasePermission", JsonPrimitive(uri), JsonPrimitive(access.permission))
+ }
+
+ override suspend fun setCover(uri: Uri, jpeg: ByteArray?) {
+ bridge.call("playlist.setCover", json(mapOf("uri" to uri, "jpeg" to jpeg?.let { java.util.Base64.getEncoder().encodeToString(it) })) as kotlinx.serialization.json.JsonObject, timeoutMs = 60_000)
+ }
/** Two updates sent back to back can lose the second one: check it landed, and resend once. */
private suspend fun updateDetails(uri: Uri, field: String, value: JsonElement) {
diff --git a/base/api-spotify/src/main/resources/bridge/player-bridge.js b/base/api-spotify/src/main/resources/bridge/player-bridge.js
index b25f5976..c9847279 100644
--- a/base/api-spotify/src/main/resources/bridge/player-bridge.js
+++ b/base/api-spotify/src/main/resources/bridge/player-bridge.js
@@ -263,6 +263,20 @@
return toJson(await svc[a.method](...(a.args || [])));
},
+ // A playlist's cover, as the page's "Edit details" sets it: the JPEG goes to the image
+ // upload service, then its token to the playlist. No jpeg (null): the cover is removed.
+ // {uri, jpeg: base64 | null}
+ 'playlist.setCover': async a => {
+ const playlists = need().resolve('PlaylistAPI');
+ let token = null;
+ if (a.jpeg) {
+ const bytes = Uint8Array.from(atob(a.jpeg), c => c.charCodeAt(0));
+ token = await playlists.uploadImage(new Blob([bytes], { type: 'image/jpeg' }));
+ }
+ await playlists.updateDetails(a.uri, { imageUploadToken: token });
+ return true;
+ },
+
// Any persisted GraphQL operation of the Web Player, sent by the page's own loader
// (its auth, client token and retries). {name, hash, variables}
'gql.query': async a => {
diff --git a/base/api-spotify/src/test/kotlin/app/myspoti/spotify/SpotifyWritesTest.kt b/base/api-spotify/src/test/kotlin/app/myspoti/spotify/SpotifyWritesTest.kt
index 63a0fc25..13fe2edf 100644
--- a/base/api-spotify/src/test/kotlin/app/myspoti/spotify/SpotifyWritesTest.kt
+++ b/base/api-spotify/src/test/kotlin/app/myspoti/spotify/SpotifyWritesTest.kt
@@ -88,20 +88,19 @@ class SpotifyWritesTest {
assertEquals("""["listenlater",["spotify:episode:e"]]""", host.calls[0].args())
}
- @Test fun `public and collaborative send the flag and check it landed`() = runBridge({ call ->
- when (call.method()) {
- "getMetadata" -> Bridge.json.parseToJsonElement("""{"public":true,"collaborative":false,"name":"x"}""")
- else -> JsonNull
- }
+ @Test fun `public, private and collaborative set the base permission`() = runBridge({ call ->
+ if (call.method() == "getBasePermission") kotlinx.serialization.json.JsonPrimitive("BLOCKED") else JsonNull
}) { host, bridge ->
val playlists = SpotifyPlaylists(FakeGql { _, _ -> JsonNull }, bridge, SpotifyHttp(OkHttpClient(), bridge))
+ playlists.setPublic("spotify:playlist:p", false)
+ playlists.setCollaborative("spotify:playlist:p", true)
playlists.setPublic("spotify:playlist:p", true)
- playlists.setCollaborative("spotify:playlist:p", false)
- val updates = host.calls.filter { it.method() == "updateDetails" }.map { it.args() }
+ val sets = host.calls.filter { it.method() == "setBasePermission" }.map { it.args() }
assertEquals(
- listOf("""["spotify:playlist:p",{"public":true}]""", """["spotify:playlist:p",{"collaborative":false}]"""),
- updates,
+ listOf("""["spotify:playlist:p","BLOCKED"]""", """["spotify:playlist:p","CONTRIBUTOR"]""", """["spotify:playlist:p","VIEWER"]"""),
+ sets,
)
+ assertEquals(app.myspoti.api.PlaylistAccess.PRIVATE, playlists.access("spotify:playlist:p"))
}
@Test fun `rename still sends the name as a string`() = runBridge({ call ->
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 c8e3bad4..9a68283e 100644
--- a/base/api/src/main/kotlin/app/myspoti/api/Api.kt
+++ b/base/api/src/main/kotlin/app/myspoti/api/Api.kt
@@ -134,10 +134,15 @@ interface Playlists {
suspend fun create(name: String, folderUri: Uri? = null): Uri
suspend fun rename(uri: Uri, name: String)
suspend fun setDescription(uri: Uri, description: String)
+ /** Who may see or change the playlist (owner only). */
+ suspend fun access(uri: Uri): PlaylistAccess
+ suspend fun setAccess(uri: Uri, access: PlaylistAccess)
/** Public playlists show on the profile and in search; private ones only to the owner. */
- suspend fun setPublic(uri: Uri, public: Boolean)
+ suspend fun setPublic(uri: Uri, public: Boolean) = setAccess(uri, if (public) PlaylistAccess.PUBLIC else PlaylistAccess.PRIVATE)
/** Collaborative playlists let other users add and remove tracks (owner only). */
- suspend fun setCollaborative(uri: Uri, collaborative: Boolean)
+ suspend fun setCollaborative(uri: Uri, collaborative: Boolean) = setAccess(uri, if (collaborative) PlaylistAccess.COLLABORATIVE else PlaylistAccess.PUBLIC)
+ /** A new cover (JPEG bytes), or null to go back to the generated one. */
+ suspend fun setCover(uri: Uri, jpeg: ByteArray?)
/** Removes the playlist from the library (owners: deletes it; it can be restored for 90 days). */
suspend fun delete(uri: Uri)
suspend fun follow(uri: 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 dbdaf14e..170b1461 100644
--- a/base/api/src/main/kotlin/app/myspoti/api/Models.kt
+++ b/base/api/src/main/kotlin/app/myspoti/api/Models.kt
@@ -60,6 +60,15 @@ data class Playlist(
val followers: Long? = null,
)
+/**
+ * A playlist's base permission, as the Web Player sets it: anyone may view it (public),
+ * nobody but the owner (private, "BLOCKED"), or anyone may add and remove tracks.
+ */
+enum class PlaylistAccess(val permission: String) {
+ PUBLIC("VIEWER"), PRIVATE("BLOCKED"), COLLABORATIVE("CONTRIBUTOR");
+ companion object { fun of(permission: String?) = entries.firstOrNull { it.permission == permission } ?: PUBLIC }
+}
+
/** Client-side orders for a playlist's rows. [CUSTOM] is the playlist's own order. */
enum class PlaylistSort { CUSTOM, TITLE, ARTIST, ALBUM, ADDED_AT, DURATION }
diff --git a/base/app/src/main/java/app/myspoti/MainActivity.kt b/base/app/src/main/java/app/myspoti/MainActivity.kt
index 7b47177a..7daea128 100644
--- a/base/app/src/main/java/app/myspoti/MainActivity.kt
+++ b/base/app/src/main/java/app/myspoti/MainActivity.kt
@@ -213,7 +213,7 @@ class MainActivity : AppCompatActivity() {
@androidx.compose.runtime.Composable
private fun ConnectingScreen() {
androidx.compose.foundation.layout.Box(
- androidx.compose.ui.Modifier.fillMaxSize().background(androidx.compose.ui.graphics.Color(0xFF0E0E13)),
+ androidx.compose.ui.Modifier.fillMaxSize().background(com.music.spotui.ui.theme.AppBackground),
contentAlignment = androidx.compose.ui.Alignment.Center,
) {
androidx.compose.material3.CircularProgressIndicator(color = com.music.spotui.ui.theme.AppAccent)
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 19dc4909..59356dd2 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
@@ -634,11 +634,14 @@ class Api constructor(
subtitle = context.getString(R.string.create_menu_item_folder_title) + " • " +
context.resources.getQuantityString(R.plurals.add_to_playlist_folder_subtitle_playlists_count, item.count ?: 0, (item.count ?: 0).toString()),
coverUri = "", isPlaylist = false, folderUri = item.uri, childCount = item.count ?: 0,
+ uri = item.uri, pinned = item.pinned, addedAt = item.addedAt.orEmpty(),
)
MediaKind.PLAYLIST -> LibraryEntry(item.uri.substringAfterLast(':'), item.name,
- context.getString(R.string.assisted_curation_search_playlist) + (item.subtitle?.let { " • $it" } ?: ""), cover(item.images), isPlaylist = true)
+ context.getString(R.string.assisted_curation_search_playlist) + (item.subtitle?.let { " • $it" } ?: ""), cover(item.images), isPlaylist = true,
+ uri = item.uri, pinned = item.pinned, addedAt = item.addedAt.orEmpty())
MediaKind.ALBUM -> LibraryEntry(item.uri.substringAfterLast(':'), item.name,
- context.getString(R.string.album_type_album) + (item.subtitle?.let { " • $it" } ?: ""), cover(item.images), isPlaylist = false, artists = item.subtitle.orEmpty())
+ context.getString(R.string.album_type_album) + (item.subtitle?.let { " • $it" } ?: ""), cover(item.images), isPlaylist = false, artists = item.subtitle.orEmpty(),
+ uri = item.uri, pinned = item.pinned, addedAt = item.addedAt.orEmpty())
MediaKind.COLLECTION -> if (item.uri == "spotify:collection:tracks") null
else LibraryEntry(EPISODES_ID, item.name, "Podcast", cover(item.images), isPlaylist = true)
else -> null
diff --git a/base/app/src/main/java/com/music/spotui/data/api/LibraryFolders.kt b/base/app/src/main/java/com/music/spotui/data/api/LibraryFolders.kt
index f6e8ab89..74b00c2a 100644
--- a/base/app/src/main/java/com/music/spotui/data/api/LibraryFolders.kt
+++ b/base/app/src/main/java/com/music/spotui/data/api/LibraryFolders.kt
@@ -14,8 +14,12 @@ object LibraryFolders {
suspend fun rename(uri: String, name: String): Boolean =
runCatching { MyspotiRuntime.api.library.renameFolder(uri, name.trim()) }.isSuccess.also { if (it) changed() }
+ /** Deletes a folder (its playlists go to the level above); false when Spotify refused. */
+ suspend fun delete(uri: String): Boolean =
+ runCatching { MyspotiRuntime.api.library.deleteFolder(uri) }.isSuccess.also { if (it) changed() }
+
/** The library changed: the next load must come from Spotify, not from the caches. */
- private fun changed() {
+ fun changed() {
Api.HomeCache.libraryRoot = null
Api.HomeCache.folders.clear()
}
diff --git a/base/app/src/main/java/com/music/spotui/data/entity/LibraryEntry.kt b/base/app/src/main/java/com/music/spotui/data/entity/LibraryEntry.kt
index 2ce0fa75..11fce641 100644
--- a/base/app/src/main/java/com/music/spotui/data/entity/LibraryEntry.kt
+++ b/base/app/src/main/java/com/music/spotui/data/entity/LibraryEntry.kt
@@ -17,6 +17,12 @@ data class LibraryEntry(
val folderUri: String = "",
/** Playlists and folders inside a folder. */
val childCount: Int = 0,
+ /** The Spotify uri (playlist, album, folder); empty for the app's own entries. */
+ val uri: String = "",
+ /** Pinned at the top of Your Library. */
+ val pinned: Boolean = false,
+ /** When it was added to the library (ISO 8601), for "Recently added". */
+ val addedAt: String = "",
) {
val isFolder: Boolean get() = folderUri.isNotBlank()
}
diff --git a/base/app/src/main/java/com/music/spotui/data/local/LibraryOrder.kt b/base/app/src/main/java/com/music/spotui/data/local/LibraryOrder.kt
index e85b3da8..986169d5 100644
--- a/base/app/src/main/java/com/music/spotui/data/local/LibraryOrder.kt
+++ b/base/app/src/main/java/com/music/spotui/data/local/LibraryOrder.kt
@@ -14,7 +14,7 @@ import java.text.Collator
* Files, Downloaded) always stay on top, as in the official app.
*/
object LibraryOrder {
- enum class Sort { CUSTOM, ALPHABETICAL, CREATOR }
+ enum class Sort { CUSTOM, RECENTS, RECENTLY_ADDED, ALPHABETICAL, CREATOR }
const val ROOT = "root"
private const val PREFS = "library_order"
@@ -83,6 +83,10 @@ object LibraryOrder {
rest.withIndex().sortedWith(compareBy({ at[key(it.value)] ?: -1 }, { it.index })).map { it.value }
}
}
+ // Spotify's own order: the most recently played first.
+ Sort.RECENTS -> rest
+ // ISO 8601 dates sort as text; folders (no date) go last.
+ Sort.RECENTLY_ADDED -> rest.sortedByDescending { it.addedAt }
Sort.ALPHABETICAL -> rest.sortedWith { a, b -> collator.compare(a.name, b.name) }
Sort.CREATOR -> rest.sortedWith(
compareBy<LibraryEntry> { !it.isFolder }
@@ -90,6 +94,7 @@ object LibraryOrder {
.then { a, b -> collator.compare(a.name, b.name) },
)
}
- return head + sorted
+ // Items pinned on Spotify stay at the top, in the chosen order.
+ return head + sorted.sortedBy { !it.pinned }
}
}
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 a189c20e..5e4c028f 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
@@ -29,6 +29,8 @@ import java.util.concurrent.ConcurrentHashMap
object SongPlayer {
private const val SPOTIFY_TRACK_PREFIX = "spotify:track:"
private const val PENDING_MS = 6000L
+ /** "Next" taps closer than this are sent as one jump. */
+ private const val SKIP_BURST_MS = 350L
/** After a local file starts, engine states this recent still predate the pause. */
private const val LOCAL_GRACE_MS = 2500L
private const val TAG = "MspPlayer"
@@ -465,7 +467,26 @@ object SongPlayer {
}
fun stop() = pause()
- fun next() { Haptics.click(); if (LocalPlayer.active.value) { LocalPlayer.next(); return }; intendPlaying(); command { api.player.next() } }
+ fun next() {
+ Haptics.click()
+ if (LocalPlayer.active.value) { LocalPlayer.next(); return }
+ intendPlaying()
+ // Taps in a row become one jump: a burst of "next" commands left the Web Player
+ // out of step (state conflicts, then a player stuck until reloaded).
+ pendingSkips++
+ main.removeCallbacks(sendSkips)
+ main.postDelayed(sendSkips, SKIP_BURST_MS)
+ }
+
+ private var pendingSkips = 0
+ private val sendSkips = Runnable {
+ val n = pendingSkips
+ pendingSkips = 0
+ if (n <= 0) return@Runnable
+ val upcoming = apiQueue?.let { it.queued + it.nextUp }.orEmpty()
+ val target = upcoming.getOrNull(n - 1)
+ command { if (n == 1 || target == null) api.player.next() else api.player.skipTo(target) }
+ }
fun previous() { Haptics.click(); if (LocalPlayer.active.value) { LocalPlayer.previous(); return }; intendPlaying(); command { api.player.previous() } }
/** Tracks shufflePlay plays without a context: the first one, plus up to 49 queued. */
diff --git a/base/app/src/main/java/com/music/spotui/ui/components/BottomBarsSpace.kt b/base/app/src/main/java/com/music/spotui/ui/components/BottomBarsSpace.kt
new file mode 100644
index 00000000..ced7251c
--- /dev/null
+++ b/base/app/src/main/java/com/music/spotui/ui/components/BottomBarsSpace.kt
@@ -0,0 +1,16 @@
+package com.music.spotui.ui.components
+
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+/**
+ * The room a scrolling page leaves at its end, so its last rows can scroll above the mini
+ * player, the tabs and the system navigation bar (three buttons or gesture line) instead of
+ * staying under them.
+ */
+@Composable
+fun bottomBarsSpace(): Dp = 160.dp + WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding()
diff --git a/base/app/src/main/java/com/music/spotui/ui/components/PlaylistOptionsSheet.kt b/base/app/src/main/java/com/music/spotui/ui/components/PlaylistOptionsSheet.kt
new file mode 100644
index 00000000..ab43b261
--- /dev/null
+++ b/base/app/src/main/java/com/music/spotui/ui/components/PlaylistOptionsSheet.kt
@@ -0,0 +1,270 @@
+package com.music.spotui.ui.components
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.PickVisualMediaRequest
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.outlined.Delete
+import androidx.compose.material.icons.outlined.Edit
+import androidx.compose.material.icons.outlined.Group
+import androidx.compose.material.icons.outlined.Lock
+import androidx.compose.material.icons.outlined.Person
+import androidx.compose.material.icons.outlined.Public
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+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.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+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 app.myspoti.api.PlaylistAccess
+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.data.entity.ContextPageModel
+import com.music.spotui.ui.theme.AppAccent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * A playlist's ⋯ menu. On your own playlists: edit the name, description and cover, choose
+ * who can see it (public, private, collaborative) and delete it. On someone else's: their
+ * profile. [onChanged] reloads the page after an edit; [onDeleted] leaves it.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun PlaylistOptionsSheet(
+ page: ContextPageModel,
+ onDismiss: () -> Unit,
+ onChanged: () -> Unit,
+ onDeleted: () -> Unit,
+ onProfile: (String) -> Unit,
+) {
+ val context = LocalContext.current
+ val scope = rememberCoroutineScope()
+ LaunchedEffect(Unit) { com.music.spotui.data.api.ProfileCache.ensure(context) }
+ val mine = com.music.spotui.data.api.ProfileCache.id?.let { page.ownerUri == "spotify:user:$it" } == true
+ var access by remember { mutableStateOf<PlaylistAccess?>(null) }
+ var editing by remember { mutableStateOf(false) }
+ var deleting by remember { mutableStateOf(false) }
+ LaunchedEffect(page.uri, mine) {
+ if (mine) access = runCatching { MyspotiRuntime.api.playlists.access(page.uri) }.getOrNull()
+ }
+
+ fun run(block: suspend () -> Unit, after: () -> Unit = onChanged) = scope.launch {
+ runCatching { block() }
+ .onSuccess { after() }
+ .onFailure { android.widget.Toast.makeText(context, R.string.playlist_change_refused, android.widget.Toast.LENGTH_SHORT).show() }
+ }
+
+ ModalBottomSheet(onDismissRequest = onDismiss, containerColor = Color(0xFF282828)) {
+ Column(Modifier.navigationBarsPadding().padding(bottom = 12.dp)) {
+ Text(page.name, color = Color.White, fontSize = 18.sp, fontWeight = FontWeight.Bold, maxLines = 1,
+ overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(20.dp, 0.dp, 20.dp, 12.dp))
+ if (mine) {
+ OptionRow(Icons.Outlined.Edit, stringResource(R.string.playlist_edit_details)) { editing = true }
+ Text(stringResource(R.string.playlist_access_title), color = Color(0xFFB3B3B3), fontSize = 13.sp,
+ modifier = Modifier.padding(20.dp, 12.dp, 20.dp, 4.dp))
+ AccessRow(Icons.Outlined.Public, R.string.playlist_access_public, R.string.playlist_access_public_detail, access == PlaylistAccess.PUBLIC) {
+ access = PlaylistAccess.PUBLIC; run({ MyspotiRuntime.api.playlists.setAccess(page.uri, PlaylistAccess.PUBLIC) }, {})
+ }
+ AccessRow(Icons.Outlined.Lock, R.string.playlist_access_private, R.string.playlist_access_private_detail, access == PlaylistAccess.PRIVATE) {
+ access = PlaylistAccess.PRIVATE; run({ MyspotiRuntime.api.playlists.setAccess(page.uri, PlaylistAccess.PRIVATE) }, {})
+ }
+ AccessRow(Icons.Outlined.Group, R.string.playlist_access_collaborative, R.string.playlist_access_collaborative_detail, access == PlaylistAccess.COLLABORATIVE) {
+ access = PlaylistAccess.COLLABORATIVE; run({ MyspotiRuntime.api.playlists.setAccess(page.uri, PlaylistAccess.COLLABORATIVE) }, {})
+ }
+ Spacer(Modifier.height(8.dp))
+ OptionRow(Icons.Outlined.Delete, stringResource(R.string.local_delete_playlist)) { deleting = true }
+ } else if (page.ownerUri.startsWith("spotify:user:")) {
+ OptionRow(Icons.Outlined.Person, stringResource(R.string.go_to_profile)) {
+ onDismiss(); onProfile(page.ownerUri.substringAfterLast(':'))
+ }
+ }
+ }
+ }
+
+ if (editing) EditDetailsDialog(page, onDismiss = { editing = false }) { name, description, cover ->
+ editing = false
+ run({
+ if (name != page.name) MyspotiRuntime.api.playlists.rename(page.uri, name)
+ if (description != page.description) MyspotiRuntime.api.playlists.setDescription(page.uri, description)
+ when (cover) {
+ is CoverChange.New -> MyspotiRuntime.api.playlists.setCover(page.uri, cover.jpeg)
+ CoverChange.Remove -> MyspotiRuntime.api.playlists.setCover(page.uri, null)
+ CoverChange.Keep -> {}
+ }
+ }, {
+ android.widget.Toast.makeText(context, R.string.playlist_saved, android.widget.Toast.LENGTH_SHORT).show()
+ onDismiss(); onChanged()
+ })
+ }
+
+ if (deleting) AlertDialog(
+ onDismissRequest = { deleting = false },
+ containerColor = Color(0xFF282828),
+ text = { Text(stringResource(R.string.playlist_delete_confirm, page.name), color = Color.White) },
+ confirmButton = {
+ TextButton(onClick = {
+ deleting = false
+ run({ MyspotiRuntime.api.playlists.delete(page.uri) }, { onDismiss(); onDeleted() })
+ }) { Text(stringResource(R.string.actions_picker_delete), color = Color(0xFFF15E6C)) }
+ },
+ dismissButton = { TextButton(onClick = { deleting = false }) { Text(stringResource(R.string.cancel), color = Color.White) } },
+ )
+}
+
+private sealed interface CoverChange {
+ data object Keep : CoverChange
+ data object Remove : CoverChange
+ class New(val jpeg: ByteArray, val preview: Bitmap) : CoverChange
+}
+
+@OptIn(ExperimentalGlideComposeApi::class)
+@Composable
+private fun EditDetailsDialog(page: ContextPageModel, onDismiss: () -> Unit, onSave: (String, String, CoverChange) -> Unit) {
+ val context = LocalContext.current
+ val scope = rememberCoroutineScope()
+ var name by remember { mutableStateOf(page.name) }
+ var description by remember { mutableStateOf(page.description) }
+ var cover by remember { mutableStateOf<CoverChange>(CoverChange.Keep) }
+ val picker = rememberLauncherForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
+ if (uri != null) scope.launch {
+ val made = withContext(Dispatchers.Default) { runCatching { coverJpeg(context, uri) }.getOrNull() }
+ if (made != null) cover = CoverChange.New(made.first, made.second)
+ }
+ }
+ val fieldColors = OutlinedTextFieldDefaults.colors(
+ focusedTextColor = Color.White, unfocusedTextColor = Color.White, cursorColor = AppAccent,
+ focusedBorderColor = AppAccent, unfocusedBorderColor = Color(0xFF555555),
+ focusedLabelColor = AppAccent, unfocusedLabelColor = Color(0xFFB3B3B3),
+ )
+ AlertDialog(
+ onDismissRequest = onDismiss,
+ containerColor = Color(0xFF282828),
+ title = { Text(stringResource(R.string.playlist_edit_details), color = Color.White) },
+ text = {
+ Column {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ val c = cover
+ Box(Modifier.size(96.dp).clip(RoundedCornerShape(4.dp)).background(Color(0xFF3A3A3A))
+ .clickable { picker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)) }) {
+ when (c) {
+ is CoverChange.New -> Image(c.preview.asImageBitmap(), null, contentScale = ContentScale.Crop, modifier = Modifier.size(96.dp))
+ CoverChange.Remove -> {}
+ CoverChange.Keep -> GlideImage(page.coverUri, null, contentScale = ContentScale.Crop,
+ failure = placeholder(R.drawable.placeholder), modifier = Modifier.size(96.dp))
+ }
+ }
+ Spacer(Modifier.width(12.dp))
+ Column {
+ TextButton(onClick = { picker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)) }) {
+ Text(stringResource(R.string.playlist_change_cover), color = Color.White)
+ }
+ TextButton(onClick = { cover = CoverChange.Remove }) {
+ Text(stringResource(R.string.playlist_remove_cover), color = Color(0xFFB3B3B3))
+ }
+ }
+ }
+ Spacer(Modifier.height(12.dp))
+ OutlinedTextField(name, { name = it }, label = { Text(stringResource(R.string.playlist_name_label)) },
+ singleLine = true, colors = fieldColors, modifier = Modifier.fillMaxWidth())
+ Spacer(Modifier.height(8.dp))
+ OutlinedTextField(description, { description = it }, label = { Text(stringResource(R.string.playlist_description_label)) },
+ minLines = 2, maxLines = 4, colors = fieldColors, modifier = Modifier.fillMaxWidth())
+ }
+ },
+ confirmButton = {
+ TextButton(enabled = name.isNotBlank(), onClick = { onSave(name.trim(), description.trim(), cover) }) {
+ Text(stringResource(R.string.playlist_save), color = AppAccent, fontWeight = FontWeight.Bold)
+ }
+ },
+ dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.cancel), color = Color.White) } },
+ )
+}
+
+/** The picked image as Spotify takes a cover: square, 640 px, JPEG under 256 KB. */
+private fun coverJpeg(context: Context, uri: Uri): Pair<ByteArray, Bitmap> {
+ val source = context.contentResolver.openInputStream(uri).use { android.graphics.BitmapFactory.decodeStream(it) }
+ ?: error("not an image")
+ val side = minOf(source.width, source.height)
+ val square = Bitmap.createBitmap(source, (source.width - side) / 2, (source.height - side) / 2, side, side)
+ val scaled = Bitmap.createScaledBitmap(square, 640, 640, true)
+ var quality = 90
+ var bytes: ByteArray
+ do {
+ bytes = java.io.ByteArrayOutputStream().also { scaled.compress(Bitmap.CompressFormat.JPEG, quality, it) }.toByteArray()
+ quality -= 10
+ } while (bytes.size > 256 * 1024 && quality > 30)
+ return bytes to scaled
+}
+
+@Composable
+private fun OptionRow(icon: ImageVector, label: String, onClick: () -> Unit) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.fillMaxWidth().clickable(onClick = onClick).padding(horizontal = 20.dp, vertical = 14.dp),
+ ) {
+ Icon(icon, null, tint = Color.White, modifier = Modifier.size(24.dp))
+ Spacer(Modifier.width(16.dp))
+ Text(label, color = Color.White, fontSize = 16.sp)
+ }
+}
+
+@Composable
+private fun AccessRow(icon: ImageVector, label: Int, detail: Int, selected: Boolean, onClick: () -> Unit) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.fillMaxWidth().clickable(onClick = onClick).padding(horizontal = 20.dp, vertical = 10.dp),
+ ) {
+ Icon(icon, null, tint = if (selected) AppAccent else Color.White, modifier = Modifier.size(24.dp))
+ Spacer(Modifier.width(16.dp))
+ Column(Modifier.weight(1f)) {
+ Text(stringResource(label), color = if (selected) AppAccent else Color.White, fontSize = 16.sp)
+ Text(stringResource(detail), color = Color(0xFFB3B3B3), fontSize = 13.sp)
+ }
+ if (selected) Icon(Icons.Default.Check, null, tint = AppAccent, modifier = Modifier.size(20.dp))
+ }
+}
diff --git a/base/app/src/main/java/com/music/spotui/ui/components/SavedInSheet.kt b/base/app/src/main/java/com/music/spotui/ui/components/SavedInSheet.kt
index 911564ce..cc60b93d 100644
--- a/base/app/src/main/java/com/music/spotui/ui/components/SavedInSheet.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/components/SavedInSheet.kt
@@ -250,10 +250,16 @@ fun SavedInSheet(
if (song.spotifyTrackId.isBlank()) return@SavedInRow
membership[pl.id] = !saved
// Refused by Spotify: back to the real state, and say so.
+ // Done or refused: say it, so nobody has to open the playlist to check.
val done: (Boolean) -> Unit = { ok ->
- if (!ok) android.os.Handler(android.os.Looper.getMainLooper()).post {
- membership[pl.id] = saved
- android.widget.Toast.makeText(context, context.getString(R.string.playlist_change_refused), android.widget.Toast.LENGTH_SHORT).show()
+ android.os.Handler(android.os.Looper.getMainLooper()).post {
+ if (!ok) membership[pl.id] = saved
+ val text = when {
+ !ok -> context.getString(R.string.playlist_change_refused)
+ saved -> context.getString(R.string.removed_from, pl.name)
+ else -> context.getString(R.string.local_added_to, pl.name)
+ }
+ android.widget.Toast.makeText(context, text, android.widget.Toast.LENGTH_SHORT).show()
}
}
if (saved) SpotifySync.removeTrackFromPlaylist(context, pl.id, song.spotifyTrackId, done)
@@ -262,7 +268,15 @@ fun SavedInSheet(
}
}
}
- Spacer(modifier = Modifier.padding(10.dp))
+ // Spotify's own "Done": closes the sheet once the changes are made.
+ Box(Modifier.fillMaxWidth().padding(top = 12.dp, bottom = 8.dp), contentAlignment = Alignment.Center) {
+ Text(
+ stringResource(R.string.done),
+ color = Color.Black, fontSize = 15.sp, fontWeight = FontWeight.Bold,
+ modifier = Modifier.clip(RoundedCornerShape(50)).background(SpotifyGreen)
+ .clickable(onClick = onDismiss).padding(horizontal = 36.dp, vertical = 12.dp),
+ )
+ }
}
}
}
diff --git a/base/app/src/main/java/com/music/spotui/ui/components/SongOptionsSheet.kt b/base/app/src/main/java/com/music/spotui/ui/components/SongOptionsSheet.kt
index 9040e727..4488cbcc 100644
--- a/base/app/src/main/java/com/music/spotui/ui/components/SongOptionsSheet.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/components/SongOptionsSheet.kt
@@ -37,6 +37,7 @@ import androidx.compose.material.icons.outlined.Radio
import androidx.compose.material.icons.outlined.Share
import androidx.compose.material.icons.outlined.Info
import androidx.compose.material.icons.outlined.Block
+import androidx.compose.material.icons.outlined.Bookmark
import androidx.compose.material.icons.outlined.Speed
import kotlinx.coroutines.launch
import androidx.compose.material3.ExperimentalMaterial3Api
@@ -222,6 +223,40 @@ fun SongOptionsSheet(
com.music.spotui.di.Haptics.confirm()
onDismiss()
}
+ // "Don't play this artist": the track's first artist, kept out of radios and mixes.
+ val artistBan by androidx.compose.runtime.produceState<Pair<String, Boolean>?>(null, trackUri) {
+ if (!hasId) return@produceState
+ val api = app.myspoti.host.android.MyspotiRuntime.api
+ value = runCatching {
+ val artist = api.catalog.track(trackUri).artists.first().uri
+ artist to api.extras.isArtistBanned(listOf(artist)).single()
+ }.getOrNull()
+ }
+ MenuRow(Icons.Outlined.Block, stringResource(if (artistBan?.second == true) R.string.artist_unban else R.string.artist_ban),
+ enabled = artistBan != null) {
+ val (artist, banned) = artistBan ?: return@MenuRow
+ app.myspoti.host.android.MyspotiRuntime.scope.launch {
+ runCatching { app.myspoti.host.android.MyspotiRuntime.api.extras.setArtistBanned(artist, !banned) }
+ }
+ toast(context.getString(if (banned) R.string.artist_unbanned else R.string.artist_banned, song.singer.substringBefore(",").trim()))
+ com.music.spotui.di.Haptics.confirm()
+ onDismiss()
+ }
+ // An episode: in or out of Your Episodes.
+ if (song.url.startsWith("episode:")) {
+ val episodeUri = "spotify:episode:" + song.url.removePrefix("episode:")
+ val saved by androidx.compose.runtime.produceState<Boolean?>(null, episodeUri) {
+ value = runCatching { app.myspoti.host.android.MyspotiRuntime.api.library.contains(listOf(episodeUri)).single() }.getOrNull()
+ }
+ MenuRow(Icons.Outlined.Bookmark, stringResource(if (saved == true) R.string.episode_unsave else R.string.episode_save), enabled = saved != null) {
+ val save = saved != true
+ app.myspoti.host.android.MyspotiRuntime.scope.launch {
+ runCatching { app.myspoti.host.android.MyspotiRuntime.api.podcasts.setEpisodeSaved(episodeUri, save) }
+ }
+ com.music.spotui.di.Haptics.confirm()
+ onDismiss()
+ }
+ }
if (nowPlaying && song.url.startsWith("episode:")) {
MenuRow(Icons.Outlined.Speed, stringResource(R.string.playback_speed)) { showSpeed = true }
}
diff --git a/base/app/src/main/java/com/music/spotui/ui/components/SwipeToQueue.kt b/base/app/src/main/java/com/music/spotui/ui/components/SwipeToQueue.kt
index 33e343e5..14a6ddce 100644
--- a/base/app/src/main/java/com/music/spotui/ui/components/SwipeToQueue.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/components/SwipeToQueue.kt
@@ -71,7 +71,7 @@ fun SwipeToQueue(song: SongsModel, content: @Composable () -> Unit) {
Box(
modifier = Modifier
.offset { IntOffset(offset.value.roundToInt(), 0) }
- .background(Color(0xFF121212))
+ .background(com.music.spotui.ui.theme.AppBackground)
.pointerInput(song.id) {
detectHorizontalDragGestures(
onDragEnd = {
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 1ac31240..88e252f8 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
@@ -226,6 +226,19 @@ fun MyNavHost(
pId?.let { ContextScreen(navHostController, type = "playlist", id = it) }
}
+ page(
+ "${Routes.Profile.route}/{uId}?name={name}",
+ arguments = listOf(navArgument("name") { defaultValue = "" }),
+ ) { navBackStackEntry ->
+ LaunchedEffect(playerState) {
+ bottomBarState.value = true
+ bottomBarPlayerState.value = playerState != ""
+ }
+ val uId = navBackStackEntry.arguments?.getString("uId")
+ val name = navBackStackEntry.arguments?.getString("name").orEmpty()
+ uId?.let { com.music.spotui.ui.screens.ProfileScreen(navHostController, userId = it, userName = name) }
+ }
+
page(
"${Routes.Show.route}/{sId}?name={name}",
arguments = listOf(navArgument("name") { defaultValue = "" }),
diff --git a/base/app/src/main/java/com/music/spotui/ui/navigation/Routes.kt b/base/app/src/main/java/com/music/spotui/ui/navigation/Routes.kt
index 236093b3..72ad1457 100644
--- a/base/app/src/main/java/com/music/spotui/ui/navigation/Routes.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/navigation/Routes.kt
@@ -31,8 +31,13 @@ sealed class Routes(
object Recap : Routes(0, "Recap", "recap")
object Spotiflac : Routes(0, "SpotiFLAC", "spotiflac")
object Settings : Routes(0, "Settings", "settings")
+ object Profile : Routes(0, "Profile", "profile")
}
+/** A Spotify user's profile, by user id (the part after spotify:user:). */
+fun profileRoute(userId: String, name: String = ""): String =
+ "${Routes.Profile.route}/${android.net.Uri.encode(userId)}?name=${android.net.Uri.encode(name)}"
+
/** Builds a Browse-category route carrying the search genre and a display title. */
fun categoryRoute(genre: String, title: String): String =
"${Routes.Category.route}/${android.net.Uri.encode(genre)}?title=${android.net.Uri.encode(title)}"
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/AccountBrowser.kt b/base/app/src/main/java/com/music/spotui/ui/screens/AccountBrowser.kt
index 6cde2f24..375f07da 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/AccountBrowser.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/AccountBrowser.kt
@@ -41,7 +41,16 @@ class AccountBrowser : ComponentActivity() {
lifecycleScope.launch {
web.loadUrl(withContext(Dispatchers.IO) { runCatching { localized(url, language) }.getOrNull() } ?: url)
}
- setContentView(web)
+ // Android draws apps edge to edge: the page sits in a frame kept out from under the
+ // status and navigation bars (a WebView's own padding does not move its content).
+ val frame = android.widget.FrameLayout(this).apply { setBackgroundColor(android.graphics.Color.BLACK); addView(web) }
+ setContentView(frame)
+ androidx.core.view.ViewCompat.setOnApplyWindowInsetsListener(frame) { v, insets ->
+ val bars = insets.getInsets(androidx.core.view.WindowInsetsCompat.Type.systemBars() or
+ androidx.core.view.WindowInsetsCompat.Type.displayCutout())
+ v.setPadding(bars.left, bars.top, bars.right, bars.bottom)
+ insets
+ }
onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
override fun handleOnBackPressed() { if (web.canGoBack()) web.goBack() else finish() }
})
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 a3313f15..c08f4caf 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
@@ -160,7 +160,7 @@ private fun ArtistOverviewContent(
Box(modifier = Modifier.fillMaxSize()) {
LazyColumn(
state = listState,
- contentPadding = PaddingValues(bottom = 130.dp),
+ contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.background(Color(AppBackground.toArgb()))
@@ -681,7 +681,7 @@ fun ArtistReleasesScreen(navController: NavController, artistName: String) {
}
LazyColumn(
- contentPadding = PaddingValues(bottom = 130.dp),
+ contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.background(Color(AppBackground.toArgb()))
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/CategoryScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/CategoryScreen.kt
index 1e50f6d5..fb65ba0e 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/CategoryScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/CategoryScreen.kt
@@ -61,7 +61,7 @@ fun CategoryScreen(navController: NavController, genre: String, title: String) {
Column(
modifier = Modifier
.fillMaxSize()
- .background(Color(0xFF0E0E13))
+ .background(com.music.spotui.ui.theme.AppBackground)
.statusBarsPadding()
) {
Row(
@@ -108,7 +108,7 @@ private fun CategoryGrid(entries: List<LibraryEntry>, navController: NavControll
}
LazyVerticalGrid(
columns = GridCells.Fixed(2),
- contentPadding = PaddingValues(12.dp, 8.dp, 12.dp, 130.dp),
+ contentPadding = PaddingValues(12.dp, 8.dp, 12.dp, com.music.spotui.ui.components.bottomBarsSpace()),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalArrangement = Arrangement.spacedBy(16.dp),
modifier = Modifier.fillMaxSize(),
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 f62295b2..e69686b5 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
@@ -1,6 +1,8 @@
package com.music.spotui.ui.screens
import androidx.compose.material.icons.filled.SwapVert
+import androidx.compose.material.icons.filled.ArrowUpward
+import androidx.compose.material.icons.filled.ArrowDownward
import androidx.compose.ui.res.stringResource
import kotlinx.coroutines.flow.first
@@ -151,7 +153,19 @@ class ContextViewModel(
private var key: String? = null
private var savedChecked = 0
+ private var lastType = ""
+ private var lastId = ""
+
+ /** After an edit (name, cover, description): the page from the server again. */
+ fun reload() {
+ val k = key ?: return
+ recent.remove(k)
+ key = null
+ load(lastType, lastId)
+ }
+
fun load(type: String, id: String) {
+ lastType = type; lastId = id
if (key == "$type:$id") return
key = "$type:$id"
// A page seen recently is on screen from the first frame (no blank, then pop,
@@ -248,13 +262,13 @@ class ContextViewModel(
}
}
- fun play(p: ContextPageModel, song: SongsModel, sort: TrackSort = TrackSort.CUSTOM) {
+ fun play(p: ContextPageModel, song: SongsModel, sort: TrackOrder = TrackOrder()) {
// No connection (the Web Player cannot stream), or the data saver on mobile data:
// the page's downloaded songs play from the phone.
val app = Graph.app
if (com.music.spotui.data.offline.OfflineStore.isDownloaded(song.spotifyTrackId) &&
(com.music.spotui.data.DataSaver.active || !com.music.spotui.data.offline.OfflineStore.isOnline(app))) {
- val local = p.tracks.mapNotNull { com.music.spotui.data.offline.OfflineStore.tracks[it.spotifyTrackId] }.distinctBy { it.trackId }
+ val local = sort.apply(p.tracks).mapNotNull { com.music.spotui.data.offline.OfflineStore.tracks[it.spotifyTrackId] }.distinctBy { it.trackId }
val at = local.indexOfFirst { it.trackId == song.spotifyTrackId }.coerceAtLeast(0)
if (local.size < p.tracks.size)
android.widget.Toast.makeText(app, app.getString(R.string.offline_only_downloaded, local.size, p.tracks.size), android.widget.Toast.LENGTH_SHORT).show()
@@ -264,7 +278,7 @@ class ContextViewModel(
state.updateQueue(p.tracks)
if (p.type == "liked") SongPlayer.registerLikedSongs(p.tracks.map { it.url })
// Sorted by the user: Spotify plays the list in that order, not the playlist's.
- val order = if (sort == TrackSort.CUSTOM) null else sort.apply(p.tracks).map { "spotify:track:${it.spotifyTrackId}" }
+ val order = if (sort.isCustom) null else sort.apply(p.tracks).map { "spotify:track:${it.spotifyTrackId}" }
if (order != null) state.updateQueue(sort.apply(p.tracks))
SongPlayer.playSong(song.url, contextUri = p.uri, order = order)
state.updateSongState(song.coverUri, song.title, song.singer, true, song.id, 0, song.album)
@@ -312,9 +326,18 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p
var menuSong by remember { mutableStateOf<SongsModel?>(null) }
// "Find in Liked Songs / in playlist".
var find by remember { mutableStateOf("") }
- // "Sort by" for the list (kept per list while the screen lives).
- var sort by remember(p.uri) { mutableStateOf(TrackSort.CUSTOM) }
+ // "Sort by" for the list, kept per list (also after leaving it or restarting the app).
+ val ctx = LocalContext.current
+ var sort by remember(p.uri) { mutableStateOf(TrackOrder.load(ctx, p.uri)) }
var askRemoveDownloads by remember { mutableStateOf(false) }
+ var playlistMenu by remember { mutableStateOf(false) }
+ if (playlistMenu) com.music.spotui.ui.components.PlaylistOptionsSheet(
+ page = p,
+ onDismiss = { playlistMenu = false },
+ onChanged = { vm.reload() },
+ onDeleted = { navController.navigateUp() },
+ onProfile = { navController.navigate(com.music.spotui.ui.navigation.profileRoute(it, p.ownerName)) },
+ )
if (askRemoveDownloads) androidx.compose.material3.AlertDialog(
onDismissRequest = { askRemoveDownloads = false },
containerColor = Color(0xFF282828),
@@ -388,6 +411,8 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p
modifier = Modifier.pressable(0.96f) {
if (p.ownerUri.startsWith("spotify:artist:")) {
navController.navigate(artistRoute(p.ownerName.substringBefore(",").trim(), p.ownerUri.substringAfterLast(":")))
+ } else if (p.ownerUri.startsWith("spotify:user:")) {
+ navController.navigate(com.music.spotui.ui.navigation.profileRoute(p.ownerUri.substringAfterLast(":"), p.ownerName))
}
},
) {
@@ -455,6 +480,11 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p
}
}
}
+ if (p.type == "playlist") {
+ Spacer(Modifier.width(16.dp))
+ Icon(Icons.Default.MoreVert, stringResource(R.string.content_description_context_menu), tint = Color.White.copy(alpha = 0.8f),
+ modifier = Modifier.size(26.dp).pressable(0.9f) { playlistMenu = true })
+ }
Spacer(Modifier.weight(1f))
val smart = SmartShuffle.on.value == p.uri
Box {
@@ -527,7 +557,7 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p
stringResource(if (p.type == "liked") R.string.find_in_context_edit_text_liked_songs_hint else R.string.find_in_context_edit_text_playlist_hint),
Modifier.weight(1f),
)
- TrackSortButton(sort) { sort = it }
+ TrackSortButton(sort) { sort = it; TrackOrder.save(ctx, p.uri, it) }
}
}
if (rows.isEmpty() && find.isNotBlank()) item(key = "find-empty") {
@@ -556,7 +586,9 @@ private fun ContextContent(navController: NavController, vm: ContextViewModel, p
localItems(additions, p.name) { com.music.spotui.data.local.LocalPlaylists.removeFromSpotify(playlistId, it.key) }
}
}
- item { Spacer(Modifier.height(160.dp)) }
+ // An album: Spotify's "More like this", albums close to its first song.
+ 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())) }
}
}
@@ -659,7 +691,7 @@ enum class TrackSort(val label: Int) {
DURATION(R.string.track_sort_duration),
ADDED(R.string.track_sort_added);
- fun apply(songs: List<SongsModel>): List<SongsModel> {
+ internal fun natural(songs: List<SongsModel>): List<SongsModel> {
val text = java.text.Collator.getInstance().apply { strength = java.text.Collator.PRIMARY }
return when (this) {
CUSTOM -> songs
@@ -673,24 +705,89 @@ enum class TrackSort(val label: Int) {
}
}
+/**
+ * A sort and its direction. [reversed] flips the sort's natural order (A to Z, shortest
+ * first, newest first for date added); for [TrackSort.CUSTOM], the playlist from its end.
+ */
+data class TrackOrder(val sort: TrackSort = TrackSort.CUSTOM, val reversed: Boolean = false) {
+ val isCustom get() = sort == TrackSort.CUSTOM && !reversed
+
+ fun apply(songs: List<SongsModel>): List<SongsModel> = sort.natural(songs).let { if (reversed) it.asReversed() else it }
+
+ companion object {
+ private const val PREFS = "track_sort"
+
+ fun load(context: android.content.Context, uri: String): TrackOrder {
+ val v = context.getSharedPreferences(PREFS, android.content.Context.MODE_PRIVATE).getString(uri, null) ?: return TrackOrder()
+ val sort = TrackSort.entries.firstOrNull { it.name == v.substringBefore(':') } ?: return TrackOrder()
+ return TrackOrder(sort, v.endsWith(":reversed"))
+ }
+
+ fun save(context: android.content.Context, uri: String, order: TrackOrder) {
+ context.getSharedPreferences(PREFS, android.content.Context.MODE_PRIVATE).edit().apply {
+ if (order == TrackOrder()) remove(uri) else putString(uri, order.sort.name + if (order.reversed) ":reversed" else "")
+ }.apply()
+ }
+ }
+}
+
+/** Spotify's sort menu: picking the sort already chosen flips its direction (the arrow shows it). */
@Composable
-private fun TrackSortButton(sort: TrackSort, onSort: (TrackSort) -> Unit) {
+private fun TrackSortButton(sort: TrackOrder, onSort: (TrackOrder) -> Unit) {
var open by remember { mutableStateOf(false) }
Box {
androidx.compose.material3.IconButton(onClick = { open = true }) {
Icon(androidx.compose.material.icons.Icons.Default.SwapVert,
contentDescription = stringResource(R.string.filter_and_sort_sort_section_title),
- tint = if (sort == TrackSort.CUSTOM) Color.White else SpotifyGreen)
+ tint = if (sort.isCustom) Color.White else SpotifyGreen)
}
androidx.compose.material3.DropdownMenu(expanded = open, onDismissRequest = { open = false }, containerColor = Color(0xFF282828)) {
Text(stringResource(R.string.filter_and_sort_sort_section_title), color = Color(0xFFB3B3B3), fontSize = 13.sp,
modifier = Modifier.padding(horizontal = 16.dp, vertical = 6.dp))
TrackSort.entries.forEach { option ->
androidx.compose.material3.DropdownMenuItem(
- text = { Text(stringResource(option.label), color = if (option == sort) SpotifyGreen else Color.White) },
- onClick = { open = false; onSort(option) },
+ text = { Text(stringResource(option.label), color = if (option == sort.sort) SpotifyGreen else Color.White) },
+ trailingIcon = if (option == sort.sort) { {
+ Icon(if (sort.reversed) Icons.Default.ArrowUpward else Icons.Default.ArrowDownward,
+ contentDescription = null, tint = SpotifyGreen, modifier = Modifier.size(18.dp))
+ } } else null,
+ onClick = { open = false; onSort(if (option == sort.sort) sort.copy(reversed = !sort.reversed) else TrackOrder(option)) },
)
}
}
}
}
+
+
+/** "More like this" under an album: Spotify's similar albums, from its first song. */
+@OptIn(com.bumptech.glide.integration.compose.ExperimentalGlideComposeApi::class)
+@Composable
+private fun SimilarAlbums(navController: NavController, firstTrackId: String, albumUri: String) {
+ val albums by androidx.compose.runtime.produceState(emptyList<app.myspoti.api.Album>(), firstTrackId) {
+ if (firstTrackId.isBlank()) return@produceState
+ value = runCatching { app.myspoti.host.android.MyspotiRuntime.api.catalog.similarAlbums("spotify:track:$firstTrackId", 12) }
+ .getOrDefault(emptyList()).filter { it.uri != albumUri }
+ }
+ if (albums.isEmpty()) return
+ Column(Modifier.padding(top = 24.dp)) {
+ Text(stringResource(R.string.more_like_this), color = Color.White, fontSize = 20.sp, fontWeight = FontWeight.Bold,
+ modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp))
+ androidx.compose.foundation.lazy.LazyRow(
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(horizontal = 16.dp),
+ horizontalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ items(albums.size) { i ->
+ val a = albums[i]
+ val artists = a.artists.joinToString(", ") { it.name }
+ Column(Modifier.width(140.dp).pressable(0.96f) {
+ navController.navigate(com.music.spotui.ui.navigation.albumRoute(a.name, artists, a.uri.substringAfterLast(':')))
+ }) {
+ GlideImage(model = a.images.maxByOrNull { it.width ?: 0 }?.url, contentDescription = null, contentScale = ContentScale.Crop,
+ modifier = Modifier.size(140.dp).clip(RoundedCornerShape(4.dp)))
+ Text(a.name, color = Color.White, fontSize = 13.sp, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(top = 6.dp))
+ Text(artists, color = Color(0xFFB3B3B3), fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
+ }
+ }
+ }
+}
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/DiscoverScreens.kt b/base/app/src/main/java/com/music/spotui/ui/screens/DiscoverScreens.kt
index 1554aeaa..3fa51ff0 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/DiscoverScreens.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/DiscoverScreens.kt
@@ -58,7 +58,7 @@ import com.music.spotui.di.SongPlayer
import com.music.spotui.ui.navigation.albumRoute
import com.music.spotui.ui.theme.AppAccent
-private val Background = Color(0xFF0E0E13)
+private val Background: Color get() = com.music.spotui.ui.theme.AppBackground
private val Subtle = Color(0xFFB3B3B3)
@Composable
@@ -110,7 +110,7 @@ fun NewReleasesScreen(navController: NavController) {
ScreenHeader(stringResource(R.string.browse_new_releases), navController)
LazyVerticalGrid(
columns = GridCells.Fixed(2),
- contentPadding = PaddingValues(12.dp, 0.dp, 12.dp, 130.dp),
+ contentPadding = PaddingValues(12.dp, 0.dp, 12.dp, com.music.spotui.ui.components.bottomBarsSpace()),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalArrangement = Arrangement.spacedBy(16.dp),
modifier = Modifier.fillMaxSize(),
@@ -149,7 +149,7 @@ fun EpisodesScreen(navController: NavController) {
when (val list = episodes) {
null -> Loading()
else -> if (list.isEmpty()) Text(stringResource(R.string.your_episodes_empty), color = Subtle, fontSize = 14.sp, modifier = Modifier.padding(20.dp))
- else LazyColumn(contentPadding = PaddingValues(bottom = 130.dp)) {
+ else LazyColumn(contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace())) {
items(list, key = { it.url }) { e ->
Row(
verticalAlignment = Alignment.CenterVertically,
@@ -193,7 +193,7 @@ fun RecapScreen(navController: NavController) {
val recap = loaded ?: ListenHistory.Recap(0, 0, emptyMap(), emptyList(), emptyList(), emptyList())
Column(Modifier.fillMaxSize().background(Background).statusBarsPadding()) {
ScreenHeader(stringResource(R.string.recap_title), navController)
- LazyColumn(contentPadding = PaddingValues(bottom = 130.dp)) {
+ LazyColumn(contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace())) {
item {
Row(Modifier.padding(horizontal = 16.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
periods.forEachIndexed { i, (label, _) ->
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/DownloadsScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/DownloadsScreen.kt
index b7cfdd4c..ae8ee60f 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/DownloadsScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/DownloadsScreen.kt
@@ -199,7 +199,7 @@ fun DownloadsScreen(navController: NavController) {
modifier = Modifier.size(24.dp).pressable(0.96f) { menuSong = OfflineStore.toSong(t) })
} }
}
- item { Spacer(Modifier.height(140.dp)) }
+ item { Spacer(Modifier.height(com.music.spotui.ui.components.bottomBarsSpace())) }
}
Box(
contentAlignment = Alignment.Center,
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/HomeScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/HomeScreen.kt
index 6a0358ce..cb98b0fd 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/HomeScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/HomeScreen.kt
@@ -182,7 +182,7 @@ fun HomeFeedContent(navController: NavController, feed: HomeFeedModel, facet: St
}
LazyColumn(
- contentPadding = PaddingValues(bottom = 130.dp),
+ contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.background(Color(AppBackground.toArgb()))
@@ -416,7 +416,11 @@ private fun ProfileSheet(onOpen: (route: String) -> Unit = {}, onDismiss: () ->
modifier = Modifier.fillMaxWidth().then(Modifier.windowInsetsPadding(androidx.compose.foundation.layout.WindowInsets.navigationBars))
.verticalScroll(androidx.compose.foundation.rememberScrollState()).padding(bottom = 16.dp),
) {
- Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp)) {
+ // Name and picture open your public profile, as in Spotify.
+ val myId = com.music.spotui.data.api.ProfileCache.id
+ Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()
+ .clickable(enabled = myId != null) { myId?.let { onOpen(com.music.spotui.ui.navigation.profileRoute(it, name)) } }
+ .padding(horizontal = 20.dp, vertical = 8.dp)) {
if (avatar != null) GlideImage(
model = avatar, contentDescription = null, contentScale = ContentScale.Crop,
modifier = Modifier.size(48.dp).clip(CircleShape),
@@ -426,6 +430,8 @@ private fun ProfileSheet(onOpen: (route: String) -> Unit = {}, onDismiss: () ->
if (com.music.spotui.data.api.SupportReminder.level != com.music.spotui.data.api.SupportReminder.Level.NONE)
com.music.spotui.ui.components.SupporterBadge(Modifier.padding(start = 10.dp))
}
+ if (myId != null) Text(stringResource(R.string.view_profile), color = Color(0xFFB3B3B3), fontSize = 13.sp,
+ modifier = Modifier.padding(start = 82.dp, bottom = 4.dp))
androidx.compose.material3.HorizontalDivider(color = Color(0xFF3E3E3E), modifier = Modifier.padding(vertical = 8.dp))
// Sound quality, downloads, data, battery, display: one page.
androidx.compose.foundation.layout.Column(
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/LibraryExtras.kt b/base/app/src/main/java/com/music/spotui/ui/screens/LibraryExtras.kt
index 5762efd6..84805a07 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/LibraryExtras.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/LibraryExtras.kt
@@ -1,5 +1,9 @@
package com.music.spotui.ui.screens
+import androidx.compose.material.icons.outlined.Folder
+import androidx.compose.material.icons.outlined.Home
+import androidx.compose.material.icons.outlined.DriveFileMove
+import androidx.compose.material.icons.outlined.PushPin
import android.widget.Toast
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
@@ -201,6 +205,7 @@ fun FolderScreen(navController: NavController, uri: String, initialName: String)
var menu by remember { mutableStateOf(false) }
var renaming by remember { mutableStateOf(false) }
var newPlaylist by remember { mutableStateOf(false) }
+ var deletingFolder by remember { mutableStateOf(false) }
var generation by remember { mutableStateOf(0) }
LaunchedEffect(uri, generation) {
withContext(Dispatchers.IO) {
@@ -211,8 +216,21 @@ fun FolderScreen(navController: NavController, uri: String, initialName: String)
Column(Modifier.navigationBarsPadding().padding(bottom = 12.dp)) {
SheetRow(Icons.AutoMirrored.Filled.PlaylistAdd, stringResource(R.string.add_to_playlist_new_playlist_button_text)) { menu = false; newPlaylist = true }
SheetRow(Icons.Outlined.Edit, stringResource(R.string.context_menu_rename_folder)) { menu = false; renaming = true }
+ SheetRow(Icons.Outlined.Delete, stringResource(R.string.folder_delete)) { menu = false; deletingFolder = true }
}
}
+ if (deletingFolder) androidx.compose.material3.AlertDialog(
+ onDismissRequest = { deletingFolder = false },
+ containerColor = SheetColor,
+ text = { Text(stringResource(R.string.folder_delete_confirm, name), color = Color.White) },
+ confirmButton = {
+ androidx.compose.material3.TextButton(onClick = {
+ deletingFolder = false
+ scope.launch { if (LibraryFolders.delete(uri)) navController.navigateUp() }
+ }) { Text(stringResource(R.string.actions_picker_delete), color = Color(0xFFF15E6C)) }
+ },
+ dismissButton = { androidx.compose.material3.TextButton(onClick = { deletingFolder = false }) { Text(stringResource(R.string.cancel), color = Color.White) } },
+ )
// A Spotify playlist created straight inside this folder.
if (newPlaylist) NameDialog(stringResource(R.string.create_playlist_content_description), context.getString(R.string.my_playlist),
stringResource(R.string.create_playlist_create_button), onDismiss = { newPlaylist = false }) { playlistName ->
@@ -237,7 +255,7 @@ fun FolderScreen(navController: NavController, uri: String, initialName: String)
else -> {
com.music.spotui.data.local.LibraryOrder.version
val arranged = com.music.spotui.data.local.LibraryOrder.run { arrange(list, sort, custom(uri), 0) }
- SumUpLibraryScreen(PaddingValues(0.dp), arranged, emptyList(), navController, reorderLevel = uri)
+ SumUpLibraryScreen(PaddingValues(0.dp), arranged, emptyList(), navController, reorderLevel = uri, onChanged = { generation++ })
}
}
}
@@ -304,7 +322,7 @@ fun LocalPlaylistScreen(navController: NavController, id: String) {
navController) { menu = true }
if (playlist.items.isEmpty()) Text(stringResource(R.string.local_playlist_empty), color = Color(0xFFB3B3B3), fontSize = 14.sp,
modifier = Modifier.padding(20.dp))
- else LazyColumn(contentPadding = PaddingValues(bottom = 140.dp), modifier = Modifier.fillMaxSize()) {
+ else LazyColumn(contentPadding = PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()), modifier = Modifier.fillMaxSize()) {
item {
Row(Modifier.fillMaxWidth().padding(16.dp, 4.dp), verticalAlignment = Alignment.CenterVertically) {
Spacer(Modifier.weight(1f))
@@ -395,3 +413,57 @@ private fun PickRow(name: String, detail: String, cover: String?, onClick: () ->
}
}
}
+
+
+/**
+ * A library row's ⋯ menu: pin it at the top, move a playlist or folder into another folder
+ * (or back to the top level), delete a folder. [onChanged] reloads the list.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun LibraryItemSheet(entry: LibraryEntry, onDismiss: () -> Unit, onChanged: () -> Unit) {
+ val context = LocalContext.current
+ val scope = rememberCoroutineScope()
+ var moving by remember { mutableStateOf(false) }
+ var deleting by remember { mutableStateOf(false) }
+ fun act(block: suspend () -> Unit) = scope.launch {
+ val ok = runCatching { block() }.isSuccess
+ if (ok) { LibraryFolders.changed(); onChanged() }
+ else Toast.makeText(context, context.getString(R.string.playlist_change_refused), Toast.LENGTH_SHORT).show()
+ onDismiss()
+ }
+ val api = app.myspoti.host.android.MyspotiRuntime.api
+ ModalBottomSheet(onDismissRequest = onDismiss, containerColor = SheetColor) {
+ Column(Modifier.navigationBarsPadding().padding(bottom = 12.dp)) {
+ Text(entry.name, color = Color.White, fontSize = 18.sp, fontWeight = FontWeight.Bold, maxLines = 1,
+ modifier = Modifier.padding(20.dp, 0.dp, 20.dp, 8.dp))
+ if (!moving) {
+ SheetRow(Icons.Outlined.PushPin, stringResource(if (entry.pinned) R.string.library_unpin else R.string.library_pin)) {
+ act { if (entry.pinned) api.library.unpin(entry.uri) else api.library.pin(entry.uri) }
+ }
+ if (entry.isPlaylist || entry.isFolder) SheetRow(Icons.Outlined.DriveFileMove, stringResource(R.string.library_move_to_folder)) { moving = true }
+ if (entry.isFolder) SheetRow(Icons.Outlined.Delete, stringResource(R.string.folder_delete)) { deleting = true }
+ } else {
+ val folders by androidx.compose.runtime.produceState<List<app.myspoti.api.LibraryItem>?>(null) {
+ value = runCatching { api.library.items(folderUri = null, limit = 200).items.filter { it.kind == app.myspoti.api.MediaKind.FOLDER && it.uri != entry.uri } }
+ .getOrDefault(emptyList())
+ }
+ SheetRow(Icons.Outlined.Home, stringResource(R.string.library_top_level)) { act { api.library.moveToFolder(entry.uri, null) } }
+ folders?.forEach { f ->
+ SheetRow(Icons.Outlined.Folder, f.name) { act { api.library.moveToFolder(entry.uri, f.uri) } }
+ }
+ }
+ }
+ }
+ if (deleting) androidx.compose.material3.AlertDialog(
+ onDismissRequest = { deleting = false },
+ containerColor = SheetColor,
+ text = { Text(stringResource(R.string.folder_delete_confirm, entry.name), color = Color.White) },
+ confirmButton = {
+ androidx.compose.material3.TextButton(onClick = { deleting = false; act { api.library.deleteFolder(entry.uri) } }) {
+ Text(stringResource(R.string.actions_picker_delete), color = Color(0xFFF15E6C))
+ }
+ },
+ dismissButton = { androidx.compose.material3.TextButton(onClick = { deleting = false }) { Text(stringResource(R.string.cancel), color = Color.White) } },
+ )
+}
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 f51ffd78..f02993c4 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
@@ -1,5 +1,7 @@
package com.music.spotui.ui.screens
+import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.PushPin
import com.music.spotui.ui.components.pressable
import androidx.compose.ui.res.stringResource
@@ -311,7 +313,8 @@ fun LibraryScreen(navController: NavController) {
if (gridView) LibraryGridScreen(PaddingValues(0.dp), filteredEntries, filteredArtists, navController,
reorderLevel = if (searchQuery.isBlank()) LibraryOrder.ROOT else null, pinned = rootPinned)
else SumUpLibraryScreen(PaddingValues(0.dp), filteredEntries, filteredArtists, navController,
- reorderLevel = if (searchQuery.isBlank()) LibraryOrder.ROOT else null, pinned = rootPinned)
+ reorderLevel = if (searchQuery.isBlank()) LibraryOrder.ROOT else null, pinned = rootPinned,
+ onChanged = { libraryViewModel.load() })
if (entries !is Response.Success) Box(modifier = Modifier.padding(20.dp, 100.dp)) { Snackbar(showMessage = stringResource(R.string.library_error)) }
}
}
@@ -340,7 +343,11 @@ fun SumUpLibraryScreen(
reorderLevel: String? = null,
/** Entries at the top that never move (Liked Songs, Local Files, Downloaded). */
pinned: Int = 0,
+ /** A pin, move or delete changed the library: load it again. */
+ onChanged: () -> Unit = {},
) {
+ var itemMenu by remember { mutableStateOf<LibraryEntry?>(null) }
+ itemMenu?.let { LibraryItemSheet(it, onDismiss = { itemMenu = null }, onChanged = onChanged) }
if (entries.isEmpty() && followedArtists.isEmpty()) {
Box(modifier = Modifier.padding(20.dp, 40.dp)) { Snackbar(showMessage = stringResource(R.string.library_empty)) }
return
@@ -410,11 +417,11 @@ fun SumUpLibraryScreen(
LazyColumn(
state = listState,
- contentPadding = PaddingValues(top = 10.dp, bottom = 130.dp),
+ contentPadding = PaddingValues(top = 10.dp, bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.padding(padding)
- .background(Color(0xFF0E0E13))
+ .background(com.music.spotui.ui.theme.AppBackground)
) {
itemsIndexed(rows, key = { _, e -> LibraryOrder.key(e) }) { index, entry ->
val key = LibraryOrder.key(entry)
@@ -457,10 +464,16 @@ fun SumUpLibraryScreen(
.size(55.dp)
.clip(RoundedCornerShape(if (entry.isPlaylist) 6.dp else 4.dp)),
)
- Column(modifier = Modifier.padding(start = 12.dp)) {
+ Column(modifier = Modifier.padding(start = 12.dp).weight(1f)) {
Text(text = entry.name, color = Color.White, fontSize = 15.sp, fontWeight = FontWeight.Bold, maxLines = 1, overflow = TextOverflow.Ellipsis)
- Text(text = entry.subtitle, color = Color.Gray, fontSize = 12.sp, fontWeight = FontWeight.Medium, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ if (entry.pinned) Icon(Icons.Default.PushPin, null, tint = com.music.spotui.ui.theme.AppAccent,
+ modifier = Modifier.padding(end = 4.dp).size(12.dp))
+ Text(text = entry.subtitle, color = Color.Gray, fontSize = 12.sp, fontWeight = FontWeight.Medium, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
}
+ if (entry.uri.isNotBlank()) Icon(Icons.Default.MoreVert, stringResource(R.string.content_description_context_menu),
+ tint = Color(0xFFB3B3B3), modifier = Modifier.size(36.dp).clip(CircleShape).clickable { itemMenu = entry }.padding(6.dp))
}
}
// ── Artists the user follows on Spotify ──
@@ -629,8 +642,8 @@ fun LibraryGridScreen(
modifier = Modifier
.fillMaxSize()
.padding(padding)
- .background(Color(0xFF0E0E13)),
- contentPadding = PaddingValues(16.dp, 10.dp, 16.dp, 130.dp),
+ .background(com.music.spotui.ui.theme.AppBackground),
+ contentPadding = PaddingValues(16.dp, 10.dp, 16.dp, com.music.spotui.ui.components.bottomBarsSpace()),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalArrangement = Arrangement.spacedBy(18.dp),
) {
@@ -714,7 +727,7 @@ private fun LibrarySkeleton(padding: PaddingValues) {
modifier = Modifier
.fillMaxSize()
.padding(padding)
- .background(Color(0xFF0E0E13))
+ .background(com.music.spotui.ui.theme.AppBackground)
) {
Spacer(modifier = Modifier.height(10.dp))
repeat(8) {
@@ -772,6 +785,12 @@ private fun AccountSheet(
// Spotify's own account pages (plan, privacy, devices), signed in, in the app.
val context = androidx.compose.ui.platform.LocalContext.current
+ com.music.spotui.data.api.ProfileCache.id?.let { myId ->
+ AccountRow(stringResource(R.string.view_profile)) {
+ onDismiss()
+ navController.navigate(com.music.spotui.ui.navigation.profileRoute(myId, account.name))
+ }
+ }
AccountRow(stringResource(R.string.settings_title)) {
onDismiss()
navController.navigate(com.music.spotui.ui.navigation.Routes.Settings.route)
@@ -801,6 +820,8 @@ private fun AccountRow(label: String, tint: Color = Color.White, onClick: () ->
private fun sortLabel(sort: LibraryOrder.Sort) = when (sort) {
LibraryOrder.Sort.CUSTOM -> R.string.your_library_sort_order_custom
+ LibraryOrder.Sort.RECENTS -> R.string.library_sort_recents
+ LibraryOrder.Sort.RECENTLY_ADDED -> R.string.library_sort_recently_added
LibraryOrder.Sort.ALPHABETICAL -> R.string.your_library_sort_order_alphabetical
LibraryOrder.Sort.CREATOR -> R.string.your_library_sort_order_creator
}
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/LocalFilesScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/LocalFilesScreen.kt
index ade3e3a6..4569168d 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/LocalFilesScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/LocalFilesScreen.kt
@@ -177,7 +177,7 @@ fun LocalFilesScreen(navController: NavController) {
modifier = Modifier.size(24.dp).pressable(0.92f) { adding = t })
}
}
- item { Spacer(Modifier.height(140.dp)) }
+ item { Spacer(Modifier.height(com.music.spotui.ui.components.bottomBarsSpace())) }
}
}
Box(
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 96efcc4a..b1973c14 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
@@ -480,6 +480,30 @@ fun PlayerScreen(navController: NavController) {
onClose = { showLyrics = false }
)
}
+ // Full-screen clip: the video over everything, turned sideways, with its own controls.
+ if (videoOn && mv.fullscreen.value) VideoFullscreen()
+ }
+}
+
+/** The clip filling the screen, landscape while it shows; back or the exit button leaves. */
+@Composable
+private fun VideoFullscreen() {
+ val activity = LocalContext.current as? android.app.Activity
+ androidx.compose.runtime.DisposableEffect(activity) {
+ val before = activity?.requestedOrientation
+ activity?.requestedOrientation = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+ val window = activity?.window
+ val bars = window?.let { androidx.core.view.WindowCompat.getInsetsController(it, it.decorView) }
+ bars?.systemBarsBehavior = androidx.core.view.WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+ bars?.hide(androidx.core.view.WindowInsetsCompat.Type.systemBars())
+ onDispose {
+ bars?.show(androidx.core.view.WindowInsetsCompat.Type.systemBars())
+ activity?.requestedOrientation = before ?: android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+ }
+ }
+ Box(Modifier.fillMaxSize().background(Color.Black), contentAlignment = Alignment.Center) {
+ com.music.spotui.ui.components.VideoSurface(fitHeight = true)
+ com.music.spotui.ui.components.VideoFullscreenOverlay()
}
}
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
new file mode 100644
index 00000000..41770829
--- /dev/null
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/ProfileScreen.kt
@@ -0,0 +1,170 @@
+package com.music.spotui.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+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.height
+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.foundation.shape.RoundedCornerShape
+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.rememberCoroutineScope
+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.pluralStringResource
+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.UserProfile
+import app.myspoti.api.best
+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.playlistRoute
+import com.music.spotui.ui.theme.AppAccent
+import com.music.spotui.ui.theme.AppBackground
+import kotlinx.coroutines.launch
+
+/**
+ * A Spotify user's profile, as the Web Player shows it: picture, name, followers and
+ * following, a Follow button (not on your own profile) and the public playlists.
+ */
+@OptIn(ExperimentalGlideComposeApi::class)
+@Composable
+fun ProfileScreen(navController: NavController, userId: String, userName: String = "") {
+ val uri = "spotify:user:$userId"
+ var profile by remember(userId) { mutableStateOf<UserProfile?>(null) }
+ var failed by remember(userId) { mutableStateOf(false) }
+ var following by remember(userId) { mutableStateOf<Boolean?>(null) }
+ val me = com.music.spotui.data.api.ProfileCache.id == userId
+ val scope = rememberCoroutineScope()
+ LaunchedEffect(userId) {
+ runCatching { MyspotiRuntime.api.users.profile(uri) }
+ .onSuccess { profile = it }.onFailure { failed = true }
+ if (!me) following = runCatching { MyspotiRuntime.api.users.isFollowing(listOf(uri)).single() }.getOrNull()
+ }
+ val p = profile
+ LazyColumn(
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
+ modifier = Modifier.fillMaxSize().background(AppBackground).statusBarsPadding(),
+ ) {
+ item {
+ 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),
+ )
+ }
+ item {
+ Column(horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.fillMaxWidth().padding(16.dp)) {
+ GlideImage(
+ model = p?.images?.best(300)?.url,
+ contentDescription = null,
+ contentScale = ContentScale.Crop,
+ failure = placeholder(R.drawable.placeholder),
+ loading = placeholder(R.drawable.placeholder),
+ modifier = Modifier.size(150.dp).clip(CircleShape),
+ )
+ Spacer(Modifier.height(14.dp))
+ Text(p?.name ?: userName, color = Color.White, fontSize = 28.sp, fontWeight = FontWeight.Bold,
+ maxLines = 2, overflow = TextOverflow.Ellipsis)
+ 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))
+ }
+ val f = following
+ if (!me && f != null) {
+ Spacer(Modifier.height(14.dp))
+ Text(
+ stringResource(if (f) R.string.curation_button_following_state_text else R.string.curation_button_follow_state_text),
+ color = Color.White, fontSize = 14.sp, fontWeight = FontWeight.Bold,
+ modifier = Modifier.clip(RoundedCornerShape(50))
+ .border(1.dp, if (f) Color.White else Color(0xFF878787), RoundedCornerShape(50))
+ .pressable(0.96f) {
+ com.music.spotui.di.Haptics.confirm()
+ following = !f
+ scope.launch {
+ runCatching {
+ if (f) MyspotiRuntime.api.users.unfollow(listOf(uri)) else MyspotiRuntime.api.users.follow(listOf(uri))
+ }.onFailure { following = f }
+ }
+ }
+ .padding(horizontal = 20.dp, vertical = 8.dp),
+ )
+ }
+ }
+ }
+ when {
+ p == null && !failed -> item {
+ Box(Modifier.fillMaxWidth().padding(32.dp), contentAlignment = Alignment.Center) {
+ CircularProgressIndicator(color = AppAccent)
+ }
+ }
+ p == null -> item {
+ Text(stringResource(R.string.home_error), color = Color.White, modifier = Modifier.padding(16.dp))
+ }
+ p.publicPlaylists.isNotEmpty() -> {
+ item {
+ Text(stringResource(R.string.profile_public_playlists), color = Color.White, fontSize = 20.sp,
+ fontWeight = FontWeight.Bold, modifier = Modifier.padding(16.dp, 12.dp))
+ }
+ items(p.publicPlaylists, key = { it.uri }) { pl ->
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.Start,
+ modifier = Modifier.fillMaxWidth()
+ .pressable(0.98f) { navController.navigate(playlistRoute(pl.uri.substringAfterLast(':'), pl.name)) }
+ .padding(16.dp, 8.dp),
+ ) {
+ GlideImage(
+ model = pl.images.best(160)?.url, contentDescription = null, contentScale = ContentScale.Crop,
+ failure = placeholder(R.drawable.placeholder), loading = placeholder(R.drawable.placeholder),
+ modifier = Modifier.size(56.dp).clip(RoundedCornerShape(4.dp)),
+ )
+ Spacer(Modifier.width(12.dp))
+ Column(Modifier.weight(1f)) {
+ Text(pl.name, color = Color.White, fontSize = 15.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ pl.followers?.let {
+ Text(pluralStringResource(R.plurals.profile_followers, it.toInt(), it.toInt()),
+ color = Color(0xFFB3B3B3), fontSize = 13.sp, maxLines = 1)
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/QueueScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/QueueScreen.kt
index 154d7775..4bcbd42f 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/QueueScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/QueueScreen.kt
@@ -79,7 +79,7 @@ fun QueueScreen(navController: NavController) {
Column(
modifier = Modifier
.fillMaxSize()
- .background(Color(0xFF121212))
+ .background(com.music.spotui.ui.theme.AppBackground)
.statusBarsPadding()
) {
Row(
@@ -188,7 +188,7 @@ private fun QueueRow(
modifier = Modifier
.fillMaxWidth()
.graphicsLayer { translationY = dragOffsetY }
- .background(Color(if (isDragging) 0xFF1E1E24 else 0xFF121212))
+ .background(if (isDragging) Color(0xFF1E1E24) else com.music.spotui.ui.theme.AppBackground)
.clickable(
interactionSource = remember { MutableInteractionSource() },
indication = null,
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/SearchScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/SearchScreen.kt
index 18694a38..2b7da9ea 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/SearchScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/SearchScreen.kt
@@ -1,5 +1,6 @@
package com.music.spotui.ui.screens
+import kotlinx.coroutines.launch
import com.music.spotui.ui.components.pressable
import androidx.compose.ui.res.stringResource
@@ -26,6 +27,7 @@ import androidx.compose.foundation.layout.statusBarsPadding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.filled.Search
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Close
import androidx.compose.material3.ExperimentalMaterial3Api
@@ -139,9 +141,23 @@ fun SumUpSearchScreen(
// One relevance-mixed list (songs, artists, albums interleaved) instead of
// separate type sections — matches how most music apps present search.
val mixed = remember(results, filter) { filterSearchResults(results, filter) }
+ // Profiles are searched only when their chip is on (Spotify keeps them out of Top).
+ val profiles by androidx.compose.runtime.produceState(emptyList<app.myspoti.api.MediaCard>(), text, filter) {
+ value = emptyList()
+ if (filter != SearchFilter.Profiles || text.isBlank()) return@produceState
+ kotlinx.coroutines.delay(250)
+ value = runCatching { app.myspoti.host.android.MyspotiRuntime.api.search.users(text.trim(), limit = 30).items }.getOrDefault(emptyList())
+ }
+ val suggestions by androidx.compose.runtime.produceState(emptyList<String>(), text) {
+ value = emptyList()
+ if (text.isBlank()) return@produceState
+ kotlinx.coroutines.delay(300)
+ value = runCatching { app.myspoti.host.android.MyspotiRuntime.api.search.suggestions(text.trim(), 6) }.getOrDefault(emptyList())
+ .filter { !it.equals(text.trim(), ignoreCase = true) }
+ }
LazyColumn(
- contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = 130.dp),
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.background(Color(AppBackground.toArgb()))
@@ -187,6 +203,8 @@ fun SumUpSearchScreen(
modifier = Modifier.pressable(0.96f) {
com.music.spotui.data.preferences.clearRecentItems(context)
recents = emptyList()
+ // Spotify's own list too, so other devices forget them as well.
+ clearSpotifyRecents()
},
)
}
@@ -245,7 +263,37 @@ fun SumUpSearchScreen(
}
}
} else {
+ // Spotify's completions for what is typed: one tap searches it.
+ if (suggestions.isNotEmpty()) item {
+ androidx.compose.foundation.lazy.LazyRow(
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(horizontal = 16.dp),
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
+ modifier = Modifier.padding(top = 8.dp),
+ ) {
+ items(suggestions.size) { i ->
+ val q = suggestions[i]
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.clip(RoundedCornerShape(50)).background(Color(0xFF2A2A2A))
+ .pressable(0.96f) { text = q; searchViewModel.search(q) }
+ .padding(horizontal = 12.dp, vertical = 7.dp),
+ ) {
+ Icon(androidx.compose.material.icons.Icons.Default.Search, null, tint = Color(0xFFB3B3B3), modifier = Modifier.size(14.dp))
+ Spacer(Modifier.width(6.dp))
+ Text(q, color = Color.White, fontSize = 13.sp, maxLines = 1)
+ }
+ }
+ }
+ }
item { SearchFilterChips(filter) { filter = it } }
+ if (filter == SearchFilter.Profiles) {
+ items(profiles.size) { i ->
+ val u = profiles[i]
+ SearchProfileRow(u.title, u.images.firstOrNull()?.url) {
+ navController.navigate(com.music.spotui.ui.navigation.profileRoute(u.uri.substringAfterLast(':'), u.title))
+ }
+ }
+ }
items(mixed.size) { i ->
when (val row = mixed[i]) {
is SearchRow.Song -> com.music.spotui.ui.components.SwipeToQueue(row.song) {
@@ -333,6 +381,7 @@ enum class SearchFilter(@androidx.annotation.StringRes val label: Int) {
Albums(R.string.assisted_curation_search_filter_albums),
Playlists(R.string.assisted_curation_search_filter_playlists),
Podcasts(R.string.assisted_curation_search_filter_podcasts),
+ Profiles(R.string.search_filter_profiles),
}
private fun filterSearchResults(results: SearchResults, filter: SearchFilter): List<SearchRow> = when (filter) {
@@ -341,7 +390,7 @@ private fun filterSearchResults(results: SearchResults, filter: SearchFilter): L
SearchFilter.Artists -> results.artists.map { SearchRow.Artist(it) }
SearchFilter.Albums -> results.albums.map { SearchRow.Album(it) }
SearchFilter.Playlists -> results.playlists.map { SearchRow.Playlist(it) }
- SearchFilter.Podcasts -> emptyList()
+ SearchFilter.Podcasts, SearchFilter.Profiles -> emptyList()
}
@Composable
@@ -802,3 +851,31 @@ fun SearchStickyBar(
)
}
}
+
+
+/** A user found by the Profiles chip: round picture, name, "Profile". */
+@OptIn(ExperimentalGlideComposeApi::class)
+@Composable
+private fun SearchProfileRow(name: String, image: String?, onClick: () -> Unit) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.fillMaxWidth().pressable(0.98f, onClick = onClick).padding(16.dp, 8.dp),
+ ) {
+ com.bumptech.glide.integration.compose.GlideImage(
+ model = image, contentDescription = null, contentScale = androidx.compose.ui.layout.ContentScale.Crop,
+ failure = com.bumptech.glide.integration.compose.placeholder(R.drawable.placeholder),
+ modifier = Modifier.size(52.dp).clip(androidx.compose.foundation.shape.CircleShape),
+ )
+ Spacer(Modifier.width(12.dp))
+ Column {
+ Text(name, color = Color.White, fontSize = 15.sp, maxLines = 1)
+ Text(stringResource(R.string.recently_played_user_profile), color = Color(0xFFB3B3B3), fontSize = 13.sp)
+ }
+ }
+}
+
+/** Spotify's own recent searches, cleared with the app's list. */
+private fun clearSpotifyRecents() {
+ val runtime = app.myspoti.host.android.MyspotiRuntime
+ runtime.scope.launch { runCatching { runtime.api.search.clearRecent() } }
+}
diff --git a/base/app/src/main/java/com/music/spotui/ui/screens/ShowScreen.kt b/base/app/src/main/java/com/music/spotui/ui/screens/ShowScreen.kt
index d7a17822..9fc21a15 100644
--- a/base/app/src/main/java/com/music/spotui/ui/screens/ShowScreen.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/screens/ShowScreen.kt
@@ -78,7 +78,7 @@ fun ShowScreen(navController: NavController, showId: String, showName: String =
}
LazyColumn(
- contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = 130.dp),
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(bottom = com.music.spotui.ui.components.bottomBarsSpace()),
modifier = Modifier
.fillMaxSize()
.background(Color(AppBackground.toArgb()))
@@ -164,6 +164,5 @@ fun ShowScreen(navController: NavController, showId: String, showName: String =
}
}
}
- item { Spacer(Modifier.height(130.dp)) }
}
}
diff --git a/base/app/src/main/java/com/music/spotui/ui/theme/Theme.kt b/base/app/src/main/java/com/music/spotui/ui/theme/Theme.kt
index 0ccc656b..a3541932 100644
--- a/base/app/src/main/java/com/music/spotui/ui/theme/Theme.kt
+++ b/base/app/src/main/java/com/music/spotui/ui/theme/Theme.kt
@@ -55,17 +55,13 @@ fun SpotuiTheme(
androidx.compose.runtime.LaunchedEffect(policy.videoMaxHeight, policy.allowBackgroundLookups) {
com.music.spotui.video.MusicVideoController.onEnergyPolicyChanged()
}
+ // The app is always dark, like Spotify: a phone in light mode must not turn the
+ // surfaces white (an empty or failed page then showed white text on white).
val colorScheme = when {
- dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
- val context = LocalContext.current
- if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
- }
-
- darkTheme -> DarkColorScheme
- else -> LightColorScheme
+ dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> dynamicDarkColorScheme(LocalContext.current)
+ else -> DarkColorScheme
}
- val visualScheme = colorScheme.copy(background = AppBackground,
- surface = if (policy.oledBlack) Color.Black else colorScheme.surface)
+ val visualScheme = colorScheme.copy(background = AppBackground, surface = AppBackground)
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
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 1dcff3bf..85121c04 100644
--- a/base/app/src/main/res/values-fr/myspoti_strings.xml
+++ b/base/app/src/main/res/values-fr/myspoti_strings.xml
@@ -256,4 +256,46 @@
<string name="update_failed">La mise à jour a échoué : %1$s</string>
<string name="update_retry">Réessayer</string>
<string name="downloads_verify_banner">Les téléchargements demandent la vérification SpotiFLAC une fois dans cette app. Touchez ici pour la faire.</string>
+ <string name="removed_from">Retiré de %1$s</string>
+ <string name="done">OK</string>
+ <string name="playlist_edit_details">Modifier les infos</string>
+ <string name="playlist_name_label">Nom</string>
+ <string name="playlist_description_label">Description</string>
+ <string name="playlist_change_cover">Changer la pochette</string>
+ <string name="playlist_remove_cover">Retirer la pochette</string>
+ <string name="playlist_save">Enregistrer</string>
+ <string name="playlist_access_title">Qui peut la voir</string>
+ <string name="playlist_access_public">Publique</string>
+ <string name="playlist_access_public_detail">Tout le monde peut la trouver et l\'écouter</string>
+ <string name="playlist_access_private">Privée</string>
+ <string name="playlist_access_private_detail">Vous seul pouvez la voir</string>
+ <string name="playlist_access_collaborative">Collaborative</string>
+ <string name="playlist_access_collaborative_detail">Toute personne avec le lien peut ajouter et retirer des titres</string>
+ <string name="playlist_delete_confirm">Supprimer « %1$s » ? Elle peut être restaurée depuis votre compte Spotify pendant 90 jours.</string>
+ <string name="playlist_saved">Playlist mise à jour</string>
+ <string name="go_to_profile">Voir le profil</string>
+ <string name="cancel">Annuler</string>
+ <plurals name="profile_followers">
+ <item quantity="one">%1$d abonné</item>
+ <item quantity="other">%1$d abonnés</item>
+ </plurals>
+ <string name="profile_following_count">%1$d abonnements</string>
+ <string name="profile_public_playlists">Playlists publiques</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>
+ <string name="artist_unbanned">%1$s peut de nouveau être joué</string>
+ <string name="episode_save">Ajouter à Vos épisodes</string>
+ <string name="episode_unsave">Retirer de Vos épisodes</string>
+ <string name="search_filter_profiles">Profils</string>
+ <string name="view_profile">Voir le profil</string>
+ <string name="folder_delete">Supprimer le dossier</string>
+ <string name="folder_delete_confirm">Supprimer le dossier « %1$s » ? Ses playlists restent dans votre bibliothèque.</string>
+ <string name="library_pin">Épingler</string>
+ <string name="library_unpin">Désépingler</string>
+ <string name="library_move_to_folder">Déplacer dans un dossier</string>
+ <string name="library_top_level">Votre bibliothèque (premier niveau)</string>
+ <string name="more_like_this">Dans le même style</string>
+ <string name="library_sort_recents">Récents</string>
+ <string name="library_sort_recently_added">Ajoutés récemment</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 9c77a35b..db3c739a 100644
--- a/base/app/src/main/res/values-it/myspoti_strings.xml
+++ b/base/app/src/main/res/values-it/myspoti_strings.xml
@@ -256,4 +256,46 @@
<string name="update_failed">Aggiornamento non riuscito: %1$s</string>
<string name="update_retry">Riprova</string>
<string name="downloads_verify_banner">I download richiedono la verifica SpotiFLAC una volta in questa app. Tocca qui per farla.</string>
+ <string name="removed_from">Rimosso da %1$s</string>
+ <string name="done">Fine</string>
+ <string name="playlist_edit_details">Modifica dettagli</string>
+ <string name="playlist_name_label">Nome</string>
+ <string name="playlist_description_label">Descrizione</string>
+ <string name="playlist_change_cover">Cambia copertina</string>
+ <string name="playlist_remove_cover">Rimuovi copertina</string>
+ <string name="playlist_save">Salva</string>
+ <string name="playlist_access_title">Chi può vederla</string>
+ <string name="playlist_access_public">Pubblica</string>
+ <string name="playlist_access_public_detail">Chiunque può trovarla e ascoltarla</string>
+ <string name="playlist_access_private">Privata</string>
+ <string name="playlist_access_private_detail">Solo tu puoi vederla</string>
+ <string name="playlist_access_collaborative">Collaborativa</string>
+ <string name="playlist_access_collaborative_detail">Chiunque abbia il link può aggiungere e rimuovere brani</string>
+ <string name="playlist_delete_confirm">Eliminare «%1$s»? Si può ripristinare dal tuo account Spotify per 90 giorni.</string>
+ <string name="playlist_saved">Playlist aggiornata</string>
+ <string name="go_to_profile">Vai al profilo</string>
+ <string name="cancel">Annulla</string>
+ <plurals name="profile_followers">
+ <item quantity="one">%1$d follower</item>
+ <item quantity="other">%1$d follower</item>
+ </plurals>
+ <string name="profile_following_count">%1$d seguiti</string>
+ <string name="profile_public_playlists">Playlist pubbliche</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>
+ <string name="artist_unbanned">%1$s può essere di nuovo riprodotto</string>
+ <string name="episode_save">Aggiungi ai tuoi episodi</string>
+ <string name="episode_unsave">Rimuovi dai tuoi episodi</string>
+ <string name="search_filter_profiles">Profili</string>
+ <string name="view_profile">Vedi profilo</string>
+ <string name="folder_delete">Elimina cartella</string>
+ <string name="folder_delete_confirm">Eliminare la cartella «%1$s»? Le sue playlist restano nella tua libreria.</string>
+ <string name="library_pin">Fissa</string>
+ <string name="library_unpin">Rimuovi dai fissati</string>
+ <string name="library_move_to_folder">Sposta in una cartella</string>
+ <string name="library_top_level">La tua libreria (livello principale)</string>
+ <string name="more_like_this">Simili</string>
+ <string name="library_sort_recents">Recenti</string>
+ <string name="library_sort_recently_added">Aggiunti di recente</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 89fa9c0a..f1a67ffc 100644
--- a/base/app/src/main/res/values/myspoti_strings.xml
+++ b/base/app/src/main/res/values/myspoti_strings.xml
@@ -256,4 +256,46 @@
<string name="update_failed">The update failed: %1$s</string>
<string name="update_retry">Try again</string>
<string name="downloads_verify_banner">Downloads need the SpotiFLAC verification once on this app. Tap here to do it.</string>
+ <string name="removed_from">Removed from %1$s</string>
+ <string name="done">Done</string>
+ <string name="playlist_edit_details">Edit details</string>
+ <string name="playlist_name_label">Name</string>
+ <string name="playlist_description_label">Description</string>
+ <string name="playlist_change_cover">Change cover</string>
+ <string name="playlist_remove_cover">Remove cover</string>
+ <string name="playlist_save">Save</string>
+ <string name="playlist_access_title">Who can see it</string>
+ <string name="playlist_access_public">Public</string>
+ <string name="playlist_access_public_detail">Anyone can find and play it</string>
+ <string name="playlist_access_private">Private</string>
+ <string name="playlist_access_private_detail">Only you can see it</string>
+ <string name="playlist_access_collaborative">Collaborative</string>
+ <string name="playlist_access_collaborative_detail">Anyone with the link can add and remove songs</string>
+ <string name="playlist_delete_confirm">Delete "%1$s"? It can be restored from your Spotify account for 90 days.</string>
+ <string name="playlist_saved">Playlist updated</string>
+ <string name="go_to_profile">Go to profile</string>
+ <string name="cancel">Cancel</string>
+ <plurals name="profile_followers">
+ <item quantity="one">%1$d follower</item>
+ <item quantity="other">%1$d followers</item>
+ </plurals>
+ <string name="profile_following_count">%1$d following</string>
+ <string name="profile_public_playlists">Public playlists</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>
+ <string name="artist_unbanned">%1$s can play again</string>
+ <string name="episode_save">Add to Your Episodes</string>
+ <string name="episode_unsave">Remove from Your Episodes</string>
+ <string name="search_filter_profiles">Profiles</string>
+ <string name="view_profile">View profile</string>
+ <string name="folder_delete">Delete folder</string>
+ <string name="folder_delete_confirm">Delete the folder "%1$s"? Its playlists stay in your library.</string>
+ <string name="library_pin">Pin</string>
+ <string name="library_unpin">Unpin</string>
+ <string name="library_move_to_folder">Move to folder</string>
+ <string name="library_top_level">Your Library (top level)</string>
+ <string name="more_like_this">More like this</string>
+ <string name="library_sort_recents">Recents</string>
+ <string name="library_sort_recently_added">Recently added</string>
</resources>
diff --git a/base/host-cdp/src/test/kotlin/app/myspoti/host/cdp/LiveFeaturesTest.kt b/base/host-cdp/src/test/kotlin/app/myspoti/host/cdp/LiveFeaturesTest.kt
new file mode 100644
index 00000000..eac4e1e3
--- /dev/null
+++ b/base/host-cdp/src/test/kotlin/app/myspoti/host/cdp/LiveFeaturesTest.kt
@@ -0,0 +1,117 @@
+package app.myspoti.host.cdp
+
+import app.myspoti.api.HomeFilter
+import app.myspoti.spotify.SpotifyApi
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty
+
+/**
+ * The features the app's screens use beyond playback (profiles, recents, podcasts home,
+ * artist ban, playlist visibility), against a signed-in Web Player. Writes are undone.
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@EnabledIfSystemProperty(named = "myspoti.cdp", matches = ".+")
+class LiveFeaturesTest {
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+ private lateinit var host: CdpHost
+ private lateinit var api: SpotifyApi
+
+ private fun live(block: suspend () -> Any?) { runBlocking { withTimeout(120_000) { block() } } }
+
+ @BeforeAll
+ fun connect() = live {
+ host = CdpHost.connect(System.getProperty("myspoti.cdp"))
+ api = SpotifyApi(host, scope, language = "fr")
+ host.reload()
+ host.awaitLoad()
+ api.onPageLoaded()
+ api.awaitReady()
+ }
+
+ @AfterAll
+ fun close() { scope.cancel() }
+
+ @Test fun podcastsHome() = live {
+ val feed = api.home.feed(HomeFilter.PODCASTS, itemsPerShelf = 10)
+ println("PODCASTS shelves=${feed.shelves.size} kinds=${feed.shelves.flatMap { it.items }.groupingBy { it.kind }.eachCount()}")
+ feed.shelves.take(5).forEach { println(" ${it.title}: ${it.items.take(3).map { c -> c.kind.name + ":" + c.title }}") }
+ assertTrue(feed.shelves.isNotEmpty())
+ }
+
+ @Test fun profilesAndRecents() = live {
+ val me = api.users.me()
+ println("me=${me.uri}")
+ val p = api.users.profile(me.uri)
+ println("profile ${p.name} followers=${p.followers} following=${p.following} playlists=${p.publicPlaylists.size}")
+ val found = api.search.users("spotify", limit = 5)
+ println("users: ${found.items.map { it.title + " " + it.uri }}")
+ val follows = api.users.isFollowing(found.items.take(2).map { it.uri })
+ println("isFollowing=$follows")
+ val h = api.users.history()
+ println("history ${h.size}: ${h.take(5).map { it.kind.name + ":" + it.name }}")
+ }
+
+ @Test fun artistBanRoundTrip() = live {
+ val artist = "spotify:artist:0TnOYISbd1XYRBk9myaseg" // Pitbull
+ val before = api.extras.isArtistBanned(listOf(artist)).single()
+ api.extras.setArtistBanned(artist, !before)
+ val flipped = api.extras.isArtistBanned(listOf(artist)).single()
+ api.extras.setArtistBanned(artist, before)
+ val back = api.extras.isArtistBanned(listOf(artist)).single()
+ println("artistban before=$before flipped=$flipped back=$back")
+ assertEquals(!before, flipped)
+ assertEquals(before, back)
+ }
+
+ @Test fun playlistAccessAndCover() = live {
+ val uri = api.playlists.create("Myspoti test ${System.currentTimeMillis() % 100000}")
+ try {
+ api.playlists.setAccess(uri, app.myspoti.api.PlaylistAccess.PRIVATE)
+ assertEquals(app.myspoti.api.PlaylistAccess.PRIVATE, api.playlists.access(uri))
+ api.playlists.setAccess(uri, app.myspoti.api.PlaylistAccess.COLLABORATIVE)
+ assertEquals(app.myspoti.api.PlaylistAccess.COLLABORATIVE, api.playlists.access(uri))
+ api.playlists.setAccess(uri, app.myspoti.api.PlaylistAccess.PUBLIC)
+ val img = java.awt.image.BufferedImage(300, 300, java.awt.image.BufferedImage.TYPE_INT_RGB)
+ img.createGraphics().apply { color = java.awt.Color(29, 185, 84); fillRect(0, 0, 300, 300) }
+ val jpeg = java.io.ByteArrayOutputStream().also { javax.imageio.ImageIO.write(img, "jpg", it) }.toByteArray()
+ api.playlists.setCover(uri, jpeg)
+ kotlinx.coroutines.delay(3000)
+ println("cover images=${api.playlists.playlist(uri).images.size}")
+ api.playlists.setDescription(uri, "test")
+ } finally {
+ api.playlists.delete(uri)
+ }
+ }
+
+ @Test fun suggestionsAndSimilar() = live {
+ println("suggestions=${api.search.suggestions("dua", 5)}")
+ val t = api.search.tracks("Levitating", limit = 1).items.first()
+ val sim = api.catalog.similarAlbums(t.uri)
+ println("similar to ${t.name}: ${sim.take(3).map { it.name }}")
+ }
+
+ @Test fun episodeSaveRoundTrip() = live {
+ val ep = api.search.episodes("asmr", limit = 1).items.first().uri
+ val before = api.library.contains(listOf(ep)).single()
+ api.podcasts.setEpisodeSaved(ep, !before)
+ kotlinx.coroutines.delay(1500)
+ val flipped = api.library.contains(listOf(ep)).single()
+ api.podcasts.setEpisodeSaved(ep, before)
+ kotlinx.coroutines.delay(1500)
+ val back = api.library.contains(listOf(ep)).single()
+ println("episode saved before=$before flipped=$flipped back=$back")
+ assertEquals(!before, flipped)
+ assertEquals(before, back)
+ }
+}
diff --git a/docs/CHANGELOG-full.md b/docs/CHANGELOG-full.md
index 8b919f5f..eca86d9e 100644
--- a/docs/CHANGELOG-full.md
+++ b/docs/CHANGELOG-full.md
@@ -16,7 +16,21 @@ Every change, release by release. The short version is in [CHANGELOG.md](../CHAN
- **Shuffle-play without a list** queues the shuffled songs (up to 50).
- **Music videos** are only looked up when the video is on or the player is showing.
- **Links** open once (not again on rotation) and www./play.spotify.com links work.
-- **API**: "Don't play this artist", public / collaborative playlists, sorted playlist rows (ascending or descending), save episodes — ready for the screens.
+- **Playlist menu** (⋯ on a playlist page): edit details (name, description, cover picked from the phone, square JPEG under 256 KB, or removed), who can see it (public, private, collaborative: the Web Player's base permission), delete with confirmation; on someone else's playlist, their profile.
+- **Profiles**: a Profiles chip in search, a profile page (picture, followers, following, public playlists, Follow / Following), the owner line of a playlist opens it, "View profile" in the account menus.
+- **Song menu**: "Don't play this artist" (Spotify's artist ban) and, for episodes, add to or remove from Your Episodes.
+- **Search**: Spotify's suggestions while typing; clearing recent searches clears Spotify's list too.
+- **Albums**: "More like this" under the tracks.
+- **Your Library**: a ⋯ on each row to pin or unpin, move a playlist or folder into a folder (or back to the top), delete a folder; sorts by Recents and Recently added; items pinned on Spotify stay on top.
+- **Playlist sort**: ascending or descending (pick the chosen sort again), remembered per playlist across restarts (#16).
+- **AMOLED**: song rows, the library and several pages used fixed greys; they follow the theme.
+- **Bottom of lists**: the last rows scroll above the mini player, the tabs and the system navigation bar.
+- **Full-screen music video**: it was never drawn; it now fills the screen in landscape with its controls.
+- **Spotify account page**: kept out from under the status and navigation bars.
+- **"Saved in"**: a message after each add or removal, and a Done button.
+- **Skipping fast**: taps on next in a row become one jump in the queue instead of a burst of commands.
+- **Light-mode phones**: the app stays dark, so an empty or failed page (like Podcasts, #36) no longer shows white.
+- **API**: playlist access (base permission) and cover upload, checked live; "Hide song" is not available in the Web Player (it reports it cannot ban), so it is not offered.
## 2.0.0