From 357c521b52d3368897e3a7b20c8db5fa4d1d1ca4 Mon Sep 17 00:00:00 2001 From: maxrave-dev Date: Thu, 12 Nov 2026 16:34:12 +0700 Subject: [PATCH 1/2] feat(sync): add library sync between phone and desktop --- CLAUDE.md | 15 +- .../com/maxrave/simpmusic/MainActivity.kt | 16 + .../maxrave/simpmusic/SimpMusicApplication.kt | 8 + .../service/sync/LibrarySyncScheduler.kt | 54 +++ .../service/sync/LibrarySyncWorker.kt | 22 + .../expect/ui/LibrarySync.android.kt | 390 ++++++++++++++++++ .../simpmusic/expect/ui/LoginSync.android.kt | 27 +- .../composeResources/values/strings.xml | 54 +++ .../maxrave/simpmusic/di/ViewModelModule.kt | 7 +- .../simpmusic/expect/ui/LibrarySync.kt | 108 +++++ .../simpmusic/ui/screen/home/SettingScreen.kt | 63 ++- .../viewModel/LibrarySyncViewModels.kt | 197 +++++++++ .../viewModel/LoginSyncSenderViewModel.kt | 54 ++- .../simpmusic/viewModel/SettingsViewModel.kt | 22 +- .../com/maxrave/simpmusic/DesktopApp.kt | 10 + .../simpmusic/expect/ui/LibrarySync.jvm.kt | 278 +++++++++++++ .../simpmusic/expect/ui/LoginSync.jvm.kt | 2 +- core | 2 +- 18 files changed, 1307 insertions(+), 22 deletions(-) create mode 100644 androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncScheduler.kt create mode 100644 androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncWorker.kt create mode 100644 composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.android.kt create mode 100644 composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.kt create mode 100644 composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LibrarySyncViewModels.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt diff --git a/CLAUDE.md b/CLAUDE.md index 9173d68d15..01d11a8021 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -110,7 +110,7 @@ Service modules: - **autoEqService/**: AutoEq headphone correction profiles (index + fixed-band curves) - **lyricsService/**: Lyrics fetching (LRCLIB, SimpMusic Lyrics, BetterLyrics) - **listenTogether/**: shared listening rooms, wire-compatible with Metrolist (`MetrolistGroup/metroproto`) -- **loginSync/**: the QR-paired transport that moves sign-ins from the Android app to the Desktop app (Ktor client on the phone, one-shot Ktor CIO server on the Desktop, AES-256-GCM). Android + JVM targets only; carries opaque bytes — the data layer decides what they mean +- **loginSync/**: the QR-paired transport that moves sign-ins from the Android app to the Desktop app (Ktor client on the phone, one-shot Ktor CIO server on the Desktop, AES-256-GCM). Android + JVM targets only; carries opaque bytes — the data layer decides what they mean. Also carries library sync's long-lived paired channel (`PairedSyncWire`/`PairedSyncClient`/`PairedSyncServer`, fixed port 48517) - **kizzy/**: Discord Rich Presence for FOSS builds (the user's own token, from a WebView login on Android or pasted on Desktop). Left untouched by the OAuth work below - **discord/**: Discord Rich Presence over OAuth for Full builds (package `org.simpmusic.discord`): PKCE login, a Ktor gateway client that identifies with a Bearer token, and the presence itself. Used instead of kizzy whenever the build carries a Discord application id - **ktorExt/**: Ktor extensions for networking @@ -1162,6 +1162,17 @@ if (getPlatform() == Platform.Android) { - **Linux slice rebuilt with `aeval` (2026-11-11).** `aeval` joined the FFmpeg `--enable-filter` list in `scripts/mpv-linux/Dockerfile`; the slice was rebuilt natively on ubuntu-work (38 libs, every object x86-64 ET_DYN, no glib, every other filter unchanged), republished on `abc` and pinned in `mpvNativesChecksums` (`f2f56dc6…45b0`, 16,035,411 B; the public URL served it at once). Checked by playing a left-only tone through that libmpv with `ao=pcm` and the app's 8D tier written by `af set`: the tone moved between the ears at the chosen period, while the previous slice answered `af set` with -12 and stayed left-only. The staged macOS (arm64, x64) and Windows (arm64, x64) slices carry `aeval` already. - Tests: `EightDEffectTest` (domain commonTest), `EightDKernelTest` (media3), `EightDGraphsTest` (media-jvm, which gained `testImplementation(libs.junit)`). Written, not run; nothing was built or listened to. aeval parses its expression only when the output is configured, so `EightDGraphsTest` cannot catch a broken one: the graph string was run through ffmpeg 8.0.1 and through the rebuilt libmpv instead (the measurements above; `1.0E-4` phases parse). The kernel's expected numbers were checked against a line-for-line Python port first: ILD 0.41 dB at 200 Hz, 16.3 dB at 8 kHz, 17.8 dB at 12 kHz with the source at the right ear, far ear 30-31 samples late at 48 kHz, 0.5/0.5 on both ears for a left-only DC input at every azimuth. +- **Library sync between a phone and its paired computer (2026-11-12, issue #2663, branch `feat/data_sync`, NOT BUILT OR TESTED YET)**: the Desktop app is the server and keeps the log; the Android app drives every round — on app open (at most every 5 min, `MainActivity.syncLibraryIfDue`), every 15 min through WorkManager (`androidApp/.../service/sync/`, scheduled only while paired) and on "Sync now". Not realtime, never touches the queue or the player. Synced: liked songs, followed artists, hearted albums / YouTube playlists / podcasts, local playlists (title, cover, songs, order) and listening history (a phone gets the year before it was paired and everything after, on every batch). Not synced: queue, recents, caches, downloads, Smart downloads, device-bound settings and secrets. Downloads stay each device's own: Smart downloads scores only the plays made on that device (`getSongPlaysSince` reads `deviceId IS NULL`), and a like arriving by sync never triggers "download songs you like", which runs only on the like action itself. A device with local tracking off neither sends nor takes plays (the computer then relays none either). UI: Settings → Devices → **Library sync** opens `LibrarySyncDialog` (`expect/ui/LibrarySync*.kt`, state in `LibrarySyncHostViewModel` / `LibrarySyncPhoneViewModel`). Desktop: QR with the address picker, then the paired phones with per-phone sync time and Remove; Windows Public and port-in-use warnings. Android: scan → "Pair with this computer?" → status with Sync now / Unpair. The settings prompt names each differing key (`PendingSettings.keys`, labelled from the key name, English only). Paired, "Send sign-ins to desktop" skips the QR and goes over the paired channel; the computer asks with `LibrarySyncLoginPrompt`, drawn over the whole Desktop window. "Apply & restart" exits on Desktop (as a restored backup does) and relaunches on Android. + - **Layers**: transport in `core/service/loginSync` (above); domain `LibrarySyncRepository` + `LibrarySyncHostRepository` (Desktop) / `LibrarySyncPhoneRepository` (Android) and `model/librarysync`; data `librarysync/` — `SyncChangeRecorder` (write hooks in `LocalDataSource`/`AnalyticsDatasource`), `SyncEngine` (one round, both ends), `SyncApplier`, `SyncSnapshot`, `SyncedSettings`, `SyncPrefs`, platform repos in `jvmMain`/`androidMain`, bound in `Loader.*.kt`. iOS binds nothing. + - **Database v28** (AutoMigration from 25/26/27): new `sync_change` table; `syncId` (unique, nullable) on `local_playlist` and `playback_event`; `deviceId` on `playback_event` (null = played on this device). "Recently played" reads `deviceId IS NULL` only, so another device's plays never show up there. `27.json` was overwritten once by an IDE build mid-edit and restored from git: **the `from` schema of an AutoMigration must stay the shipped one**. + - **`sync_change` is two things.** On the phone it is the outbox (`serverSeq` null = not taken yet), so changes made while the computer is away go out later. On the computer it is the log phones pull from by `serverSeq`, keeping only the newest row per (entity, key) except history. It exists because an unlike writes `favoriteAt` back to null, so without it the moment of an "off" is lost and two devices cannot tell which came last. + - **Merge**: last change wins (`supersedes`: `changedAt`, then "on" beats "off", then `changeId`), compared against the log on the computer and against the phone's own pending rows on the phone, one change at a time right before it is applied. The computer logs a change only once it holds there (`SyncApplier.applyOne` returns whether it did), and when a phone's change loses it sends the winning row back. A playlist's name, cover and order are read when sent, not when changed. Writes made while applying run under the `SyncApplying` context element so the hooks do not record them again. Referenced rows (songs, albums, artists…) travel along and are inserted IGNORE with `inLibrary = 2000-01-01`, so they never surface as "recently added". + - **Local playlists are the hard part** (found by an independent review on 2026-11-12). A rename logs a new playlist row at the end of the log while its songs keep their old places, so a phone pulling from scratch can get the songs several batches before the playlist: every song and order row therefore carries the playlist's `meta`, and the receiver creates the playlist from it unless it deleted it later itself. A deletion loses to a later edit; the side that keeps the playlist then sends it again whole (`SyncSnapshot.playlistChanges`) instead of logging the deletion, since other phones would otherwise delete it too. When the computer brings back a playlist it had deleted from an edit alone, it asks that phone to send it again whole (`SyncResponse.resend`). + - **The YouTube link travels too** (owner's call, 2026-11-12): `PlaylistMeta.youtubePlaylistId`, and each song row of a linked playlist carries its `setVideoId` (the YouTube entry id `LocalPlaylistRepositoryImpl.findSetVideoId` needs to remove a song there). Only the device where the user made an edit pushes it to YouTube; applying a synced edit never does. Linking (`updateLocalPlaylistYouTubePlaylistId`) sends the playlist whole so every song carries its entry id, and an entry id stored after its song (`insertSetVideoId`) sends that song again. **A playlist imported from the same YouTube playlist on both devices is one playlist**: the side that receives a syncId it lacks, while holding a playlist with that link, gives its own the incoming syncId, drops what it recorded under the old one and sends it again whole. Both sides adopt what they receive, so they agree whichever row arrives first. + - **Sign-ins sent over the paired channel wait for the computer's user** (`LibrarySyncHostRepository.pendingLogins` / `answerLogins`): holding the paired key is not enough, so a lost phone cannot switch the computer's accounts. The phone's request waits up to 100 s for the answer (its client gives up at 120 s) and gets back only what was accepted; one prompt at a time. + - **Identity is the key, not the IP.** Pairing hands the phone a long-lived key under the QR's one-time key; every later knock carries a nonce the computer must echo with its id, and every sync reply echoes the request's nonce. A 403 alone never unpairs a phone: only the computer's own sealed "removed" knock reply does, and the computer keeps answering it for the 30 days a removed phone is remembered. The server refuses a body with no Content-Length before reading it. The phone looks for the computer at the address picked when pairing (LAN, Tailscale, anything listed), then every address it last reported, then a sealed UDP probe (multicast 239.255.48.17 + broadcast), then a sweep of its /24. + - **Deletion never propagates by accident.** Clearing listening history unpairs first (Desktop: every phone), and so does restoring a backup. A removed phone is told under its own key the next time it knocks. Settings travel every round but are applied only after the user agrees (allowlist in `SyncedSettings.KEYS`). A database copy is taken before the first merge of a pairing and before a merge that removes something, at most one an hour, three kept (`~/.simpmusic/sync-backups`, `filesDir/sync-backups`). Pairing state lives in its own `library_sync.preferences_pb`, outside the settings file, so a backup cannot carry a pairing key to another device. + ## 🔄 CLAUDE.md Auto-Update Rule (MANDATORY) After completing any of the following types of changes, the AI agent **MUST** update this CLAUDE.md file: @@ -1186,6 +1197,6 @@ After completing any of the following types of changes, the AI agent **MUST** up *This document helps AI Agents quickly understand the SimpMusic project. Update regularly when there are major changes to architecture or structure.* -**Last updated**: 2026-11-11 +**Last updated**: 2026-11-12 **Project version**: Check latest release on GitHub **Maintained by**: maxrave-dev and contributors diff --git a/androidApp/src/main/java/com/maxrave/simpmusic/MainActivity.kt b/androidApp/src/main/java/com/maxrave/simpmusic/MainActivity.kt index 61c9203bf8..1fbeae79d9 100644 --- a/androidApp/src/main/java/com/maxrave/simpmusic/MainActivity.kt +++ b/androidApp/src/main/java/com/maxrave/simpmusic/MainActivity.kt @@ -8,6 +8,7 @@ import android.content.res.Configuration import android.os.Build import android.os.Bundle import android.os.IBinder +import android.os.SystemClock import androidx.activity.SystemBarStyle import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge @@ -34,6 +35,7 @@ import com.maxrave.domain.data.model.intent.GenericIntent import com.maxrave.domain.manager.DataStoreManager import com.maxrave.domain.mediaservice.handler.MediaPlayerHandler import com.maxrave.domain.mediaservice.handler.ToastType +import com.maxrave.domain.repository.LibrarySyncPhoneRepository import com.maxrave.logger.Logger import com.maxrave.media3.di.setServiceActivitySession import com.maxrave.simpmusic.di.viewModelModule @@ -53,11 +55,15 @@ import pub.devrel.easypermissions.EasyPermissions import java.util.Locale import java.util.concurrent.TimeUnit +// Process-wide, so a recreated activity (rotation, theme change) does not count as opening the app. +private var lastLibrarySyncAt = 0L + @Suppress("DEPRECATION") class MainActivity : AppCompatActivity() { val viewModel: SharedViewModel by inject() val mediaPlayerHandler by inject() val dataStoreManager: DataStoreManager by inject() + private val librarySync: LibrarySyncPhoneRepository by inject() private var mBound = false private var shouldUnbind = false @@ -84,6 +90,16 @@ class MainActivity : AppCompatActivity() { startMusicService() // Every return to the screen asks; the pass itself runs at most once a day. viewModel.runSmartDownloadsIfDue() + syncLibraryIfDue() + } + + // ponytail: a fixed 5-minute gap between app-open rounds, since a computer that is off costs a + // LAN sweep each time; WorkManager covers the rest every 15 minutes, and "Sync now" ignores it. + private fun syncLibraryIfDue() { + val now = SystemClock.elapsedRealtime() + if (lastLibrarySyncAt != 0L && now - lastLibrarySyncAt < 5 * 60_000L) return + lastLibrarySyncAt = now + lifecycleScope.launch { librarySync.syncNow() } } override fun onStop() { diff --git a/androidApp/src/main/java/com/maxrave/simpmusic/SimpMusicApplication.kt b/androidApp/src/main/java/com/maxrave/simpmusic/SimpMusicApplication.kt index 00b831b514..a50d16cc3b 100644 --- a/androidApp/src/main/java/com/maxrave/simpmusic/SimpMusicApplication.kt +++ b/androidApp/src/main/java/com/maxrave/simpmusic/SimpMusicApplication.kt @@ -20,9 +20,11 @@ import coil3.request.crossfade import com.maxrave.common.AppIdentity import com.maxrave.data.di.loader.loadAllModules import com.maxrave.domain.manager.DataStoreManager +import com.maxrave.domain.repository.LibrarySyncPhoneRepository import com.maxrave.logger.Logger import com.maxrave.simpmusic.di.viewModelModule import com.maxrave.simpmusic.service.backup.AutoBackupScheduler +import com.maxrave.simpmusic.service.sync.LibrarySyncScheduler import com.maxrave.simpmusic.utils.NetworkFirstInterceptor import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers @@ -34,6 +36,7 @@ import okio.FileSystem import org.koin.android.ext.koin.androidContext import org.koin.android.ext.koin.androidLogger import org.koin.core.component.KoinComponent +import org.koin.core.component.get import org.koin.core.component.inject import org.koin.core.context.loadKoinModules import org.koin.core.context.startKoin @@ -90,6 +93,11 @@ class SimpMusicApplication : autoBackupScheduler.observeAndSchedule() } + val librarySyncScheduler = LibrarySyncScheduler(this, get()) + applicationScope.launch { + librarySyncScheduler.observeAndSchedule() + } + CaocConfig.Builder .create() .backgroundMode(CaocConfig.BACKGROUND_MODE_SILENT) // default: CaocConfig.BACKGROUND_MODE_SHOW_CUSTOM diff --git a/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncScheduler.kt b/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncScheduler.kt new file mode 100644 index 0000000000..0f14f5ac6c --- /dev/null +++ b/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncScheduler.kt @@ -0,0 +1,54 @@ +package com.maxrave.simpmusic.service.sync + +import android.content.Context +import androidx.work.Constraints +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import com.maxrave.domain.repository.LibrarySyncPhoneRepository +import com.maxrave.logger.Logger +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.map +import java.util.concurrent.TimeUnit + +/** + * Runs a library sync round in the background while this phone is paired with a computer (#2663). + * Fifteen minutes is the shortest interval WorkManager allows; opening the app and "Sync now" fill in + * between. + */ +class LibrarySyncScheduler( + private val context: Context, + private val repository: LibrarySyncPhoneRepository, +) { + /** Call from a scope that lives as long as the application. */ + suspend fun observeAndSchedule() { + var wasPaired = false + repository.state + .map { it.isPaired } + .distinctUntilChanged() + .collect { paired -> + val workManager = WorkManager.getInstance(context) + if (paired) { + val request = + PeriodicWorkRequestBuilder(15, TimeUnit.MINUTES) + .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) + .build() + // KEEP: a launch must not restart the period, or cancel the job that woke the process. + workManager.enqueueUniquePeriodicWork(WORK_NAME, ExistingPeriodicWorkPolicy.KEEP, request) + Logger.i(TAG, "background sync scheduled") + } else if (wasPaired) { + // Only a real unpairing cancels it. The first value is "not paired" until the + // pairing file has been read, and acting on it would cancel a job that is running. + workManager.cancelUniqueWork(WORK_NAME) + Logger.i(TAG, "background sync cancelled") + } + wasPaired = paired + } + } + + private companion object { + const val TAG = "LibrarySync" + const val WORK_NAME = "LibrarySyncWorker" + } +} diff --git a/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncWorker.kt b/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncWorker.kt new file mode 100644 index 0000000000..b65637bd58 --- /dev/null +++ b/androidApp/src/main/java/com/maxrave/simpmusic/service/sync/LibrarySyncWorker.kt @@ -0,0 +1,22 @@ +package com.maxrave.simpmusic.service.sync + +import android.content.Context +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import com.maxrave.domain.repository.LibrarySyncPhoneRepository +import org.koin.core.component.KoinComponent +import org.koin.core.component.inject + +/** One round; a computer that is away is simply tried again on the next run. */ +class LibrarySyncWorker( + context: Context, + params: WorkerParameters, +) : CoroutineWorker(context, params), + KoinComponent { + private val repository: LibrarySyncPhoneRepository by inject() + + override suspend fun doWork(): Result { + repository.syncNow() + return Result.success() + } +} diff --git a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.android.kt b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.android.kt new file mode 100644 index 0000000000..0291855440 --- /dev/null +++ b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.android.kt @@ -0,0 +1,390 @@ +package com.maxrave.simpmusic.expect.ui + +import android.Manifest +import android.content.Intent +import android.content.pm.PackageManager +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.background +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.WindowInsets +import androidx.compose.foundation.layout.aspectRatio +import androidx.compose.foundation.layout.fillMaxSize +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.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.rememberModalBottomSheetState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +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.platform.LocalContext +import androidx.compose.ui.unit.dp +import androidx.core.content.ContextCompat +import androidx.lifecycle.compose.LifecycleResumeEffect +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem +import com.maxrave.domain.data.model.librarysync.LibrarySyncState +import com.maxrave.simpmusic.extension.findActivity +import com.maxrave.simpmusic.ui.component.QrScanner +import com.maxrave.simpmusic.ui.component.rememberSurfaceDarkColors +import com.maxrave.simpmusic.ui.icon.Close +import com.maxrave.simpmusic.ui.icon.SimpIcons +import com.maxrave.simpmusic.ui.theme.typo +import com.maxrave.simpmusic.viewModel.LibrarySyncPhoneViewModel +import com.maxrave.simpmusic.viewModel.LibrarySyncPhoneViewModel.Step +import kotlinx.coroutines.launch +import org.jetbrains.compose.resources.stringResource +import org.koin.compose.viewmodel.koinViewModel +import org.koin.mp.KoinPlatform.getKoin +import simpmusic.composeapp.generated.resources.Res +import simpmusic.composeapp.generated.resources.cancel +import simpmusic.composeapp.generated.resources.library_sync_allow +import simpmusic.composeapp.generated.resources.library_sync_computer +import simpmusic.composeapp.generated.resources.library_sync_failed +import simpmusic.composeapp.generated.resources.library_sync_first_sync_phone +import simpmusic.composeapp.generated.resources.library_sync_last_synced +import simpmusic.composeapp.generated.resources.library_sync_needs_nearby +import simpmusic.composeapp.generated.resources.library_sync_pair +import simpmusic.composeapp.generated.resources.library_sync_pair_again +import simpmusic.composeapp.generated.resources.library_sync_pair_message +import simpmusic.composeapp.generated.resources.library_sync_pair_title +import simpmusic.composeapp.generated.resources.library_sync_pairing +import simpmusic.composeapp.generated.resources.library_sync_revoked +import simpmusic.composeapp.generated.resources.library_sync_scan_hint +import simpmusic.composeapp.generated.resources.library_sync_settings_differ_android +import simpmusic.composeapp.generated.resources.library_sync_sync_now +import simpmusic.composeapp.generated.resources.library_sync_syncing +import simpmusic.composeapp.generated.resources.library_sync_syncs +import simpmusic.composeapp.generated.resources.library_sync_syncs_value +import simpmusic.composeapp.generated.resources.library_sync_title +import simpmusic.composeapp.generated.resources.library_sync_unpair +import simpmusic.composeapp.generated.resources.library_sync_unpair_message +import simpmusic.composeapp.generated.resources.library_sync_unpair_title +import simpmusic.composeapp.generated.resources.library_sync_unreachable +import simpmusic.composeapp.generated.resources.login_sync_allow_camera +import simpmusic.composeapp.generated.resources.login_sync_camera_blocked +import simpmusic.composeapp.generated.resources.login_sync_camera_needed +import simpmusic.composeapp.generated.resources.login_sync_connecting +import simpmusic.composeapp.generated.resources.login_sync_no_camera +import simpmusic.composeapp.generated.resources.login_sync_open_settings +import simpmusic.composeapp.generated.resources.retry + +private const val ACCESS_LOCAL_NETWORK = "android.permission.ACCESS_LOCAL_NETWORK" + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +actual fun LibrarySyncDialog(onDismiss: () -> Unit) { + val context = LocalContext.current + val viewModel: LibrarySyncPhoneViewModel = koinViewModel() + val state by viewModel.state.collectAsStateWithLifecycle() + val step by viewModel.step.collectAsStateWithLifecycle() + val pending by viewModel.pendingSettings.collectAsStateWithLifecycle() + val scope = rememberCoroutineScope() + val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true) + val colors = rememberSurfaceDarkColors() + var confirmUnpair by remember { mutableStateOf(false) } + + // Camera, plus Nearby devices on Android 17+, asked together as Login Sync does. + val permissions = remember { loginSyncPermissions() } + + fun hasPermissions() = permissions.all { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED } + + val permissionLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { result -> + val granted = result.isNotEmpty() && result.values.all { it } + val blocked = !granted && !context.findActivity().shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) + viewModel.onPermission(granted, blocked) + } + // Paired and only Nearby devices missing: ask for it alone, then run the round it was blocking. + val nearbyLauncher = + rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> + if (granted) viewModel.syncNow() else context.openAppSettings() + } + + fun close() { + scope.launch { sheetState.hide() }.invokeOnCompletion { onDismiss() } + } + + LaunchedEffect(viewModel) { viewModel.open(hasPermissions()) } + DisposableEffect(viewModel) { onDispose { viewModel.close() } } + LifecycleResumeEffect(step) { + if (step is Step.NeedsPermission && hasPermissions()) viewModel.onPermission(granted = true, blocked = false) + onPauseOrDispose { } + } + + ModalBottomSheet( + onDismissRequest = onDismiss, + sheetState = sheetState, + containerColor = Color.Transparent, + contentColor = Color.Transparent, + dragHandle = null, + scrimColor = Color.Black.copy(alpha = .5f), + contentWindowInsets = { WindowInsets(0, 0, 0, 0) }, + ) { + Card( + modifier = Modifier.fillMaxWidth(), + shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp), + colors = CardDefaults.cardColors().copy(containerColor = colors.container), + ) { + Column( + modifier = + Modifier + .fillMaxWidth() + .verticalScroll(rememberScrollState()) + .navigationBarsPadding() + .padding(bottom = 24.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Spacer(Modifier.height(8.dp)) + Box( + Modifier + .width(60.dp) + .height(4.dp) + .clip(RoundedCornerShape(50)) + .background(colors.handle), + ) + Row( + modifier = Modifier.fillMaxWidth().padding(start = 24.dp, end = 8.dp, top = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = stringResource(Res.string.library_sync_title), + style = typo().titleMedium, + color = colors.content, + modifier = Modifier.weight(1f), + ) + IconButton(onClick = ::close) { + Icon(imageVector = SimpIcons.Close, contentDescription = stringResource(Res.string.cancel), tint = colors.content) + } + } + if (state.isPaired) { + PairedStatus( + state = state, + onAllowNearby = { nearbyLauncher.launch(ACCESS_LOCAL_NETWORK) }, + onSyncNow = viewModel::syncNow, + onUnpair = { confirmUnpair = true }, + ) + pending?.let { + Box(Modifier.padding(horizontal = 24.dp, vertical = 8.dp)) { + PendingSettingsCard( + pending = it, + differ = stringResource(Res.string.library_sync_settings_differ_android), + onNotNow = viewModel::dismissSettings, + onApply = { viewModel.applySettings(::restartAfterSyncedSettings) }, + ) + } + } + } else { + Text( + text = stringResource(Res.string.library_sync_scan_hint), + style = typo().bodySmall, + color = colors.subtitle, + modifier = Modifier.fillMaxWidth().padding(horizontal = 24.dp), + ) + Spacer(Modifier.height(20.dp)) + Box( + modifier = + Modifier + .padding(horizontal = 24.dp) + .widthIn(max = 340.dp) + .fillMaxWidth() + .aspectRatio(1f) + .clip(RoundedCornerShape(24.dp)) + .background(if (step == Step.Scanning) Color.Black else colors.disabled.copy(alpha = 0.15f)), + contentAlignment = Alignment.Center, + ) { + when (val s = step) { + Step.Scanning -> { + QrScanner( + onResult = viewModel::onScanned, + onCameraUnavailable = viewModel::onCameraUnavailable, + modifier = Modifier.fillMaxSize(), + ) + ViewfinderCorners(Modifier.fillMaxSize().padding(20.dp)) + } + + Step.Reaching -> { + Status(stringResource(Res.string.login_sync_connecting), progress = true) + } + + Step.Pairing -> { + Status(stringResource(Res.string.library_sync_pairing), progress = true) + } + + is Step.Confirm -> { + Status("${s.desktop.name} · ${s.desktop.os}", progress = false) + } + + is Step.NeedsPermission -> { + if (s.blocked) { + Status(stringResource(Res.string.login_sync_camera_blocked), progress = false) { + SheetButton(stringResource(Res.string.login_sync_open_settings)) { context.openAppSettings() } + } + } else { + Status(stringResource(Res.string.login_sync_camera_needed), progress = false) { + SheetButton(stringResource(Res.string.login_sync_allow_camera)) { + permissionLauncher.launch(permissions.toTypedArray()) + } + } + } + } + + Step.NoCamera -> { + Status(stringResource(Res.string.login_sync_no_camera), progress = false) + } + + Step.Revoked -> { + Status(stringResource(Res.string.library_sync_revoked), progress = false) { + SheetButton(stringResource(Res.string.library_sync_pair_again)) { viewModel.scan(hasPermissions()) } + } + } + + is Step.Failed -> { + Status(problemText(s.problem, s.detail, null), progress = false) { + SheetButton(stringResource(Res.string.retry)) { viewModel.scan(hasPermissions()) } + } + } + } + } + } + } + } + } + + (step as? Step.Confirm)?.let { confirm -> + if (!state.isPaired) { + AlertDialog( + onDismissRequest = { viewModel.cancelConfirm(hasPermissions()) }, + title = { Text(text = stringResource(Res.string.library_sync_pair_title), style = typo().titleSmall) }, + text = { Text(text = stringResource(Res.string.library_sync_pair_message, confirm.desktop.name, confirm.desktop.os)) }, + confirmButton = { + TextButton(onClick = viewModel::pair) { + Text(text = stringResource(Res.string.library_sync_pair), color = LocalContentColor.current) + } + }, + dismissButton = { + TextButton(onClick = { viewModel.cancelConfirm(hasPermissions()) }) { + Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) + } + }, + ) + } + } + + if (confirmUnpair) { + val name = state.peers.firstOrNull()?.name.orEmpty() + AlertDialog( + onDismissRequest = { confirmUnpair = false }, + title = { Text(text = stringResource(Res.string.library_sync_unpair_title, name), style = typo().titleSmall) }, + text = { Text(text = stringResource(Res.string.library_sync_unpair_message, name)) }, + confirmButton = { + TextButton(onClick = { + confirmUnpair = false + viewModel.unpair(hasPermissions()) + }) { Text(text = stringResource(Res.string.library_sync_unpair), color = LocalContentColor.current) } + }, + dismissButton = { + TextButton(onClick = { confirmUnpair = false }) { Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) } + }, + ) + } +} + +/** A4/A5: the computer, what syncs, when it last did, and what stopped it. */ +@Composable +private fun PairedStatus( + state: LibrarySyncState, + onAllowNearby: () -> Unit, + onSyncNow: () -> Unit, + onUnpair: () -> Unit, +) { + val colors = rememberSurfaceDarkColors() + val peer = state.peers.first() + Column( + modifier = Modifier.fillMaxWidth().padding(horizontal = 24.dp, vertical = 8.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + state.problem?.let { problem -> + if (problem == LibrarySyncProblem.NEEDS_LOCAL_NETWORK_PERMISSION) { + SyncProblemBox(stringResource(Res.string.library_sync_needs_nearby), stringResource(Res.string.library_sync_allow), onAllowNearby) + } else { + SyncProblemBox(problemText(problem, state.problemDetail, peer.name)) + } + } + Column { + Text(text = stringResource(Res.string.library_sync_computer), style = typo().bodySmall, color = colors.subtitle) + Text(text = "${peer.name} · ${peer.os}", style = typo().bodyMedium, color = colors.content) + } + Column { + Text(text = stringResource(Res.string.library_sync_syncs), style = typo().bodySmall, color = colors.subtitle) + Text(text = stringResource(Res.string.library_sync_syncs_value), style = typo().bodyMedium, color = colors.content) + } + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + if (state.syncing) CircularProgressIndicator(Modifier.width(16.dp).height(16.dp), strokeWidth = 2.dp) + Text( + text = + when { + state.syncing && state.lastSyncAt == null -> stringResource(Res.string.library_sync_first_sync_phone) + state.syncing -> stringResource(Res.string.library_sync_syncing) + else -> state.lastSyncAt?.let { stringResource(Res.string.library_sync_last_synced, syncedAgo(it)) }.orEmpty() + }, + style = typo().bodySmall, + color = colors.subtitle, + ) + } + SheetButton(stringResource(Res.string.library_sync_sync_now), onSyncNow) + TextButton(onClick = onUnpair, modifier = Modifier.align(Alignment.CenterHorizontally)) { + Text(text = stringResource(Res.string.library_sync_unpair), color = colors.content) + } + } +} + +@Composable +private fun problemText( + problem: LibrarySyncProblem, + detail: String?, + desktopName: String?, +): String = + when (problem) { + LibrarySyncProblem.UNREACHABLE -> stringResource(Res.string.library_sync_unreachable, desktopName ?: "your computer") + LibrarySyncProblem.NEEDS_LOCAL_NETWORK_PERMISSION -> stringResource(Res.string.library_sync_needs_nearby) + LibrarySyncProblem.REVOKED -> stringResource(Res.string.library_sync_revoked) + else -> stringResource(Res.string.library_sync_failed, detail.orEmpty()) + } + +actual fun restartAfterSyncedSettings() { + val context: android.content.Context = getKoin().get() + val launch = context.packageManager.getLaunchIntentForPackage(context.packageName) + context.startActivity(Intent.makeRestartActivityTask(launch?.component)) + Runtime.getRuntime().exit(0) +} diff --git a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt index cf7f5bc685..180a73d344 100644 --- a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt +++ b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt @@ -77,6 +77,9 @@ import org.jetbrains.compose.resources.stringResource import org.koin.compose.viewmodel.koinViewModel import simpmusic.composeapp.generated.resources.Res import simpmusic.composeapp.generated.resources.cancel +import simpmusic.composeapp.generated.resources.library_sync_logins_declined +import simpmusic.composeapp.generated.resources.library_sync_logins_waiting +import simpmusic.composeapp.generated.resources.library_sync_send_logins_paired import simpmusic.composeapp.generated.resources.login_sync_allow_camera import simpmusic.composeapp.generated.resources.login_sync_android_title import simpmusic.composeapp.generated.resources.login_sync_camera_blocked @@ -182,7 +185,9 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { } } Text( - text = stringResource(Res.string.login_sync_scan_hint), + text = + uiState.pairedTo?.let { stringResource(Res.string.library_sync_send_logins_paired, it.name) } + ?: stringResource(Res.string.login_sync_scan_hint), style = typo().bodySmall, color = colors.subtitle, modifier = Modifier.fillMaxWidth().padding(horizontal = 24.dp), @@ -248,6 +253,18 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { Status(stringResource(Res.string.login_sync_no_camera), progress = false) } + is Step.Waiting -> { + Status(stringResource(Res.string.library_sync_logins_waiting, step.desktop.name), progress = true) { + SheetButton(stringResource(Res.string.cancel), ::close) + } + } + + is Step.Declined -> { + Status(stringResource(Res.string.library_sync_logins_declined, step.desktop.name), progress = false) { + SheetButton(stringResource(Res.string.ok), ::close) + } + } + Step.NothingSignedIn -> { Status(stringResource(Res.string.login_sync_nothing_signed_in), progress = false) } @@ -335,7 +352,7 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { /** A message centred in the viewfinder square, with an optional spinner above and action below. */ @Composable -private fun Status( +internal fun Status( text: String, progress: Boolean, action: (@Composable () -> Unit)? = null, @@ -362,7 +379,7 @@ private fun Status( * inherits that instead of onPrimary and renders pale text on a pale fill. */ @Composable -private fun SheetButton( +internal fun SheetButton( text: String, onClick: () -> Unit, ) { @@ -383,7 +400,7 @@ private fun SheetButton( /** Four corner brackets marking where the code should sit. */ @Composable -private fun ViewfinderCorners(modifier: Modifier = Modifier) { +internal fun ViewfinderCorners(modifier: Modifier = Modifier) { Canvas(modifier) { val arm = size.minDimension * 0.14f val stroke = 4.dp.toPx() @@ -413,7 +430,7 @@ internal fun Context.openAppSettings() { * grants ACCESS_LOCAL_NETWORK implicitly with INTERNET, but only to apps that do not declare it, and * our manifest does. Without it the connection does not fail — it times out (element-x-android#7694). */ -private fun loginSyncPermissions(): List = +internal fun loginSyncPermissions(): List = buildList { add(Manifest.permission.CAMERA) if (Build.VERSION.SDK_INT >= 37) { diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 56789955c6..4ea19ff0df 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -508,6 +508,7 @@ Clear listening history Erase your local listening statistics and remove songs that nothing else in the app refers to Your listening statistics and unused resources will be cleaned. This cannot be undone — please back up first. + This device is paired for library sync. Clearing also unpairs it; your other devices keep their own history. Listening history cleared, %1$d songs removed Proxy Using Proxy to bypass country content blocking @@ -960,6 +961,59 @@ Couldn't reach the computer. Make sure your phone is on the same network or tailnet, then try again. The code on your computer has expired. Show a new one and scan again. Something went wrong. Please try again. + Library sync + Not paired · Share likes, artists, albums, podcasts, playlists and history with your phone + Not paired · Share likes, artists, albums, podcasts, playlists and history with your computer + %1$s · synced %2$s + %1$s · not synced yet + just now + %1$d min ago + On your phone, open SimpMusic → Settings → Library sync, then scan this code. + Windows is blocking your phones. This network is set to Public, so Windows refuses connections from other devices. Set it to Private. + Open network settings + Another app is using port 48517. Close it and try again. + Something went wrong: %1$s + Paired with %1$s. + The first sync is running on your phone. Keep SimpMusic open on both devices until it finishes. + Remove + Remove %1$s? + %1$s stops syncing with this computer. Changes made on it since the last sync stay on that phone only. Nothing is deleted on either device. + Settings from %1$s + These differ from this computer's: + These differ from this phone's: + Apply them? SimpMusic restarts. + Not now + Apply & restart + Your phones sync by themselves when SimpMusic opens on them and every 15 minutes, while SimpMusic is open on this computer. Downloads and device settings stay on each device. + Pair another phone + Pair a phone + Use sign-ins from %1$s? + Your phone sent its sign-ins for %1$s. Using them signs this computer in to those accounts. + Ignore + Use + Point the camera at the code under Settings → Library sync on your computer. + Pair with this computer? + This phone and %1$s (%2$s) will share likes, followed artists, saved albums and podcasts, playlists and the last year of listening history with each other. Nothing is deleted. Only continue if this is the computer in front of you. + Pair + Pairing… + Computer + Syncs + Likes, artists, albums, podcasts, playlists, history + First sync in progress. Keep SimpMusic open on both devices. + Syncing… + Last synced %1$s · syncs by itself when SimpMusic opens and every 15 minutes + Sync now + Unpair + Unpair from %1$s? + This phone stops syncing with %1$s. Changes made here since the last sync stay on this phone only. Nothing is deleted on either device. + Couldn't find %1$s. Make sure SimpMusic is open on it and both devices are on the same Wi-Fi or Tailscale. + Nearby devices is off, so this phone can't reach your computer. + Allow + Your computer removed this phone. + Pair again + Send to %1$s over the paired connection + Waiting for %1$s to accept. Confirm on the computer. + %1$s didn't accept the sign-ins. Unofficial app You are using an unofficial copy of SimpMusic that was modified or repackaged by someone else. It cannot be used. Download the official version from simpmusic.org. What's your music taste? diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/di/ViewModelModule.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/di/ViewModelModule.kt index b9ae65a8c3..494a7bc036 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/di/ViewModelModule.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/di/ViewModelModule.kt @@ -16,6 +16,8 @@ import com.maxrave.simpmusic.viewModel.LibraryDynamicPlaylistViewModel import com.maxrave.simpmusic.viewModel.LibrarySidebarViewModel import com.maxrave.simpmusic.viewModel.LibraryViewModel import com.maxrave.simpmusic.viewModel.LocalPlaylistViewModel +import com.maxrave.simpmusic.viewModel.LibrarySyncHostViewModel +import com.maxrave.simpmusic.viewModel.LibrarySyncPhoneViewModel import com.maxrave.simpmusic.viewModel.LogInViewModel import com.maxrave.simpmusic.viewModel.LoginSyncHostViewModel import com.maxrave.simpmusic.viewModel.LoginSyncSenderViewModel @@ -67,7 +69,9 @@ val viewModelModule = // Only one of these resolves on a given platform: Desktop binds the host repository, Android the // sender. Koin resolves dependencies when a ViewModel is created, not when it is declared. viewModel { LoginSyncHostViewModel(get()) } - viewModel { LoginSyncSenderViewModel(get()) } + viewModel { LoginSyncSenderViewModel(get(), get()) } + viewModel { LibrarySyncHostViewModel(get()) } + viewModel { LibrarySyncPhoneViewModel(get()) } viewModel { BrowserLoginViewModel(get()) } viewModel { CommentsViewModel(get(), get()) } viewModel { SoundCloudPlayerViewModel(get()) } @@ -133,6 +137,7 @@ val viewModelModule = get(), get(), get(), + get(), ) } viewModel { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.kt new file mode 100644 index 0000000000..d81dcb8c64 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.kt @@ -0,0 +1,108 @@ +package com.maxrave.simpmusic.expect.ui + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.unit.dp +import com.maxrave.domain.data.model.librarysync.PendingSettings +import com.maxrave.simpmusic.ui.theme.typo +import org.jetbrains.compose.resources.stringResource +import simpmusic.composeapp.generated.resources.Res +import simpmusic.composeapp.generated.resources.day_s_ago +import simpmusic.composeapp.generated.resources.hour_s_ago +import simpmusic.composeapp.generated.resources.library_sync_apply_question +import simpmusic.composeapp.generated.resources.library_sync_apply_restart +import simpmusic.composeapp.generated.resources.library_sync_just_now +import simpmusic.composeapp.generated.resources.library_sync_minutes_ago +import simpmusic.composeapp.generated.resources.library_sync_not_now +import simpmusic.composeapp.generated.resources.library_sync_settings_from +import kotlin.time.Clock +import kotlin.time.ExperimentalTime + +/** Desktop: the pairing QR and the paired phones. Android: scan, pair, then the pairing's status (#2663). */ +@Composable +expect fun LibrarySyncDialog(onDismiss: () -> Unit) + +/** Restarts the app after synced settings were written, the same way a restored backup does. */ +expect fun restartAfterSyncedSettings() + +/** "3 min ago" for an epoch-millisecond time. */ +@OptIn(ExperimentalTime::class) +@Composable +internal fun syncedAgo(millis: Long): String { + val minutes = (Clock.System.now().toEpochMilliseconds() - millis).coerceAtLeast(0) / 60_000 + return when { + minutes < 1 -> stringResource(Res.string.library_sync_just_now) + minutes < 60 -> stringResource(Res.string.library_sync_minutes_ago, minutes.toInt()) + minutes < 24 * 60 -> stringResource(Res.string.hour_s_ago, (minutes / 60).toInt()) + else -> stringResource(Res.string.day_s_ago, (minutes / (24 * 60)).toInt()) + } +} + +// ponytail: names come from the DataStore key ("lyrics_provider" → "Lyrics provider"), so they are +// English on every locale; give the 29 allowlisted keys string resources if translators ask. +internal fun settingLabel(key: String): String = key.replace('_', ' ').replaceFirstChar { it.uppercase() } + +/** A problem worded for the user, with an optional fix next to it. */ +@Composable +internal fun SyncProblemBox( + text: String, + action: String? = null, + onAction: () -> Unit = {}, +) { + Column( + modifier = + Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(12.dp)) + .background(MaterialTheme.colorScheme.errorContainer) + .padding(12.dp), + ) { + Text(text = text, style = typo().bodySmall, color = MaterialTheme.colorScheme.onErrorContainer) + if (action != null) { + TextButton(onClick = onAction, modifier = Modifier.align(Alignment.End)) { + Text(text = action, color = MaterialTheme.colorScheme.onErrorContainer) + } + } + } +} + +/** The other device's settings, named one per line, with Not now / Apply & restart. */ +@Composable +internal fun PendingSettingsCard( + pending: PendingSettings, + differ: String, + onNotNow: () -> Unit, + onApply: () -> Unit, +) { + Column( + modifier = + Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(12.dp)) + .background(MaterialTheme.colorScheme.surfaceContainerHigh) + .padding(12.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text(text = stringResource(Res.string.library_sync_settings_from, pending.fromName), style = typo().titleSmall) + Text(text = differ, style = typo().bodySmall) + pending.keys.forEach { Text(text = "• ${settingLabel(it)}", style = typo().bodyMedium) } + Text(text = stringResource(Res.string.library_sync_apply_question), style = typo().bodySmall) + Row(modifier = Modifier.align(Alignment.End)) { + TextButton(onClick = onNotNow) { Text(text = stringResource(Res.string.library_sync_not_now), color = LocalContentColor.current) } + TextButton(onClick = onApply) { Text(text = stringResource(Res.string.library_sync_apply_restart), color = LocalContentColor.current) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt index 2881398c48..c6ea7e44fe 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt @@ -104,13 +104,16 @@ import com.maxrave.common.VIDEO_QUALITY import com.maxrave.domain.extension.now import com.maxrave.domain.data.model.lyrics.RomanizationDictionaryState import com.maxrave.domain.data.model.lyrics.RomanizationLanguage +import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem import com.maxrave.domain.manager.DataStoreManager import com.maxrave.domain.manager.DataStoreManager.Values.TRUE import com.maxrave.domain.repository.ImportProgress import com.maxrave.domain.utils.LocalResource import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.LibrarySyncDialog import com.maxrave.simpmusic.expect.ui.LoginSyncDialog +import com.maxrave.simpmusic.expect.ui.syncedAgo import com.maxrave.simpmusic.expect.ui.filePickerResult import com.maxrave.simpmusic.expect.ui.fileSaverResult import com.maxrave.simpmusic.expect.ui.isLyricsBlurSupported @@ -234,6 +237,7 @@ import simpmusic.composeapp.generated.resources.clear_downloaded_cache import simpmusic.composeapp.generated.resources.clear_listening_history import simpmusic.composeapp.generated.resources.clear_listening_history_confirm import simpmusic.composeapp.generated.resources.clear_listening_history_description +import simpmusic.composeapp.generated.resources.clear_listening_history_unpairs import simpmusic.composeapp.generated.resources.clear_player_cache import simpmusic.composeapp.generated.resources.clear_thumbnail_cache import simpmusic.composeapp.generated.resources.content @@ -321,6 +325,13 @@ import simpmusic.composeapp.generated.resources.log_out_from_spotify import simpmusic.composeapp.generated.resources.log_out_warning import simpmusic.composeapp.generated.resources.logged_in import simpmusic.composeapp.generated.resources.logged_in_as +import simpmusic.composeapp.generated.resources.library_sync_not_paired_android +import simpmusic.composeapp.generated.resources.library_sync_not_paired_desktop +import simpmusic.composeapp.generated.resources.library_sync_peer_not_synced +import simpmusic.composeapp.generated.resources.library_sync_peer_synced +import simpmusic.composeapp.generated.resources.library_sync_send_logins_paired +import simpmusic.composeapp.generated.resources.library_sync_title +import simpmusic.composeapp.generated.resources.library_sync_windows_public import simpmusic.composeapp.generated.resources.login_sync_android_description import simpmusic.composeapp.generated.resources.login_sync_android_title import simpmusic.composeapp.generated.resources.login_sync_desktop_description @@ -521,6 +532,7 @@ fun SettingScreen( val language by viewModel.language.collectAsStateWithLifecycle() val location by viewModel.location.collectAsStateWithLifecycle() + val librarySyncState by viewModel.librarySyncState.collectAsStateWithLifecycle() val quality by viewModel.quality.collectAsStateWithLifecycle() val downloadQuality by viewModel.downloadQuality.collectAsStateWithLifecycle() val autoDownloadLikedSongs by viewModel.autoDownloadLikedSongs.collectAsStateWithLifecycle() @@ -638,6 +650,9 @@ fun SettingScreen( var showLoginSyncDialog by rememberSaveable { mutableStateOf(false) } + var showLibrarySyncDialog by rememberSaveable { + mutableStateOf(false) + } var showThirdPartyLibraries by rememberSaveable { mutableStateOf(false) } @@ -714,21 +729,46 @@ fun SettingScreen( title = stringResource(Res.string.login_sync_section), modifier = Modifier.onSizeChanged { devicesGroupHeightPx = it.height }, ) { + val syncPeer = librarySyncState.peers.firstOrNull() SettingItem( title = stringResource( if (getPlatform() == Platform.Android) Res.string.login_sync_android_title else Res.string.login_sync_desktop_title, ), subtitle = - stringResource( - if (getPlatform() == Platform.Android) { - Res.string.login_sync_android_description - } else { - Res.string.login_sync_desktop_description - }, - ), + when { + getPlatform() != Platform.Android -> stringResource(Res.string.login_sync_desktop_description) + syncPeer != null -> stringResource(Res.string.library_sync_send_logins_paired, syncPeer.name) + else -> stringResource(Res.string.login_sync_android_description) + }, onClick = { showLoginSyncDialog = true }, ) + SettingItem( + title = stringResource(Res.string.library_sync_title), + subtitle = + when { + librarySyncState.problem == LibrarySyncProblem.WINDOWS_PUBLIC_NETWORK -> { + stringResource(Res.string.library_sync_windows_public) + } + + syncPeer == null -> { + stringResource( + if (getPlatform() == Platform.Android) { + Res.string.library_sync_not_paired_android + } else { + Res.string.library_sync_not_paired_desktop + }, + ) + } + + else -> { + val names = librarySyncState.peers.joinToString { it.name } + librarySyncState.lastSyncAt?.let { stringResource(Res.string.library_sync_peer_synced, names, syncedAgo(it)) } + ?: stringResource(Res.string.library_sync_peer_not_synced, names) + } + }, + onClick = { showLibrarySyncDialog = true }, + ) } SettingGroup(title = stringResource(Res.string.user_interface)) { val themeModeLabels = @@ -1682,7 +1722,11 @@ fun SettingScreen( viewModel.setBasicAlertData( SettingBasicAlertState( title = runBlocking { getString(Res.string.clear_listening_history) }, - message = runBlocking { getString(Res.string.clear_listening_history_confirm) }, + message = + runBlocking { + val confirm = getString(Res.string.clear_listening_history_confirm) + if (viewModel.librarySyncPaired) "$confirm\n\n${getString(Res.string.clear_listening_history_unpairs)}" else confirm + }, confirm = runBlocking { getString(Res.string.clear) } to { viewModel.clearListeningHistory() @@ -3007,6 +3051,9 @@ fun SettingScreen( if (showLoginSyncDialog) { LoginSyncDialog(onDismiss = { showLoginSyncDialog = false }) } + if (showLibrarySyncDialog) { + LibrarySyncDialog(onDismiss = { showLibrarySyncDialog = false }) + } if (showYouTubeAccountDialog) { BasicAlertDialog( onDismissRequest = { }, diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LibrarySyncViewModels.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LibrarySyncViewModels.kt new file mode 100644 index 0000000000..ea26f5fd13 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LibrarySyncViewModels.kt @@ -0,0 +1,197 @@ +package com.maxrave.simpmusic.viewModel + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.maxrave.domain.data.model.librarysync.LibrarySyncException +import com.maxrave.domain.data.model.librarysync.LibrarySyncPairingState +import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem +import com.maxrave.domain.data.model.librarysync.LibrarySyncState +import com.maxrave.domain.data.model.librarysync.PendingSettings +import com.maxrave.domain.data.model.loginsync.DesktopInfo +import com.maxrave.domain.data.model.loginsync.NetAddress +import com.maxrave.domain.repository.LibrarySyncHostRepository +import com.maxrave.domain.repository.LibrarySyncPhoneRepository +import kotlinx.coroutines.NonCancellable +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch + +/** Desktop: the pairing QR, the paired phones, and settings a phone sent (#2663). */ +class LibrarySyncHostViewModel( + private val repository: LibrarySyncHostRepository, +) : ViewModel() { + val state: StateFlow = repository.state + val pairing: StateFlow = repository.pairing + val pendingSettings: StateFlow = repository.pendingSettings + + /** The dialog opened: checks the Windows network profile, and shows the QR straight away when no phone is paired. */ + fun open() { + viewModelScope.launch { + repository.checkNetworkProfile() + } + if (!repository.state.value.isPaired) startPairing() + } + + fun startPairing() { + viewModelScope.launch { repository.startPairing() } + } + + fun select(address: NetAddress) = repository.selectPairingAddress(address) + + /** Back to the list; the QR stops being valid. */ + fun stopPairing() { + viewModelScope.launch { repository.stopPairing() } + } + + fun removePhone(phoneId: String) { + viewModelScope.launch { repository.removePhone(phoneId) } + } + + fun applySettings(restart: () -> Unit) { + viewModelScope.launch { + repository.applyPendingSettings() + restart() + } + } + + fun dismissSettings() { + viewModelScope.launch { repository.dismissPendingSettings() } + } + + // The dialog can close with the ViewModel: the QR must still be withdrawn. + fun close() { + viewModelScope.launch(NonCancellable) { repository.stopPairing() } + } + + override fun onCleared() { + close() + } +} + +/** Android: scans the computer's QR, pairs, then shows the pairing's status (#2663). */ +class LibrarySyncPhoneViewModel( + private val repository: LibrarySyncPhoneRepository, +) : ViewModel() { + /** Only the unpaired side has steps; once paired the screen shows [state]. */ + sealed interface Step { + /** [blocked]: denied with "don't ask again", so only the system settings can grant it now. */ + data class NeedsPermission( + val blocked: Boolean, + ) : Step + + data object NoCamera : Step + + data object Scanning : Step + + data object Reaching : Step + + data class Confirm( + val desktop: DesktopInfo, + ) : Step + + data object Pairing : Step + + /** The computer removed this phone; the user decides when to scan again. */ + data object Revoked : Step + + data class Failed( + val problem: LibrarySyncProblem, + val detail: String?, + ) : Step + } + + val state: StateFlow = repository.state + val pendingSettings: StateFlow = repository.pendingSettings + + private val _step = MutableStateFlow(Step.Scanning) + val step: StateFlow = _step.asStateFlow() + + /** [hasPermissions]: camera (and Nearby devices on Android 17+) already granted. */ + fun open(hasPermissions: Boolean) { + val current = repository.state.value + _step.value = + when { + current.isPaired -> Step.Scanning + current.problem == LibrarySyncProblem.REVOKED -> Step.Revoked + else -> scanOrAsk(hasPermissions) + } + if (current.isPaired) syncNow() + } + + fun scan(hasPermissions: Boolean) { + _step.value = scanOrAsk(hasPermissions) + } + + fun onPermission( + granted: Boolean, + blocked: Boolean, + ) { + _step.value = if (granted) Step.Scanning else Step.NeedsPermission(blocked) + } + + fun onCameraUnavailable() { + _step.value = Step.NoCamera + } + + fun onScanned(text: String) { + // Any other QR (a Login Sync one included) is ignored and the camera keeps looking. + if (_step.value != Step.Scanning || !repository.isPairingCode(text)) return + _step.value = Step.Reaching + viewModelScope.launch { + _step.value = + try { + Step.Confirm(repository.reach(text)) + } catch (e: LibrarySyncException) { + Step.Failed(e.problem, e.detail) + } + } + } + + fun pair() { + if (_step.value !is Step.Confirm) return + _step.value = Step.Pairing + viewModelScope.launch { + try { + repository.pair() + // The paired status takes over the screen from here. + _step.value = Step.Scanning + } catch (e: LibrarySyncException) { + _step.value = Step.Failed(e.problem, e.detail) + } + } + } + + fun cancelConfirm(hasPermissions: Boolean) { + repository.cancelPairing() + _step.value = scanOrAsk(hasPermissions) + } + + fun syncNow() { + viewModelScope.launch { repository.syncNow() } + } + + fun unpair(hasPermissions: Boolean) { + viewModelScope.launch { + repository.unpairAll() + _step.value = scanOrAsk(hasPermissions) + } + } + + fun applySettings(restart: () -> Unit) { + viewModelScope.launch { + repository.applyPendingSettings() + restart() + } + } + + fun dismissSettings() { + viewModelScope.launch { repository.dismissPendingSettings() } + } + + fun close() = repository.cancelPairing() + + override fun onCleared() = close() + + private fun scanOrAsk(hasPermissions: Boolean): Step = if (hasPermissions) Step.Scanning else Step.NeedsPermission(blocked = false) +} diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LoginSyncSenderViewModel.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LoginSyncSenderViewModel.kt index 73a4017c0e..3cea9adab1 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LoginSyncSenderViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/LoginSyncSenderViewModel.kt @@ -2,9 +2,12 @@ package com.maxrave.simpmusic.viewModel import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.maxrave.domain.data.model.librarysync.LibrarySyncException +import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem import com.maxrave.domain.data.model.loginsync.DesktopInfo import com.maxrave.domain.data.model.loginsync.LoginSyncException import com.maxrave.domain.data.model.loginsync.LoginSyncService +import com.maxrave.domain.repository.LibrarySyncPhoneRepository import com.maxrave.domain.repository.LoginSyncSenderRepository import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow @@ -12,9 +15,13 @@ import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch -/** Android: scans the Desktop's QR, asks the user to trust it, sends the chosen sign-ins. */ +/** + * Android: scans the Desktop's QR, asks the user to trust it, sends the chosen sign-ins. Paired for + * library sync, it skips the QR and sends over the paired channel, where the computer's user decides. + */ class LoginSyncSenderViewModel( private val repository: LoginSyncSenderRepository, + private val librarySync: LibrarySyncPhoneRepository, ) : ViewModel() { sealed interface Step { data object Loading : Step @@ -42,6 +49,16 @@ class LoginSyncSenderViewModel( data object Sending : Step + /** Paired: the computer is asking its user (D4). */ + data class Waiting( + val desktop: DesktopInfo, + ) : Step + + /** Paired: the computer's user ignored the sign-ins, or did not answer in time. */ + data class Declined( + val desktop: DesktopInfo, + ) : Step + data class Done( val desktop: DesktopInfo, val services: List, @@ -57,6 +74,8 @@ class LoginSyncSenderViewModel( val step: Step = Step.Loading, val signedIn: List = emptyList(), val selected: Set = emptySet(), + /** The computer this phone is paired with for library sync, if any. */ + val pairedTo: DesktopInfo? = null, ) private val _uiState = MutableStateFlow(UiState()) @@ -66,14 +85,17 @@ class LoginSyncSenderViewModel( /** The sheet opened. [hasCamera]: the camera permission is already granted. */ fun open(hasCamera: Boolean) { - _uiState.value = UiState() + val pairedTo = librarySync.state.value.peers.firstOrNull()?.let { DesktopInfo(it.name, it.os) } + _uiState.value = UiState(pairedTo = pairedTo) viewModelScope.launch { val signedIn = repository.signedInServices() _uiState.value = UiState( + pairedTo = pairedTo, step = when { signedIn.isEmpty() -> Step.NothingSignedIn + pairedTo != null -> Step.Choose(pairedTo) hasCamera -> Step.Scanning else -> Step.NeedsCamera(blocked = false) }, @@ -117,6 +139,7 @@ class LoginSyncSenderViewModel( val choose = _uiState.value.step as? Step.Choose ?: return val services = _uiState.value.selected if (services.isEmpty()) return + if (_uiState.value.pairedTo != null) return sendPaired(choose.desktop, services) step(Step.Sending) viewModelScope.launch { step( @@ -129,9 +152,34 @@ class LoginSyncSenderViewModel( } } + private fun sendPaired( + desktop: DesktopInfo, + services: Set, + ) { + step(Step.Waiting(desktop)) + viewModelScope.launch { + step( + try { + val taken = librarySync.sendLogins(services) + if (taken.isEmpty()) Step.Declined(desktop) else Step.Done(desktop, taken) + } catch (e: LibrarySyncException) { + val reason = if (e.problem == LibrarySyncProblem.UNREACHABLE) LoginSyncException.Reason.UNREACHABLE else LoginSyncException.Reason.FAILED + Step.Failed(reason, e.detail) + }, + ) + } + } + fun retry(hasCamera: Boolean) { repository.disconnect() - step(if (hasCamera) Step.Scanning else Step.NeedsCamera(blocked = false)) + val pairedTo = _uiState.value.pairedTo + step( + when { + pairedTo != null -> Step.Choose(pairedTo) + hasCamera -> Step.Scanning + else -> Step.NeedsCamera(blocked = false) + }, + ) } /** The sheet is gone. A computer still waiting on this phone is put back on its QR. */ diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/SettingsViewModel.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/SettingsViewModel.kt index 6baa36a245..5767975dd5 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/SettingsViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/viewModel/SettingsViewModel.kt @@ -23,6 +23,8 @@ import com.maxrave.domain.repository.AccountRepository import com.maxrave.domain.repository.ArtistRepository import com.maxrave.domain.repository.CacheRepository import com.maxrave.domain.repository.DiscordRepository +import com.maxrave.domain.repository.LibrarySyncRepository +import com.maxrave.domain.data.model.librarysync.LibrarySyncState import com.maxrave.domain.repository.CommonRepository import com.maxrave.domain.repository.LyricsRomanizerRepository import com.maxrave.domain.repository.SongRepository @@ -83,6 +85,7 @@ class SettingsViewModel( private val artistRepository: ArtistRepository, private val lyricsRomanizerRepository: LyricsRomanizerRepository, private val discordRepository: DiscordRepository, + private val librarySyncRepository: LibrarySyncRepository, ) : BaseViewModel() { private val databasePath: String? = commonRepository.getDatabasePath() private val downloadUtils: DownloadHandler by inject() @@ -90,6 +93,10 @@ class SettingsViewModel( val castState: StateFlow get() = mediaPlayerHandler.castState val eightDAvailable: StateFlow get() = mediaPlayerHandler.player.eightDAvailable + /** Library sync (#2663): clearing history and restoring a backup both leave the pairing. */ + val librarySyncPaired: Boolean get() = librarySyncRepository.state.value.isPaired + val librarySyncState: StateFlow get() = librarySyncRepository.state + /** READY everywhere the dictionary is bundled (Desktop), so only Android ever leaves it. */ val japaneseDictionaryState: StateFlow = lyricsRomanizerRepository.japaneseDictionaryState @@ -1327,7 +1334,16 @@ class SettingsViewModel( // last, so a run stopped in between — the user leaving Settings is enough to do // it — has already dropped every cached playlist, album and artist and left the // songs behind. Nothing resumes it afterwards, so it has to run to the end. - withContext(NonCancellable) { songRepository.clearHistoryAndOrphanedSongs() } + withContext(NonCancellable) { + // Paired: leave the pairing first, so nothing synced lands after the wipe and + // the wipe itself never reaches the other device. The wipe goes on regardless. + try { + librarySyncRepository.unpairAll() + } catch (e: Exception) { + Logger.e(tag, "library sync: unpair before clearing history failed", e) + } + songRepository.clearHistoryAndOrphanedSongs() + } } catch (e: CancellationException) { // Not a failure, and it must not be swallowed: catching it breaks structured // concurrency, and it would put the generic error toast in front of a user whose @@ -1380,6 +1396,10 @@ class SettingsViewModel( makeToast(getString(Res.string.restore_in_progress)) withContext(Dispatchers.IO) { runCatching { + // The restored database replaces everything the sync log and the other device + // know about; pairing again starts both from it. A failure here must not stop the restore. + runCatching { librarySyncRepository.unpairAll() } + .onFailure { Logger.e(tag, "library sync: unpair before restore failed", it) } restoreNative(commonRepository, uri) { getData() } diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt index c3638644a2..69634ef759 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt @@ -33,9 +33,11 @@ import com.maxrave.domain.manager.DataStoreManager import com.maxrave.domain.mediaservice.handler.MediaPlayerHandler import com.maxrave.domain.mediaservice.handler.ToastType import com.maxrave.domain.notification.DesktopNotificationManager +import com.maxrave.domain.repository.LibrarySyncHostRepository import com.maxrave.data.io.getHomeFolderPath import com.maxrave.logger.Logger import com.maxrave.simpmusic.di.viewModelModule +import com.maxrave.simpmusic.expect.ui.LibrarySyncLoginPrompt import com.maxrave.simpmusic.extension.DesktopWindowChrome import com.maxrave.simpmusic.ui.component.CustomTitleBar import com.maxrave.simpmusic.ui.mini_player.MiniPlayerManager @@ -53,10 +55,14 @@ import io.sentry.Sentry import io.sentry.SentryLevel import io.sentry.protocol.OperatingSystem import io.sentry.protocol.User +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.SharedFlow import kotlinx.coroutines.flow.asSharedFlow import kotlinx.coroutines.flow.first +import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking import multiplatform.network.cmptoast.ToastHost import multiplatform.network.cmptoast.showToast @@ -267,6 +273,9 @@ fun runDesktopApp(args: Array = emptyArray()) { val desktopNotificationManager = getKoin().get() desktopNotificationManager.initialize() + // Library sync (#2663): reopens the server for paired phones. Off the startup path: it binds a port. + CoroutineScope(SupervisorJob() + Dispatchers.IO).launch { getKoin().get().start() } + val sharedViewModel = getKoin().get() if (sharedViewModel.shouldCheckForUpdate()) { sharedViewModel.checkForUpdate() @@ -505,6 +514,7 @@ fun runDesktopApp(args: Array = emptyArray()) { onOpenDesktopNotificationSettings = desktopNotificationManager::openNotificationSettings, ) + LibrarySyncLoginPrompt() ToastHost() } } diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt new file mode 100644 index 0000000000..9d3608807b --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt @@ -0,0 +1,278 @@ +package com.maxrave.simpmusic.expect.ui + +import androidx.compose.foundation.layout.Arrangement +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.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.selection.selectable +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.RadioButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.maxrave.domain.data.model.librarysync.LibrarySyncPairingState +import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem +import com.maxrave.domain.data.model.librarysync.SyncPeer +import com.maxrave.domain.repository.LibrarySyncHostRepository +import com.maxrave.simpmusic.expect.openUrl +import com.maxrave.simpmusic.ui.theme.AppTheme +import com.maxrave.simpmusic.ui.theme.typo +import com.maxrave.simpmusic.viewModel.LibrarySyncHostViewModel +import org.jetbrains.compose.resources.stringResource +import org.koin.compose.koinInject +import org.koin.compose.viewmodel.koinViewModel +import simpmusic.composeapp.generated.resources.Res +import simpmusic.composeapp.generated.resources.cancel +import simpmusic.composeapp.generated.resources.library_sync_desktop_footer +import simpmusic.composeapp.generated.resources.library_sync_desktop_instructions +import simpmusic.composeapp.generated.resources.library_sync_failed +import simpmusic.composeapp.generated.resources.library_sync_first_sync_desktop +import simpmusic.composeapp.generated.resources.library_sync_ignore +import simpmusic.composeapp.generated.resources.library_sync_logins_message +import simpmusic.composeapp.generated.resources.library_sync_logins_title +import simpmusic.composeapp.generated.resources.library_sync_open_network_settings +import simpmusic.composeapp.generated.resources.library_sync_pair_another +import simpmusic.composeapp.generated.resources.library_sync_pair_phone +import simpmusic.composeapp.generated.resources.library_sync_paired_with +import simpmusic.composeapp.generated.resources.library_sync_peer_not_synced +import simpmusic.composeapp.generated.resources.library_sync_peer_synced +import simpmusic.composeapp.generated.resources.library_sync_port_in_use +import simpmusic.composeapp.generated.resources.library_sync_remove +import simpmusic.composeapp.generated.resources.library_sync_remove_message +import simpmusic.composeapp.generated.resources.library_sync_remove_title +import simpmusic.composeapp.generated.resources.library_sync_settings_differ_desktop +import simpmusic.composeapp.generated.resources.library_sync_title +import simpmusic.composeapp.generated.resources.library_sync_use +import simpmusic.composeapp.generated.resources.library_sync_windows_public +import simpmusic.composeapp.generated.resources.login_sync_new_code +import simpmusic.composeapp.generated.resources.login_sync_no_network +import simpmusic.composeapp.generated.resources.login_sync_pick_address +import simpmusic.composeapp.generated.resources.ok +import kotlin.system.exitProcess + +@Composable +actual fun LibrarySyncDialog(onDismiss: () -> Unit) { + val viewModel: LibrarySyncHostViewModel = koinViewModel() + val state by viewModel.state.collectAsStateWithLifecycle() + val pairing by viewModel.pairing.collectAsStateWithLifecycle() + val pending by viewModel.pendingSettings.collectAsStateWithLifecycle() + var removing by remember { mutableStateOf(null) } + + LaunchedEffect(viewModel) { viewModel.open() } + DisposableEffect(viewModel) { onDispose { viewModel.close() } } + + val showingQr = pairing !is LibrarySyncPairingState.Idle && pairing !is LibrarySyncPairingState.Paired + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(text = stringResource(Res.string.library_sync_title), style = typo().titleSmall) }, + text = { + Column( + modifier = Modifier.fillMaxWidth().verticalScroll(rememberScrollState()), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + when (val p = pairing) { + LibrarySyncPairingState.Starting -> { + CircularProgressIndicator() + } + + is LibrarySyncPairingState.Waiting -> { + QrCode(p.invite, Modifier.size(240.dp)) + Text(text = stringResource(Res.string.library_sync_desktop_instructions), style = typo().bodyMedium, textAlign = TextAlign.Center) + Text(text = stringResource(Res.string.login_sync_pick_address), style = typo().bodySmall, textAlign = TextAlign.Center) + Column(Modifier.fillMaxWidth()) { + p.addresses.forEach { address -> + Row( + modifier = + Modifier + .fillMaxWidth() + .selectable( + selected = address == p.selected, + role = Role.RadioButton, + onClick = { viewModel.select(address) }, + ).padding(vertical = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + RadioButton(selected = address == p.selected, onClick = null) + Spacer(Modifier.width(8.dp)) + Text(text = address.ip, style = typo().bodyMedium) + Spacer(Modifier.width(8.dp)) + Text(text = address.interfaceName, style = typo().bodySmall, maxLines = 1) + } + } + } + WindowsPublicBox(state.problem) + } + + LibrarySyncPairingState.NoNetwork -> { + Text(text = stringResource(Res.string.login_sync_no_network)) + } + + is LibrarySyncPairingState.Failed -> { + SyncProblemBox( + if (p.problem == LibrarySyncProblem.PORT_IN_USE) { + stringResource(Res.string.library_sync_port_in_use) + } else { + stringResource(Res.string.library_sync_failed, p.detail.orEmpty()) + }, + ) + } + + is LibrarySyncPairingState.Paired -> { + Text(text = stringResource(Res.string.library_sync_paired_with, p.peer.name), style = typo().bodyMedium) + Text(text = stringResource(Res.string.library_sync_first_sync_desktop), style = typo().bodySmall) + } + + LibrarySyncPairingState.Idle -> { + state.peers.forEach { peer -> + Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Column(Modifier.weight(1f)) { + Text(text = peer.name, style = typo().bodyMedium) + Text( + text = + peer.lastSyncAt?.let { stringResource(Res.string.library_sync_peer_synced, peer.os, syncedAgo(it)) } + ?: stringResource(Res.string.library_sync_peer_not_synced, peer.os), + style = typo().bodySmall, + ) + } + TextButton(onClick = { removing = peer }) { + Text(text = stringResource(Res.string.library_sync_remove), color = LocalContentColor.current) + } + } + } + pending?.let { + PendingSettingsCard( + pending = it, + differ = stringResource(Res.string.library_sync_settings_differ_desktop), + onNotNow = viewModel::dismissSettings, + onApply = { viewModel.applySettings(::restartAfterSyncedSettings) }, + ) + } + WindowsPublicBox(state.problem) + if (state.problem == LibrarySyncProblem.PORT_IN_USE) SyncProblemBox(stringResource(Res.string.library_sync_port_in_use)) + Text(text = stringResource(Res.string.library_sync_desktop_footer), style = typo().bodySmall) + } + } + } + }, + confirmButton = { + when { + pairing is LibrarySyncPairingState.Paired -> { + TextButton(onClick = viewModel::stopPairing) { Text(text = stringResource(Res.string.ok), color = LocalContentColor.current) } + } + + // Cancel from the QR goes back to the list when a phone is paired, else closes. + showingQr -> { + TextButton(onClick = { if (state.isPaired) viewModel.stopPairing() else onDismiss() }) { + Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) + } + } + + else -> { + TextButton(onClick = onDismiss) { Text(text = stringResource(Res.string.ok), color = LocalContentColor.current) } + } + } + }, + dismissButton = { + when { + pairing is LibrarySyncPairingState.NoNetwork || pairing is LibrarySyncPairingState.Failed -> { + TextButton(onClick = viewModel::startPairing) { + Text(text = stringResource(Res.string.login_sync_new_code), color = LocalContentColor.current) + } + } + + pairing is LibrarySyncPairingState.Idle -> { + TextButton(onClick = viewModel::startPairing) { + Text( + text = stringResource(if (state.isPaired) Res.string.library_sync_pair_another else Res.string.library_sync_pair_phone), + color = LocalContentColor.current, + ) + } + } + + else -> {} + } + }, + ) + + removing?.let { peer -> + AlertDialog( + onDismissRequest = { removing = null }, + title = { Text(text = stringResource(Res.string.library_sync_remove_title, peer.name), style = typo().titleSmall) }, + text = { Text(text = stringResource(Res.string.library_sync_remove_message, peer.name)) }, + confirmButton = { + TextButton(onClick = { + viewModel.removePhone(peer.id) + removing = null + }) { Text(text = stringResource(Res.string.library_sync_remove), color = LocalContentColor.current) } + }, + dismissButton = { + TextButton(onClick = { removing = null }) { Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) } + }, + ) + } +} + +@Composable +private fun WindowsPublicBox(problem: LibrarySyncProblem?) { + if (problem != LibrarySyncProblem.WINDOWS_PUBLIC_NETWORK) return + SyncProblemBox( + text = stringResource(Res.string.library_sync_windows_public), + action = stringResource(Res.string.library_sync_open_network_settings), + onAction = { openUrl("ms-settings:network-status") }, + ) +} + +/** + * Sign-ins a paired phone sent: nothing is used until the user here says so (D4). Lives over the + * whole window, since the phone sends them whenever its user asks. + */ +@Composable +fun LibrarySyncLoginPrompt() { + val repository: LibrarySyncHostRepository = koinInject() + val pending by repository.pendingLogins.collectAsStateWithLifecycle() + val logins = pending ?: return + // Outside App(), so it brings a theme of its own: the app's default dark one. + AppTheme { + AlertDialog( + onDismissRequest = {}, + title = { Text(text = stringResource(Res.string.library_sync_logins_title, logins.fromName), style = typo().titleSmall) }, + text = { Text(text = stringResource(Res.string.library_sync_logins_message, logins.services.joinToString { it.label })) }, + confirmButton = { + TextButton(onClick = { repository.answerLogins(true) }) { + Text(text = stringResource(Res.string.library_sync_use), color = LocalContentColor.current) + } + }, + dismissButton = { + TextButton(onClick = { repository.answerLogins(false) }) { + Text(text = stringResource(Res.string.library_sync_ignore), color = LocalContentColor.current) + } + }, + ) + } +} + +// The same exit a restored backup takes; Desktop has no relaunch of its own. +actual fun restartAfterSyncedSettings() { + exitProcess(0) +} diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt index edcca8865f..939716c939 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt @@ -167,7 +167,7 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { /** Dark modules on white whatever the theme: scanners expect that polarity. */ @Composable -private fun QrCode( +internal fun QrCode( text: String, modifier: Modifier = Modifier, ) { diff --git a/core b/core index a4e6231015..edfac2ca13 160000 --- a/core +++ b/core @@ -1 +1 @@ -Subproject commit a4e62310154c6dc37846237cd7a4ed83708313ed +Subproject commit edfac2ca13f73a047bac7698a2b543bf87f825d0 From 609369fff19698a477ec0e76d640a52e9b5eefec Mon Sep 17 00:00:00 2001 From: maxrave-dev Date: Thu, 12 Nov 2026 23:22:57 +0700 Subject: [PATCH 2/2] feat(ui): add desktop vertical scrollbars, unify artwork corners and tighten Android home --- CLAUDE.md | 6 + .../simpmusic/expect/ui/LoginSync.android.kt | 22 +- .../simpmusic/expect/ui/Scrollbar.android.kt | 22 ++ .../expect/ui/SongRecognition.android.kt | 3 +- .../maxrave/simpmusic/expect/ui/Scrollbar.kt | 29 +++ .../simpmusic/ui/component/AdapterItems.kt | 62 ++++-- .../ui/component/CommentsBottomSheet.kt | 5 + .../simpmusic/ui/component/DesktopSidebar.kt | 11 +- .../ui/component/FiveImagesComponent.kt | 4 +- .../simpmusic/ui/component/FullWidthItems.kt | 8 +- .../ui/component/FullscreenLyricsContent.kt | 5 +- .../ui/component/GridLibraryPlaylist.kt | 6 + .../ui/component/HomeSectionStyles.kt | 4 + .../simpmusic/ui/component/LibraryItem.kt | 4 +- .../ui/component/LibraryTilingBox.kt | 3 +- .../ui/component/ModalBottomSheet.kt | 189 +++++++++--------- .../ui/component/MoodCategoryCard.kt | 3 +- .../ui/component/WrappedEntryCard.kt | 5 +- .../maxrave/simpmusic/ui/screen/MiniPlayer.kt | 5 +- .../simpmusic/ui/screen/home/HomeScreen.kt | 30 ++- .../ui/screen/home/ListenTogetherScreen.kt | 75 ++++--- .../home/ListenTogetherSettingsScreen.kt | 9 +- .../simpmusic/ui/screen/home/MoodScreen.kt | 10 + .../ui/screen/home/NotificationScreen.kt | 10 +- .../simpmusic/ui/screen/home/SettingScreen.kt | 6 + .../screen/home/analytics/AnalyticsScreen.kt | 12 +- .../library/LibraryDynamicPlaylistScreen.kt | 9 + .../ui/screen/library/LibraryScreen.kt | 6 + .../ui/screen/library/LocalPlaylistScreen.kt | 9 +- .../screen/login/DiscordOAuthLoginScreen.kt | 9 +- .../ui/screen/login/LastfmLoginScreen.kt | 9 +- .../simpmusic/ui/screen/login/LogInScreen.kt | 173 ++++++++-------- .../simpmusic/ui/screen/other/AlbumScreen.kt | 9 +- .../simpmusic/ui/screen/other/AppLogScreen.kt | 12 ++ .../simpmusic/ui/screen/other/ArtistScreen.kt | 6 + .../simpmusic/ui/screen/other/BrowseScreen.kt | 6 + .../simpmusic/ui/screen/other/CreditScreen.kt | 9 +- .../ui/screen/other/MoreAlbumsScreen.kt | 9 + .../ui/screen/other/PlaylistScreen.kt | 9 +- .../ui/screen/other/PodcastsScreen.kt | 9 +- .../simpmusic/ui/screen/other/SearchScreen.kt | 21 +- .../content/NowPlayingContentAppleMusic.kt | 5 +- .../content/NowPlayingContentM3Expressive.kt | 3 +- .../content/NowPlayingContentSpotify.kt | 13 +- .../content/applemusic/AppleMusicQueueView.kt | 5 + .../content/applemusic/AppleMusicShared.kt | 3 +- .../com/maxrave/simpmusic/ui/theme/Theme.kt | 5 + .../com/maxrave/simpmusic/DesktopApp.kt | 2 +- .../simpmusic/expect/ui/LibrarySync.jvm.kt | 16 +- .../simpmusic/expect/ui/LoginSync.jvm.kt | 8 +- .../simpmusic/expect/ui/Scrollbar.jvm.kt | 42 ++++ .../ui/mini_player/MiniPlayerLayout.kt | 7 +- 52 files changed, 681 insertions(+), 281 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 01d11a8021..2f361bead7 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1173,6 +1173,12 @@ if (getPlatform() == Platform.Android) { - **Identity is the key, not the IP.** Pairing hands the phone a long-lived key under the QR's one-time key; every later knock carries a nonce the computer must echo with its id, and every sync reply echoes the request's nonce. A 403 alone never unpairs a phone: only the computer's own sealed "removed" knock reply does, and the computer keeps answering it for the 30 days a removed phone is remembered. The server refuses a body with no Content-Length before reading it. The phone looks for the computer at the address picked when pairing (LAN, Tailscale, anything listed), then every address it last reported, then a sealed UDP probe (multicast 239.255.48.17 + broadcast), then a sweep of its /24. - **Deletion never propagates by accident.** Clearing listening history unpairs first (Desktop: every phone), and so does restoring a backup. A removed phone is told under its own key the next time it knocks. Settings travel every round but are applied only after the user agrees (allowlist in `SyncedSettings.KEYS`). A database copy is taken before the first merge of a pairing and before a merge that removes something, at most one an hour, three kept (`~/.simpmusic/sync-backups`, `filesDir/sync-backups`). Pairing state lives in its own `library_sync.preferences_pb`, outside the settings file, so a backup cannot carry a pairing key to another device. +- **Desktop vertical scrollbars, one artwork corner, tighter Android Home (2026-11-12)**: + - `VerticalScrollBar(scrollState, modifier)` (`expect/ui/Scrollbar*.kt`, overloads for `LazyListState`, `LazyGridState`, `ScrollState`) puts Compose Desktop's `VerticalScrollbar`, in the horizontal bars' `scrollBarStyle`, on the right edge of every scrolling page, the sidebar, both queues and the comments sheet. The Desktop gate is inside the function and the Android actual is empty. Thumb drag and press-and-hold paging (one page, then one every 100ms after 300ms) are Compose's own. Put it right after the list in a parent that stacks its children (Box, Crossfade, AnimatedContent): it fills that parent and only the bar takes input. `modifier` carries the list's top inset and `DesktopMiniPlayerClearance` (80dp: the capsule's 60dp plus its 20dp margin). A new vertical list on Desktop gets one too. + - `ArtworkShape` (`ui/theme/Theme.kt`, 4dp, measured off Spotify) is the one corner for rounded artwork; it replaced 2–14dp radii at 44 sites. It is not for circles (artists, avatars), edge-to-edge headers, or the three cards that define a style (M3 Expressive 28dp, SoundCloud 20dp, Your daily discover 28dp). + - Android Home packs tighter, Desktop unchanged: card sides 8dp (`cardSidePadding`), Quick picks rows 56dp, no 8dp/5dp around Quick picks' own header, no 8dp spacer over each section title. Android's card floor is artwork + `cardTextBlockFloor()`, the tallest text block (two `titleSmall` lines plus the subtitle row) measured with `rememberTextMeasurer`: Desktop's fixed 70dp counts Poppins' line gap (Skia) and left ~10dp spare under every Android card. Keep the floor: without it a row takes the height of the cards on screen and Home jumps when a two-line title scrolls in. Titles stay two lines, as on Spotify's song cards; the spare line belongs under the subtitle, never between title and subtitle. + - `AppTheme {}` with no arguments is the app's default cyan dark theme, not the user's: anything drawn outside `App()` (Desktop's `LibrarySyncLoginPrompt`) must read theme mode, colour source and custom colour the way `App()` does. Force-dark `typo()` paints `headlineMedium`/`bodyMedium` in its #A8A8A8 body grey, so text on a scrim (the daily discover hero) names `onSurface`/`onSurfaceVariant`. + ## 🔄 CLAUDE.md Auto-Update Rule (MANDATORY) After completing any of the following types of changes, the AI agent **MUST** update this CLAUDE.md file: diff --git a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt index 180a73d344..68add4c406 100644 --- a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt +++ b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.android.kt @@ -39,6 +39,7 @@ import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon import androidx.compose.material3.IconButton +import androidx.compose.material3.LocalContentColor import androidx.compose.material3.ModalBottomSheet import androidx.compose.material3.Text import androidx.compose.material3.TextButton @@ -68,7 +69,6 @@ import com.maxrave.simpmusic.ui.component.QrScanner import com.maxrave.simpmusic.ui.component.rememberSurfaceDarkColors import com.maxrave.simpmusic.ui.icon.Close import com.maxrave.simpmusic.ui.icon.SimpIcons -import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.LoginSyncSenderViewModel import com.maxrave.simpmusic.viewModel.LoginSyncSenderViewModel.Step @@ -302,10 +302,12 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { title = { Text(text = stringResource(Res.string.login_sync_trust_title), style = typo().titleSmall) }, text = { Text(text = stringResource(Res.string.login_sync_trust_message, step.desktop.name, step.desktop.os)) }, confirmButton = { - TextButton(onClick = viewModel::trust) { Text(text = stringResource(Res.string.login_sync_trust)) } + TextButton(onClick = viewModel::trust) { + Text(text = stringResource(Res.string.login_sync_trust), color = LocalContentColor.current) + } }, dismissButton = { - TextButton(onClick = ::close) { Text(text = stringResource(Res.string.cancel)) } + TextButton(onClick = ::close) { Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) } }, ) } @@ -337,11 +339,11 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { }, confirmButton = { TextButton(enabled = uiState.selected.isNotEmpty(), onClick = viewModel::send) { - Text(text = stringResource(Res.string.login_sync_send)) + Text(text = stringResource(Res.string.login_sync_send), color = LocalContentColor.current) } }, dismissButton = { - TextButton(onClick = ::close) { Text(text = stringResource(Res.string.cancel)) } + TextButton(onClick = ::close) { Text(text = stringResource(Res.string.cancel), color = LocalContentColor.current) } }, ) } @@ -374,9 +376,9 @@ internal fun Status( } /** - * The app's sheet button (ModalBottomSheet.kt's sleep timer "Set"): seed fill, 12dp corners. The text - * colour is set explicitly because typo() bakes a body colour into every style — a stock M3 Button - * inherits that instead of onPrimary and renders pale text on a pale fill. + * The sheet's button: the theme's primary fill, 12dp corners, so it follows the user's theme colour. + * The text colour is set explicitly because typo() bakes a body colour into every style — a stock M3 + * Button inherits that instead of onPrimary and renders pale text on a pale fill. */ @Composable internal fun SheetButton( @@ -387,12 +389,12 @@ internal fun SheetButton( onClick = onClick, modifier = Modifier.fillMaxWidth(), shape = RoundedCornerShape(12.dp), - colors = ButtonDefaults.buttonColors(containerColor = seed), + colors = ButtonDefaults.buttonColors(), ) { Text( text = text, style = typo().labelSmall, - color = rememberSurfaceDarkColors().content, + color = LocalContentColor.current, modifier = Modifier.padding(vertical = 4.dp), ) } diff --git a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.android.kt b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.android.kt index e06c9371ca..93868ec103 100644 --- a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.android.kt +++ b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.android.kt @@ -1,5 +1,6 @@ package com.maxrave.simpmusic.expect.ui +import androidx.compose.foundation.ScrollState import androidx.compose.foundation.gestures.FlingBehavior import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.lazy.grid.LazyGridState @@ -32,3 +33,24 @@ actual fun HorizontalScrollBar( itemCount: Int, ) { } + +@Composable +actual fun VerticalScrollBar( + scrollState: LazyListState, + modifier: Modifier, +) { +} + +@Composable +actual fun VerticalScrollBar( + scrollState: LazyGridState, + modifier: Modifier, +) { +} + +@Composable +actual fun VerticalScrollBar( + scrollState: ScrollState, + modifier: Modifier, +) { +} diff --git a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/SongRecognition.android.kt b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/SongRecognition.android.kt index ea9a689406..1d6d208941 100644 --- a/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/SongRecognition.android.kt +++ b/composeApp/src/androidMain/kotlin/com/maxrave/simpmusic/expect/ui/SongRecognition.android.kt @@ -78,6 +78,7 @@ import com.maxrave.simpmusic.ui.icon.Refresh import com.maxrave.simpmusic.ui.icon.Replay import com.maxrave.simpmusic.ui.icon.Search import com.maxrave.simpmusic.ui.icon.SimpIcons +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import kotlinx.coroutines.launch import org.jetbrains.compose.resources.stringResource @@ -227,7 +228,7 @@ actual fun SongRecognitionSheet( modifier = Modifier .size(OrbSize) - .clip(RoundedCornerShape(14.dp)) + .clip(ArtworkShape) .background(colors.handle), ) Column( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.kt index 2c92131140..e1c4636c48 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.kt @@ -1,5 +1,6 @@ package com.maxrave.simpmusic.expect.ui +import androidx.compose.foundation.ScrollState import androidx.compose.foundation.gestures.FlingBehavior import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.lazy.grid.LazyGridState @@ -7,6 +8,7 @@ import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.carousel.CarouselState import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp /** [flingBehavior]: the list's own snap fling, run once the thumb is let go so a drag ends on an item. */ @Composable @@ -35,3 +37,30 @@ expect fun HorizontalScrollBar( scrollState: CarouselState, itemCount: Int, ) + +/** Space the Desktop capsule player takes at the bottom of a page (App.kt: 60dp tall, 20dp off the bottom). */ +val DesktopMiniPlayerClearance = 80.dp + +/** + * Desktop only: a bar along the right edge of a vertical list, dragged by its thumb or held on its + * track to page. Put it right after the list, in a parent that stacks its children (Box, Crossfade, + * AnimatedContent): it fills that parent and takes input only on the bar itself. [modifier] carries the + * list's top and bottom padding, so the track starts below the top bar and ends above the mini player. + */ +@Composable +expect fun VerticalScrollBar( + scrollState: LazyListState, + modifier: Modifier = Modifier, +) + +@Composable +expect fun VerticalScrollBar( + scrollState: LazyGridState, + modifier: Modifier = Modifier, +) + +@Composable +expect fun VerticalScrollBar( + scrollState: ScrollState, + modifier: Modifier = Modifier, +) diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/AdapterItems.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/AdapterItems.kt index c1ff8a43a6..2ab64cbb9e 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/AdapterItems.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/AdapterItems.kt @@ -64,7 +64,9 @@ import androidx.compose.ui.geometry.CornerRadius import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.graphicsLayer import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.rememberTextMeasurer import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.Dp @@ -117,6 +119,7 @@ import com.maxrave.simpmusic.ui.navigation.destination.list.PlaylistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PodcastDestination import com.maxrave.simpmusic.ui.icon.PlayArrow import com.maxrave.simpmusic.ui.icon.SimpIcons +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalForceDarkText import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.HomeViewModel @@ -407,6 +410,32 @@ private fun Content.hoverPlay(viewModel: BaseViewModel): (() -> Unit)? { return { viewModel.playFromEndpoint(endpoint, title) } } +// Android packs the Home-family cards tighter than Desktop: 8dp sides, so two artworks sit 16dp apart +// instead of 20. Desktop keeps the values it was tuned with. +private val compactCards = getPlatform() == Platform.Android +private val cardSidePadding = if (compactCards) 8.dp else 10.dp + +/** + * The tallest text block under a Home card's artwork — HomeItemSong's: 8dp, two title lines, and the + * subtitle row (its line plus 6dp, or the 20dp explicit badge) — measured in this device's own text. + * Android floors a card at artwork + this, so the tallest card in a row ends right under its subtitle. + * Desktop keeps its fixed 70dp, measured where Skia counts Poppins' line gap; on Android that left ~10dp spare. + */ +@Composable +private fun cardTextBlockFloor(): Dp { + val measurer = rememberTextMeasurer() + val density = LocalDensity.current + val title = typo().titleSmall + val subtitle = typo().bodySmall + return remember(measurer, density, title, subtitle) { + with(density) { + val titleLines = measurer.measure("A\nA", title).size.height.toDp() + val subtitleRow = maxOf(measurer.measure("A", subtitle).size.height.toDp() + 6.dp, 20.dp) + 8.dp + titleLines + subtitleRow + } + } +} + /** * Spotify-style hover for a Home card: while the pointer is over it, or keyboard focus is on it, * the card sits on a faint onSurface tint and [HoverPlayButton] rises onto the artwork. Touch @@ -568,13 +597,13 @@ fun HomeItemContentPlaylist( Column( modifier = Modifier - .padding(start = 10.dp, top = 10.dp, end = 10.dp, bottom = 6.dp) + .padding(start = cardSidePadding, top = 10.dp, end = cardSidePadding, bottom = 6.dp) // One floor for every home card, so a row mixing them stays one height. 70 // covers the tallest text block among them, HomeItemSong's: 69.5dp when the // text engine counts Poppins' line gap (Skia on Desktop does), 65.8dp when not. // A cell-filling card has no such row to match and its artwork is narrower than // thumbSize, so the floor would only add empty space under every tile. - .then(if (fillMaxWidth) Modifier else Modifier.heightIn(min = thumbSize + 70.dp)), + .then(if (fillMaxWidth) Modifier else Modifier.heightIn(min = thumbSize + if (compactCards) cardTextBlockFloor() else 70.dp)), ) { val thumb = when (data) { @@ -681,7 +710,7 @@ fun HomeItemContentPlaylist( (if (fillMaxWidth) Modifier.fillMaxWidth() else Modifier.size(thumbSize)) .aspectRatio(1f) .clip( - RoundedCornerShape(10.dp), + ArtworkShape, ).hoverZoom(hovered), ) if (onPlay != null) HoverPlayButton(visible = hovered, onClick = onPlay) @@ -832,7 +861,8 @@ fun QuickPicksItem( modifier = Modifier .fillMaxWidth() - .padding(10.dp), + // 44dp artwork plus this padding is the grid's cell: 64dp, or 56dp on Android. + .padding(horizontal = 10.dp, vertical = if (compactCards) 6.dp else 10.dp), ) { AsyncImage( model = @@ -851,7 +881,7 @@ fun QuickPicksItem( .align(Alignment.CenterVertically) .size(44.dp) .clip( - RoundedCornerShape(10), + ArtworkShape, ), ) Column( @@ -862,7 +892,7 @@ fun QuickPicksItem( verticalArrangement = Arrangement.SpaceEvenly, ) { // One line + marquee, NOT maxLines = 2: the parent LazyHorizontalGrid uses - // GridCells.Fixed(4) over a fixed 256.dp, so every cell is exactly 64.dp and a + // GridCells.Fixed(4) over a fixed 256.dp (224.dp on Android), so every cell is exactly 64.dp (56.dp) and a // second title line pushes the artist row out of the cell, where the grid clips it. Text( text = data.title, @@ -955,8 +985,8 @@ fun HomeItemSong( Column( modifier = Modifier - .padding(start = 10.dp, top = 10.dp, end = 10.dp, bottom = 6.dp) - .heightIn(min = 230.dp), + .padding(start = cardSidePadding, top = 10.dp, end = cardSidePadding, bottom = 6.dp) + .heightIn(min = if (compactCards) 160.dp + cardTextBlockFloor() else 230.dp), ) { val thumb = data.thumbnails.lastOrNull()?.url?.let { @@ -984,7 +1014,7 @@ fun HomeItemSong( Modifier .then(if (fillMaxWidth) Modifier.fillMaxWidth().aspectRatio(1f) else Modifier.size(160.dp)) .clip( - RoundedCornerShape(10.dp), + ArtworkShape, ).hoverZoom(hovered), ) if (onPlay != null) HoverPlayButton(visible = hovered, onClick = onPlay) @@ -1066,8 +1096,8 @@ fun HomeItemVideo( Column( modifier = Modifier - .padding(start = 10.dp, top = 10.dp, end = 10.dp, bottom = 6.dp) - .heightIn(min = 230.dp), + .padding(start = cardSidePadding, top = 10.dp, end = cardSidePadding, bottom = 6.dp) + .heightIn(min = if (compactCards) 160.dp + cardTextBlockFloor() else 230.dp), ) { val thumb = data.thumbnails.lastOrNull()?.url Box(Modifier.align(Alignment.CenterHorizontally)) { @@ -1089,7 +1119,7 @@ fun HomeItemVideo( .then(if (fillMaxWidth) Modifier.fillMaxWidth() else Modifier.height(160.dp)) .aspectRatio(16f / 9f) .clip( - RoundedCornerShape(10.dp), + ArtworkShape, ).hoverZoom(hovered), ) if (onPlay != null) HoverPlayButton(visible = hovered, onClick = onPlay) @@ -1184,8 +1214,8 @@ fun HomeItemArtist( Column( modifier = Modifier - .padding(start = 10.dp, top = 10.dp, end = 10.dp, bottom = 6.dp) - .heightIn(min = 230.dp), + .padding(start = cardSidePadding, top = 10.dp, end = cardSidePadding, bottom = 6.dp) + .heightIn(min = if (compactCards) 160.dp + cardTextBlockFloor() else 230.dp), ) { val thumb = data.thumbnails.lastOrNull()?.url AsyncImage( @@ -1325,7 +1355,7 @@ fun ItemVideoChart( .width(280.dp) .height(160.dp) .clip( - RoundedCornerShape(10), + ArtworkShape, ), ) Row { @@ -1545,7 +1575,7 @@ fun ItemTrackChart( .align(Alignment.CenterVertically) .size(50.dp) .clip( - RoundedCornerShape(10), + ArtworkShape, ), ) Column( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/CommentsBottomSheet.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/CommentsBottomSheet.kt index d89a7cebb4..c642e0f308 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/CommentsBottomSheet.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/CommentsBottomSheet.kt @@ -72,6 +72,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle import coil3.compose.AsyncImage import com.maxrave.domain.data.model.comments.CommentLikeState import com.maxrave.domain.data.model.comments.YouTubeComment +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.icon.CheckCircle import com.maxrave.simpmusic.ui.icon.Close import com.maxrave.simpmusic.ui.icon.Send @@ -365,6 +366,10 @@ private fun CommentsBody( } } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(bottom = bottomPadding), + ) } } } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/DesktopSidebar.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/DesktopSidebar.kt index 24a8f403e4..e2c653edf7 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/DesktopSidebar.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/DesktopSidebar.kt @@ -79,7 +79,9 @@ import coil3.request.CachePolicy import coil3.request.ImageRequest import com.kyant.backdrop.highlight.Highlight import com.maxrave.domain.data.model.library.LibraryCollectionPreview +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance import com.maxrave.simpmusic.expect.ui.PlatformBackdrop +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.barBlurStyle @@ -97,6 +99,7 @@ import com.maxrave.simpmusic.ui.icon.VolumeUp import com.maxrave.simpmusic.ui.navigation.destination.library.LibraryDynamicPlaylistDestination import com.maxrave.simpmusic.ui.screen.home.chipStripEdgeFades import com.maxrave.simpmusic.ui.screen.library.LibraryDynamicPlaylistType +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalLiquidGlassEnabled import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.LibrarySidebarItem @@ -276,7 +279,7 @@ fun DesktopSidebar( Box( Modifier .size(48.dp) - .clip(RoundedCornerShape(8.dp)) + .clip(ArtworkShape) .background(MaterialTheme.colorScheme.surfaceContainerHighest), contentAlignment = Alignment.Center, ) { collection.icon() } @@ -298,6 +301,10 @@ fun DesktopSidebar( } item { Spacer(Modifier.height(8.dp)) } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(top = with(LocalDensity.current) { headerHeightPx.toDp() }, bottom = DesktopMiniPlayerClearance), + ) Box( Modifier .fillMaxWidth() @@ -701,7 +708,7 @@ private fun SidebarLibraryRow( @Composable private fun SidebarCover(item: LibrarySidebarItem) { - val shape = if (item.kind == LibrarySidebarKind.ARTIST) CircleShape else RoundedCornerShape(8.dp) + val shape = if (item.kind == LibrarySidebarKind.ARTIST) CircleShape else ArtworkShape if (item.thumbnail.isNullOrEmpty()) { // A local playlist with no artwork: the gradient its title tile has in the Library grid, // without the title and badge, which that tile sizes for 150dp and which cannot be read at 48. diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FiveImagesComponent.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FiveImagesComponent.kt index b86290d1aa..4bf69637e1 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FiveImagesComponent.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FiveImagesComponent.kt @@ -15,7 +15,6 @@ import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.wrapContentHeight -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.ui.Alignment @@ -32,6 +31,7 @@ import coil3.request.CachePolicy import coil3.request.ImageRequest import coil3.request.crossfade import com.maxrave.simpmusic.extension.artworkScrimBrush +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo /** @@ -51,7 +51,7 @@ fun FiveImagesComponent( modifier: Modifier, images: List, landscape: Boolean = false, - shape: Shape = RoundedCornerShape(12.dp), + shape: Shape = ArtworkShape, ) { if (images.isEmpty()) return // Rounded on the OUTSIDE of the block only. The tiles stay flush with each other on purpose — diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullWidthItems.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullWidthItems.kt index e0d3c4b071..f79e6b26ff 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullWidthItems.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullWidthItems.kt @@ -33,7 +33,6 @@ import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width import androidx.compose.foundation.layout.wrapContentHeight import androidx.compose.foundation.shape.CircleShape -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text @@ -87,6 +86,7 @@ import com.maxrave.simpmusic.ui.icon.PushPin import com.maxrave.simpmusic.ui.icon.QueueMusic import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.icon.SkipNext +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalForceDarkText import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo @@ -296,7 +296,7 @@ fun SongFullWidthItems( modifier = Modifier .fillMaxSize() - .clip(RoundedCornerShape(4.dp)), + .clip(ArtworkShape), ) } else { Text( @@ -459,7 +459,7 @@ fun SuggestItems( Modifier .wrapContentHeight() .fillMaxWidth() - .clip(RoundedCornerShape(4.dp)), + .clip(ArtworkShape), ) } } @@ -616,7 +616,7 @@ fun PlaylistFullWidthItems( modifier = Modifier .fillMaxSize() - .clip(RoundedCornerShape(4.dp)), + .clip(ArtworkShape), ) } Column( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullscreenLyricsContent.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullscreenLyricsContent.kt index 430e0d5e1f..9be0c6fa1a 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullscreenLyricsContent.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/FullscreenLyricsContent.kt @@ -120,6 +120,7 @@ import com.maxrave.simpmusic.ui.screen.player.content.NowPlayingTrackInfoRow import com.maxrave.simpmusic.ui.screen.player.content.SpotifyPlaybackControls import com.maxrave.simpmusic.ui.screen.player.content.applemusic.AppleMusicPlaybackControls import com.maxrave.simpmusic.ui.screen.player.content.applemusic.rememberAppleMusicTypography +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalLiquidGlassEnabled import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo @@ -363,7 +364,7 @@ fun FullscreenLyricsContent( modifier = Modifier .size(45.dp) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) Spacer(modifier = Modifier.width(12.dp)) @@ -893,7 +894,7 @@ private fun FullscreenLyricsLandscape( Modifier .padding(horizontal = 20.dp) .size(artworkSize) - .clip(RoundedCornerShape(12.dp)), + .clip(ArtworkShape), ) Spacer(modifier = Modifier.height(20.dp)) when (nowPlayingStyle) { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/GridLibraryPlaylist.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/GridLibraryPlaylist.kt index f42ee6d025..21c3dece1a 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/GridLibraryPlaylist.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/GridLibraryPlaylist.kt @@ -52,6 +52,8 @@ import com.maxrave.domain.data.type.MonthlyRecapItem import com.maxrave.domain.data.type.PlaylistType import com.maxrave.domain.utils.LocalResource import com.maxrave.logger.Logger +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.angledGradientBackground import com.maxrave.simpmusic.extension.isScrollingUp import com.maxrave.simpmusic.ui.icon.Add @@ -323,6 +325,10 @@ internal inline fun GridLibraryPlaylist( EndOfPage() } } + VerticalScrollBar( + scrollState = state, + modifier = Modifier.padding(top = contentPadding.calculateTopPadding(), bottom = DesktopMiniPlayerClearance), + ) } else if (data is LocalResource.Loading) { CenterLoadingBox( Modifier.fillMaxSize(), diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/HomeSectionStyles.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/HomeSectionStyles.kt index 2e427d6fc5..82a7cd379a 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/HomeSectionStyles.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/HomeSectionStyles.kt @@ -148,6 +148,8 @@ fun HomeDiscoverSection( ), ) // The scrim is dark in either theme, so the text takes the app's force-dark styles. + // Both colours are named: force-dark typo() paints headlineMedium and bodyMedium in its + // #A8A8A8 body grey, which sinks into the scrim over a bright sleeve. ForceDarkContent { Column( Modifier @@ -158,6 +160,7 @@ fun HomeDiscoverSection( text = song.title, // The size of Home's section titles (HomeSectionHeader). style = typo().headlineMedium, + color = MaterialTheme.colorScheme.onSurface, maxLines = 2, overflow = TextOverflow.Ellipsis, ) @@ -171,6 +174,7 @@ fun HomeDiscoverSection( song.album?.name?.takeIf { it.isNotBlank() }, ).joinToString(" • "), style = typo().bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, ) diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryItem.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryItem.kt index 968c3b243d..302f608a10 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryItem.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryItem.kt @@ -20,7 +20,6 @@ import androidx.compose.foundation.layout.wrapContentSize import androidx.compose.foundation.lazy.LazyRow import androidx.compose.foundation.lazy.items import androidx.compose.foundation.lazy.rememberLazyListState -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text @@ -63,6 +62,7 @@ import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.LocalPlaylistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PlaylistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PodcastDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.LibraryViewModel import com.maxrave.simpmusic.viewModel.SharedViewModel @@ -290,7 +290,7 @@ fun LibraryItem( Modifier .fillMaxSize() .clip( - RoundedCornerShape(8.dp), + ArtworkShape, ), ) Column( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryTilingBox.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryTilingBox.kt index 4cb7bb179b..73dcb5e2ec 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryTilingBox.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/LibraryTilingBox.kt @@ -42,6 +42,7 @@ import com.maxrave.simpmusic.getPlatform import com.maxrave.simpmusic.ui.component.taste.libraryCardColor import com.maxrave.simpmusic.ui.navigation.destination.library.LibraryDynamicPlaylistDestination import com.maxrave.simpmusic.ui.screen.library.LibraryDynamicPlaylistType +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import org.jetbrains.compose.resources.StringResource import org.jetbrains.compose.resources.pluralStringResource @@ -257,7 +258,7 @@ private fun SleeveFan( ) { Box(modifier, contentAlignment = Alignment.Center) { if (thumbnails == null) return@Box - val shape = if (round) CircleShape else RoundedCornerShape(8.dp) + val shape = if (round) CircleShape else ArtworkShape val covers = thumbnails.take(slots) val count = if (covers.isEmpty()) slots else covers.size for (i in 0 until count) { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/ModalBottomSheet.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/ModalBottomSheet.kt index 84c400179e..15449a0d8d 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/ModalBottomSheet.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/ModalBottomSheet.kt @@ -139,6 +139,7 @@ import com.maxrave.domain.utils.toListName import com.maxrave.logger.Logger import com.maxrave.simpmusic.expect.copyToClipboard import com.maxrave.simpmusic.expect.shareUrl +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.persistPickedImage import com.maxrave.simpmusic.expect.ui.photoPickerResult import com.maxrave.simpmusic.extension.displayNameRes @@ -180,6 +181,7 @@ import com.maxrave.simpmusic.ui.icon.Tune import com.maxrave.simpmusic.ui.icon.Update import com.maxrave.simpmusic.ui.navigation.destination.list.AlbumDestination import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.NowPlayingBottomSheetUIEvent @@ -1178,104 +1180,111 @@ fun QueueBottomSheet( "${track.videoId}#$occurrence" } } - LazyColumn( - horizontalAlignment = Alignment.Start, - state = lazyListState, - modifier = - Modifier - .pointerInput(Unit) { - detectDragGesturesAfterLongPress( - onDrag = { change, offset -> - Logger.d("QueueBottomSheet", "onDrag $offset") - change.consume() - dragDropState.onDrag(offset = offset) - - if (overscrollJob?.isActive == true) { - return@detectDragGesturesAfterLongPress - } + // Wraps the list so the Desktop scrollbar can lie over its right edge; sized by the list alone. + Box { + LazyColumn( + horizontalAlignment = Alignment.Start, + state = lazyListState, + modifier = + Modifier + .pointerInput(Unit) { + detectDragGesturesAfterLongPress( + onDrag = { change, offset -> + Logger.d("QueueBottomSheet", "onDrag $offset") + change.consume() + dragDropState.onDrag(offset = offset) + + if (overscrollJob?.isActive == true) { + return@detectDragGesturesAfterLongPress + } - dragDropState - .checkForOverScroll() - .takeIf { it != 0f } - ?.let { - overscrollJob = - coroutineScope.launch { - dragDropState.state.animateScrollBy( - it * 1.3f, - tween(easing = FastOutLinearInEasing), - ) - } + dragDropState + .checkForOverScroll() + .takeIf { it != 0f } + ?.let { + overscrollJob = + coroutineScope.launch { + dragDropState.state.animateScrollBy( + it * 1.3f, + tween(easing = FastOutLinearInEasing), + ) + } + } + ?: run { overscrollJob?.cancel() } + }, + onDragStart = { offset -> + Logger.d("QueueBottomSheet", "onDragStart $offset") + dragDropState.onDragStart(offset) + }, + onDragEnd = { + Logger.d("QueueBottomSheet", "onDragEnd") + dragDropState.onDragInterrupted(true) + overscrollJob?.cancel() + }, + onDragCancel = { + Logger.d("QueueBottomSheet", "onDragCancel") + dragDropState.onDragInterrupted() + overscrollJob?.cancel() + }, + ) + }, + ) { + itemsIndexed( + queue, + // Keyed by the track, NOT by its position: a radio queue drops played + // tracks off the front, and a position-based key changes for every row + // when that happens, so the list loses its scroll anchor and jumps under + // the user. The occurrence number keeps the key unique when a radio + // repeats a song. + key = { i, t -> queueRowKeys.getOrElse(i) { t.videoId } }, + ) { index, track -> + if (index != -1) { + DraggableItem( + dragDropState = dragDropState, + index = index, + modifier = Modifier, + ) { _ -> + SongFullWidthItems( + track = track, + isPlaying = track.videoId == songEntity?.videoId, + modifier = + Modifier + .fillMaxWidth(), + onClickListener = { videoId -> + if (videoId == track.videoId) { + musicServiceHandler.playMediaItemInMediaSource(index) } - ?: run { overscrollJob?.cancel() } - }, - onDragStart = { offset -> - Logger.d("QueueBottomSheet", "onDragStart $offset") - dragDropState.onDragStart(offset) - }, - onDragEnd = { - Logger.d("QueueBottomSheet", "onDragEnd") - dragDropState.onDragInterrupted(true) - overscrollJob?.cancel() - }, - onDragCancel = { - Logger.d("QueueBottomSheet", "onDragCancel") - dragDropState.onDragInterrupted() - overscrollJob?.cancel() - }, - ) - }, - ) { - itemsIndexed( - queue, - // Keyed by the track, NOT by its position: a radio queue drops played - // tracks off the front, and a position-based key changes for every row - // when that happens, so the list loses its scroll anchor and jumps under - // the user. The occurrence number keeps the key unique when a radio - // repeats a song. - key = { i, t -> queueRowKeys.getOrElse(i) { t.videoId } }, - ) { index, track -> - if (index != -1) { - DraggableItem( - dragDropState = dragDropState, - index = index, - modifier = Modifier, - ) { _ -> - SongFullWidthItems( - track = track, - isPlaying = track.videoId == songEntity?.videoId, + }, + onMoreClickListener = { + showQueueItemBottomSheet(index) + }, + onAddToQueue = { + sharedViewModel.addListToQueue( + arrayListOf(track), + ) + }, + ) + } + } + } + item { + if (loadMoreState == QueueData.StateSource.STATE_INITIALIZING) { + CenterLoadingBox( modifier = Modifier - .fillMaxWidth(), - onClickListener = { videoId -> - if (videoId == track.videoId) { - musicServiceHandler.playMediaItemInMediaSource(index) - } - }, - onMoreClickListener = { - showQueueItemBottomSheet(index) - }, - onAddToQueue = { - sharedViewModel.addListToQueue( - arrayListOf(track), - ) - }, + .fillMaxWidth() + .height(80.dp), ) } } - } - item { - if (loadMoreState == QueueData.StateSource.STATE_INITIALIZING) { - CenterLoadingBox( - modifier = - Modifier - .fillMaxWidth() - .height(80.dp), - ) + item { + EndOfPage() } } - item { - EndOfPage() - } + VerticalScrollBar( + scrollState = lazyListState, + modifier = Modifier.matchParentSize(), + ) } } } @@ -1654,7 +1663,7 @@ fun NowPlayingBottomSheet( Modifier .align(Alignment.CenterVertically) .size(44.dp) - .clip(RoundedCornerShape(6.dp)), + .clip(ArtworkShape), ) Spacer(modifier = Modifier.width(12.dp)) Column(verticalArrangement = Arrangement.spacedBy(1.dp)) { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/MoodCategoryCard.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/MoodCategoryCard.kt index 4f7e8bed94..6a3f15da10 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/MoodCategoryCard.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/MoodCategoryCard.kt @@ -24,6 +24,7 @@ import androidx.compose.ui.unit.LayoutDirection import androidx.compose.ui.unit.dp import coil3.compose.AsyncImage import com.maxrave.simpmusic.extension.angledGradientBackground +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import org.jetbrains.compose.resources.painterResource import simpmusic.composeapp.generated.resources.Res @@ -93,7 +94,7 @@ fun MoodCategoryCard( .offset(x = 8.dp, y = 12.dp) .size(64.dp) .rotate(25f) - .clip(RoundedCornerShape(2.dp)), + .clip(ArtworkShape), ) } Text( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/WrappedEntryCard.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/WrappedEntryCard.kt index abdd932b6c..d82092798b 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/WrappedEntryCard.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/component/WrappedEntryCard.kt @@ -33,6 +33,7 @@ import com.maxrave.simpmusic.ui.icon.PlayArrow import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.screen.home.wrapped.formatCount import com.maxrave.simpmusic.ui.screen.home.wrapped.wholeMinutes +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.WrappedYear import org.jetbrains.compose.resources.stringResource @@ -112,7 +113,7 @@ internal fun EntryCard( verticalAlignment = Alignment.CenterVertically, ) { Box( - modifier = Modifier.size(COVER_SIZE).clip(RoundedCornerShape(COVER_RADIUS)), + modifier = Modifier.size(COVER_SIZE).clip(ArtworkShape), content = picture, ) Spacer(Modifier.width(14.dp)) @@ -175,8 +176,6 @@ private val GUTTER = 14.dp /** Row height, not banner height — the whole card lands near 96dp with the gutter. */ private val COVER_SIZE = 68.dp -private val COVER_RADIUS = 8.dp - private val CARD_RADIUS = 12.dp private val DISC_SIZE = 44.dp diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/MiniPlayer.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/MiniPlayer.kt index 8123661417..50acc48db2 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/MiniPlayer.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/MiniPlayer.kt @@ -135,6 +135,7 @@ import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.icon.VolumeOff import com.maxrave.simpmusic.ui.icon.VolumeUp import com.maxrave.simpmusic.ui.screen.player.content.toAudioQualityLabel +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalIsDarkTheme import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.SharedViewModel @@ -422,7 +423,7 @@ fun MiniPlayer( modifier = Modifier .size(if (isFlat) 26.dp else 40.dp) - .clip(if (isFlat) CircleShape else RoundedCornerShape(4.dp)), + .clip(if (isFlat) CircleShape else ArtworkShape), ) } Spacer(modifier = Modifier.width(10.dp)) @@ -757,7 +758,7 @@ fun MiniPlayer( modifier = Modifier .size(32.dp) - .clip(RoundedCornerShape(6.dp)) + .clip(ArtworkShape) .hoverable(artworkInteraction), contentAlignment = Alignment.Center, ) { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/HomeScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/HomeScreen.kt index 6ed66f6042..c49d66c0b0 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/HomeScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/HomeScreen.kt @@ -120,7 +120,9 @@ import com.maxrave.domain.utils.toTrack import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform import com.maxrave.simpmusic.expect.openUrl +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance import com.maxrave.simpmusic.expect.ui.HorizontalScrollBar +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.angledGradientBackground @@ -171,6 +173,7 @@ import com.maxrave.simpmusic.ui.navigation.destination.list.PodcastDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PlaylistDestination import com.maxrave.simpmusic.ui.navigation.destination.login.LoginDestination import com.maxrave.simpmusic.ui.screen.library.LibraryDynamicPlaylistType +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalLiquidGlassEnabled import com.maxrave.simpmusic.ui.theme.desktopPanelDark import com.maxrave.simpmusic.ui.theme.typo @@ -860,7 +863,9 @@ fun HomeScreen( ), ) } - Spacer(modifier = Modifier.height(8.dp)) + // Android drops the 8dp over each section's title: the list's own 8dp + // spacing already separates it from the shelf above. + if (getPlatform() != Platform.Android) Spacer(modifier = Modifier.height(8.dp)) if (item.title == stringResource(Res.string.quick_picks)) { AnimatedVisibility( visible = @@ -1022,6 +1027,14 @@ fun HomeScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = scrollState, + modifier = + Modifier.padding( + top = with(LocalDensity.current) { topAppBarHeightPx.toDp() }, + bottom = DesktopMiniPlayerClearance, + ), + ) } else { Column { Spacer( @@ -1376,9 +1389,12 @@ fun QuickPicks( ) } + // Quick picks draws its own header, and its 8dp around the block and 5dp around the title are + // gaps no other shelf has: on Android they stood it 8dp further off the shelf above than the rest. + val compact = getPlatform() == Platform.Android Column( Modifier - .padding(vertical = 8.dp) + .padding(vertical = if (compact) 0.dp else 8.dp) .onGloballyPositioned { coordinates -> with(density) { widthDp = (coordinates.size.width).toDp() @@ -1399,7 +1415,7 @@ fun QuickPicks( modifier = Modifier .fillMaxWidth() - .padding(vertical = 5.dp), + .padding(vertical = if (compact) 0.dp else 5.dp), ) } if (homeItem.playAllEndpoint != null) { @@ -1411,7 +1427,11 @@ fun QuickPicks( } LazyHorizontalGrid( rows = GridCells.Fixed(4), - modifier = Modifier.height(256.dp).mouseDragScroll(lazyListState, snapperFlingBehavior), + // Four 64dp rows; 56dp on Android, where Home packs tighter (QuickPicksItem pads to match). + modifier = + Modifier + .height(if (compact) 224.dp else 256.dp) + .mouseDragScroll(lazyListState, snapperFlingBehavior), state = lazyListState, flingBehavior = snapperFlingBehavior, ) { @@ -1656,7 +1676,7 @@ fun ChartData( onClick = { navController.navigate(PodcastDestination(podcastId = data.browseId)) }, data = data, widthDp = if (isPortrait) gridWidthDp else minOf(gridWidthDp, LandscapeGridItemMaxWidth), - thumbnailShape = RoundedCornerShape(8.dp), + thumbnailShape = ArtworkShape, subtitle = data.subscribers, ) } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherScreen.kt index d9548f23d6..6e0c78e0f3 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherScreen.kt @@ -78,7 +78,9 @@ import com.maxrave.domain.data.model.listentogether.RoomJoinRequest import com.maxrave.domain.data.model.listentogether.RoomMember import com.maxrave.domain.data.model.listentogether.RoomSuggestion import com.maxrave.simpmusic.expect.shareUrl +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance import com.maxrave.simpmusic.expect.ui.PlatformBackdrop +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.angledGradientBackground @@ -247,44 +249,57 @@ fun ListenTogetherScreen( Row(modifier = Modifier.fillMaxSize().padding(innerPadding)) { // The identity side scrolls separately and normally does not move at all: the room // code is what people read aloud, so it stays on screen while the list scrolls. - Column( - modifier = - Modifier - .weight(0.42f) - .fillMaxHeight() - .verticalScroll(rememberScrollState()) - .padding(start = 24.dp, end = 28.dp, top = 14.dp, bottom = 24.dp), - verticalArrangement = Arrangement.spacedBy(24.dp), - ) { - // Reserves the strip the floating back button is drawn over — it is a sibling of - // this column and takes part in no measurement, so nothing else pushes down for it. - Spacer(Modifier.height(BACK_BUTTON_STRIP)) - TitleBlock(inRoom = state.inRoom) - ConnectionLine(state.connection, viewModel::connect, viewModel::disconnect) - AnimatedVisibility(visible = state.inRoom) { - RoomCodePoster(state, copyCode, shareCode) + val identityScroll = rememberScrollState() + Box(Modifier.weight(0.42f).fillMaxHeight()) { + Column( + modifier = + Modifier + .fillMaxSize() + .verticalScroll(identityScroll) + .padding(start = 24.dp, end = 28.dp, top = 14.dp, bottom = 24.dp), + verticalArrangement = Arrangement.spacedBy(24.dp), + ) { + // Reserves the strip the floating back button is drawn over — it is a sibling of + // this column and takes part in no measurement, so nothing else pushes down for it. + Spacer(Modifier.height(BACK_BUTTON_STRIP)) + TitleBlock(inRoom = state.inRoom) + ConnectionLine(state.connection, viewModel::connect, viewModel::disconnect) + AnimatedVisibility(visible = state.inRoom) { + RoomCodePoster(state, copyCode, shareCode) + } } + VerticalScrollBar( + scrollState = identityScroll, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } - Column( - modifier = - Modifier - .weight(0.58f) - .fillMaxHeight() - .verticalScroll(rememberScrollState()) - .padding(start = 4.dp, end = 40.dp, top = 30.dp) - .animateContentSize(), - verticalArrangement = Arrangement.spacedBy(16.dp), - ) { - WorkArea(state, displayName, codeInput, viewModel, { managing = it }, openSettings) + val workScroll = rememberScrollState() + Box(Modifier.weight(0.58f).fillMaxHeight()) { + Column( + modifier = + Modifier + .fillMaxSize() + .verticalScroll(workScroll) + .padding(start = 4.dp, end = 40.dp, top = 30.dp) + .animateContentSize(), + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + WorkArea(state, displayName, codeInput, viewModel, { managing = it }, openSettings) + } + VerticalScrollBar( + scrollState = workScroll, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } } } else { + val pageScroll = rememberScrollState() Column( modifier = Modifier .fillMaxSize() - .verticalScroll(rememberScrollState()) + .verticalScroll(pageScroll) .padding(innerPadding) .padding(horizontal = 24.dp, vertical = 14.dp) .animateContentSize(), @@ -298,6 +313,10 @@ fun ListenTogetherScreen( } WorkArea(state, displayName, codeInput, viewModel, { managing = it }, openSettings) } + VerticalScrollBar( + scrollState = pageScroll, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding(), bottom = DesktopMiniPlayerClearance), + ) } BackButton(backdrop) { navController.navigateUp() } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherSettingsScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherSettingsScreen.kt index c5a8c16364..3c1ae8a7d1 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherSettingsScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/ListenTogetherSettingsScreen.kt @@ -46,6 +46,8 @@ import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.angledGradientBackground @@ -134,11 +136,12 @@ fun ListenTogetherSettingsScreen( } } + val scrollState = rememberScrollState() Column( modifier = Modifier .fillMaxSize() - .verticalScroll(rememberScrollState()) + .verticalScroll(scrollState) .padding(innerPadding), horizontalAlignment = Alignment.CenterHorizontally, ) { @@ -282,6 +285,10 @@ fun ListenTogetherSettingsScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = scrollState, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding(), bottom = DesktopMiniPlayerClearance), + ) // Floats over the strip the header row reserves — a sibling of both the scroll column and // the backdrop source, exactly the arrangement the main Listen Together page uses. diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/MoodScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/MoodScreen.kt index e719621f2c..bb1351d7c3 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/MoodScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/MoodScreen.kt @@ -3,8 +3,10 @@ package com.maxrave.simpmusic.ui.screen.home import androidx.compose.animation.AnimatedVisibility import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.Text @@ -14,6 +16,8 @@ import androidx.compose.runtime.getValue import androidx.compose.ui.Modifier import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.component.CenterLoadingBox import com.maxrave.simpmusic.ui.component.EndOfPage import com.maxrave.simpmusic.ui.component.MoodAndGenresContentItem @@ -59,7 +63,9 @@ fun MoodScreen( }, ) AnimatedVisibility(visible = !loading) { + val listState = rememberLazyListState() LazyColumn( + state = listState, modifier = Modifier.fillMaxSize(), ) { items(moodData?.items ?: emptyList()) { item -> @@ -72,6 +78,10 @@ fun MoodScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } AnimatedVisibility(visible = loading) { CenterLoadingBox( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/NotificationScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/NotificationScreen.kt index e40c8b4942..d42db0eb6a 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/NotificationScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/NotificationScreen.kt @@ -29,7 +29,6 @@ import androidx.compose.foundation.lazy.LazyRow import androidx.compose.foundation.lazy.items import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.foundation.shape.CircleShape -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme @@ -62,6 +61,8 @@ import coil3.request.CachePolicy import coil3.request.ImageRequest import coil3.request.crossfade import com.maxrave.domain.data.entities.NotificationEntity +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.barBlurStyle import com.maxrave.simpmusic.extension.formatTimeAgo import com.maxrave.simpmusic.extension.mouseDragScroll @@ -75,6 +76,7 @@ import com.maxrave.simpmusic.ui.icon.RssFeed import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.navigation.destination.list.AlbumDestination import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.NotificationViewModel import dev.chrisbanes.haze.HazeInput @@ -152,6 +154,10 @@ fun NotificationScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(top = topAppBarHeight, bottom = DesktopMiniPlayerClearance), + ) } else { Box( Modifier.fillMaxSize(), @@ -407,7 +413,7 @@ fun ItemAlbumNotification( .align(Alignment.CenterHorizontally) .size(150.dp) .clip( - RoundedCornerShape(10), + ArtworkShape, ), ) Text( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt index c6ea7e44fe..2c17b7c0cd 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/SettingScreen.kt @@ -111,8 +111,10 @@ import com.maxrave.domain.repository.ImportProgress import com.maxrave.domain.utils.LocalResource import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance import com.maxrave.simpmusic.expect.ui.LibrarySyncDialog import com.maxrave.simpmusic.expect.ui.LoginSyncDialog +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.syncedAgo import com.maxrave.simpmusic.expect.ui.filePickerResult import com.maxrave.simpmusic.expect.ui.fileSaverResult @@ -2901,6 +2903,10 @@ fun SettingScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = settingListState, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding(), bottom = DesktopMiniPlayerClearance), + ) importState?.let { progress -> ImportProgressDialog( progress = progress, diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/analytics/AnalyticsScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/analytics/AnalyticsScreen.kt index ba50f6c6d8..7951861dfb 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/analytics/AnalyticsScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/home/analytics/AnalyticsScreen.kt @@ -19,6 +19,7 @@ import androidx.compose.foundation.layout.width import androidx.compose.foundation.layout.windowInsetsPadding import androidx.compose.foundation.layout.wrapContentHeight import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.DropdownMenu @@ -46,8 +47,11 @@ import androidx.compose.ui.platform.LocalLayoutDirection import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.Dp +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.LeftToRight import com.maxrave.simpmusic.ui.icon.ArrowForwardIos +import com.maxrave.simpmusic.ui.theme.ArtworkShape import simpmusic.composeapp.generated.resources.analytics_avg_per_day import simpmusic.composeapp.generated.resources.analytics_busiest_day import simpmusic.composeapp.generated.resources.analytics_by_decade @@ -299,7 +303,9 @@ fun AnalyticsScreen( .fillMaxSize() .background(pageBackground), ) { + val listState = rememberLazyListState() LazyColumn( + state = listState, modifier = Modifier .fillMaxSize() @@ -433,6 +439,10 @@ fun AnalyticsScreen( item { EndOfPage() } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) if (selectionState.isActive) { SongSelectionTopAppBar( @@ -793,7 +803,7 @@ private fun LandscapeHeader( ArtworkImage( url = topTrack.second.thumbnails, onBitmap = onBitmap, - modifier = Modifier.size(LANDSCAPE_ARTWORK).clip(RoundedCornerShape(8.dp)), + modifier = Modifier.size(LANDSCAPE_ARTWORK).clip(ArtworkShape), ) Column(modifier = Modifier.weight(1f)) { Text( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryDynamicPlaylistScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryDynamicPlaylistScreen.kt index b572f01306..4600d0af0b 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryDynamicPlaylistScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryDynamicPlaylistScreen.kt @@ -15,6 +15,7 @@ import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.wrapContentWidth import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.material3.MaterialTheme import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon @@ -49,6 +50,8 @@ import com.maxrave.domain.mediaservice.handler.QueueData import com.maxrave.domain.utils.LocalResource import com.maxrave.domain.utils.toArrayListTrack import com.maxrave.domain.utils.toTrack +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.getStringBlocking import com.maxrave.simpmusic.extension.ultraThinBarStyle import com.maxrave.simpmusic.ui.component.SearchBarExit @@ -205,7 +208,9 @@ fun LibraryDynamicPlaylistScreen( ?: emptyList() } + val listState = rememberLazyListState() LazyColumn( + state = listState, modifier = Modifier.hazeSource(hazeState), contentPadding = innerPadding, ) { @@ -463,6 +468,10 @@ fun LibraryDynamicPlaylistScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding(), bottom = DesktopMiniPlayerClearance), + ) if (showSelectionSheet) { val selectedIds = selectionState.selected.toList() val isDownloadedList = LibraryDynamicPlaylistType.toType(type) == LibraryDynamicPlaylistType.Downloaded diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryScreen.kt index 6380241e94..872df955ad 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LibraryScreen.kt @@ -59,6 +59,8 @@ import com.maxrave.domain.data.model.taste.TasteProfile import com.maxrave.domain.utils.LocalResource import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.copy @@ -332,6 +334,10 @@ fun LibraryScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = state, + modifier = Modifier.padding(top = topAppBarHeight, bottom = DesktopMiniPlayerClearance), + ) } } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LocalPlaylistScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LocalPlaylistScreen.kt index 6caeb70514..dc8dd5fee6 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LocalPlaylistScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/library/LocalPlaylistScreen.kt @@ -49,6 +49,8 @@ import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.AlertDialog import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.HorizontalDivider +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.barBlurStyle import com.maxrave.simpmusic.ui.component.DownloadingIndicator import com.maxrave.simpmusic.ui.icon.Search @@ -160,6 +162,7 @@ import com.maxrave.simpmusic.ui.icon.Shuffle import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.icon.Sort import com.maxrave.simpmusic.ui.icon.TipsAndUpdates +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalIsDarkTheme import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo @@ -752,7 +755,7 @@ fun LocalPlaylistScreen( modifier = Modifier .size(280.dp) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) Column( modifier = Modifier.weight(1f), @@ -1424,6 +1427,10 @@ fun LocalPlaylistScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = lazyState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) AnimatedVisibility( visible = selectionState.isActive, enter = fadeIn() + slideInVertically(), diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/DiscordOAuthLoginScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/DiscordOAuthLoginScreen.kt index fe5be0b5f8..f5170b064b 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/DiscordOAuthLoginScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/DiscordOAuthLoginScreen.kt @@ -38,6 +38,8 @@ import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.component.RippleIconButton import com.maxrave.simpmusic.ui.icon.ArrowBackIosNew import com.maxrave.simpmusic.ui.icon.SimpIcons @@ -112,11 +114,12 @@ fun DiscordOAuthLoginScreen( val busy = state is DiscordLoginState.CompletingLogin Box(modifier = Modifier.fillMaxSize()) { + val scrollState = rememberScrollState() Column( modifier = Modifier .fillMaxSize() - .verticalScroll(rememberScrollState()) + .verticalScroll(scrollState) .padding(horizontal = 24.dp), horizontalAlignment = Alignment.CenterHorizontally, ) { @@ -215,6 +218,10 @@ fun DiscordOAuthLoginScreen( Spacer(Modifier.height(48.dp)) } + VerticalScrollBar( + scrollState = scrollState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) TopAppBar( modifier = Modifier.align(Alignment.TopCenter), diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LastfmLoginScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LastfmLoginScreen.kt index e6f6d87cb1..47a6dd912d 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LastfmLoginScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LastfmLoginScreen.kt @@ -41,6 +41,8 @@ import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.component.RippleIconButton import com.maxrave.simpmusic.ui.icon.ArrowBackIosNew import com.maxrave.simpmusic.ui.icon.SimpIcons @@ -120,11 +122,12 @@ fun LastfmLoginScreen( val busy = state is LastfmLoginState.CompletingLogin Box(modifier = Modifier.fillMaxSize()) { + val scrollState = rememberScrollState() Column( modifier = Modifier .fillMaxSize() - .verticalScroll(rememberScrollState()) + .verticalScroll(scrollState) .padding(horizontal = 24.dp), horizontalAlignment = Alignment.CenterHorizontally, ) { @@ -226,6 +229,10 @@ fun LastfmLoginScreen( Spacer(Modifier.height(48.dp)) } + VerticalScrollBar( + scrollState = scrollState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) TopAppBar( modifier = Modifier.align(Alignment.TopCenter), diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LogInScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LogInScreen.kt index 4b4ae944d2..43bd5648c7 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LogInScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/login/LogInScreen.kt @@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.MaterialTheme @@ -46,6 +47,8 @@ import com.maxrave.domain.repository.BrowserProfile import com.maxrave.domain.repository.BrowserProfileStatus import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.getPlatform import com.maxrave.simpmusic.expect.openUrl import com.maxrave.simpmusic.expect.ui.PlatformWebView @@ -308,96 +311,104 @@ internal fun BrowserLoginPanel( ) { val busy = state.loading || state.importingId != null val serviceName = stringResource(if (target == BrowserLoginTarget.YOUTUBE) Res.string.browser_login_youtube else Res.string.spotify) - LazyColumn( - modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp), - contentPadding = PaddingValues(top = 16.dp, bottom = bottomPadding + 24.dp), - ) { - item(key = "description") { - Text( - stringResource(Res.string.browser_login_description, serviceName), - style = typo().bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - if (busy) { - item(key = "progress") { - Row( - Modifier.fillMaxWidth().padding(vertical = 16.dp), - horizontalArrangement = Arrangement.spacedBy(12.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - CircularProgressIndicator(Modifier.size(24.dp)) - Text( - stringResource(if (state.loading) Res.string.loading else Res.string.browser_login_importing), - style = typo().bodyMedium, - color = MaterialTheme.colorScheme.onSurface, - ) + val listState = rememberLazyListState() + Box(Modifier.fillMaxSize()) { + LazyColumn( + state = listState, + modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp), + contentPadding = PaddingValues(top = 16.dp, bottom = bottomPadding + 24.dp), + ) { + item(key = "description") { + Text( + stringResource(Res.string.browser_login_description, serviceName), + style = typo().bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (busy) { + item(key = "progress") { + Row( + Modifier.fillMaxWidth().padding(vertical = 16.dp), + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + CircularProgressIndicator(Modifier.size(24.dp)) + Text( + stringResource(if (state.loading) Res.string.loading else Res.string.browser_login_importing), + style = typo().bodyMedium, + color = MaterialTheme.colorScheme.onSurface, + ) + } } } - } - state.profiles.groupBy { it.browser }.forEach { (browser, profiles) -> - item(key = "browser:$browser") { - SettingGroup(title = browser) { - profiles.forEach { profile -> - val needsFileAccess = state.requiresFileAccess(profile, isMacOS) - val subtitle = when (profile.status) { - BrowserProfileStatus.COOKIES_FOUND -> Res.string.browser_login_found - BrowserProfileStatus.NO_COOKIES -> Res.string.browser_login_missing - BrowserProfileStatus.PERMISSION_REQUIRED -> if (isMacOS) Res.string.browser_login_full_disk_access else Res.string.browser_login_permission - BrowserProfileStatus.UNREADABLE -> Res.string.browser_login_unreadable - BrowserProfileStatus.UNSUPPORTED -> Res.string.browser_login_unsupported - } - SettingItem( - title = profile.name, - subtitle = if (profile.status == BrowserProfileStatus.COOKIES_FOUND || profile.status == BrowserProfileStatus.NO_COOKIES) { - stringResource(subtitle, serviceName) - } else { - stringResource(subtitle) - }, - isEnable = !busy && profile.status != BrowserProfileStatus.UNSUPPORTED, - onClick = { if (needsFileAccess) onOpenFileAccess() else onSelect(profile) }, - otherView = if (needsFileAccess) { - { - TextButton(onClick = onOpenFileAccess, enabled = !busy) { - Text(stringResource(Res.string.browser_login_open_settings), color = LocalContentColor.current) + state.profiles.groupBy { it.browser }.forEach { (browser, profiles) -> + item(key = "browser:$browser") { + SettingGroup(title = browser) { + profiles.forEach { profile -> + val needsFileAccess = state.requiresFileAccess(profile, isMacOS) + val subtitle = when (profile.status) { + BrowserProfileStatus.COOKIES_FOUND -> Res.string.browser_login_found + BrowserProfileStatus.NO_COOKIES -> Res.string.browser_login_missing + BrowserProfileStatus.PERMISSION_REQUIRED -> if (isMacOS) Res.string.browser_login_full_disk_access else Res.string.browser_login_permission + BrowserProfileStatus.UNREADABLE -> Res.string.browser_login_unreadable + BrowserProfileStatus.UNSUPPORTED -> Res.string.browser_login_unsupported + } + SettingItem( + title = profile.name, + subtitle = if (profile.status == BrowserProfileStatus.COOKIES_FOUND || profile.status == BrowserProfileStatus.NO_COOKIES) { + stringResource(subtitle, serviceName) + } else { + stringResource(subtitle) + }, + isEnable = !busy && profile.status != BrowserProfileStatus.UNSUPPORTED, + onClick = { if (needsFileAccess) onOpenFileAccess() else onSelect(profile) }, + otherView = if (needsFileAccess) { + { + TextButton(onClick = onOpenFileAccess, enabled = !busy) { + Text(stringResource(Res.string.browser_login_open_settings), color = LocalContentColor.current) + } } - } - } else { - null - }, - ) + } else { + null + }, + ) + } } } } - } - val error = state.error - if (error != null || state.rejectedSession) { - item(key = "error") { - val message = when { - state.rejectedSession -> Res.string.browser_login_rejected - error == BrowserLoginFailure.FILE_ACCESS_DENIED -> if (isMacOS) Res.string.browser_login_full_disk_access else Res.string.browser_login_permission - error == BrowserLoginFailure.ACCESS_DENIED -> Res.string.browser_login_permission - error == BrowserLoginFailure.KEY_UNAVAILABLE -> Res.string.browser_login_key_unavailable - error == BrowserLoginFailure.UNSUPPORTED_ENCRYPTION -> Res.string.browser_login_unsupported - error == BrowserLoginFailure.DATABASE_BUSY -> Res.string.browser_login_busy - error == BrowserLoginFailure.NO_COOKIES -> Res.string.browser_login_missing - else -> Res.string.browser_login_unreadable + val error = state.error + if (error != null || state.rejectedSession) { + item(key = "error") { + val message = when { + state.rejectedSession -> Res.string.browser_login_rejected + error == BrowserLoginFailure.FILE_ACCESS_DENIED -> if (isMacOS) Res.string.browser_login_full_disk_access else Res.string.browser_login_permission + error == BrowserLoginFailure.ACCESS_DENIED -> Res.string.browser_login_permission + error == BrowserLoginFailure.KEY_UNAVAILABLE -> Res.string.browser_login_key_unavailable + error == BrowserLoginFailure.UNSUPPORTED_ENCRYPTION -> Res.string.browser_login_unsupported + error == BrowserLoginFailure.DATABASE_BUSY -> Res.string.browser_login_busy + error == BrowserLoginFailure.NO_COOKIES -> Res.string.browser_login_missing + else -> Res.string.browser_login_unreadable + } + Spacer(Modifier.height(16.dp)) + Text( + if (error == BrowserLoginFailure.NO_COOKIES) stringResource(message, serviceName) else stringResource(message), + style = typo().bodyMedium, + color = MaterialTheme.colorScheme.error, + ) } - Spacer(Modifier.height(16.dp)) - Text( - if (error == BrowserLoginFailure.NO_COOKIES) stringResource(message, serviceName) else stringResource(message), - style = typo().bodyMedium, - color = MaterialTheme.colorScheme.error, - ) } - } - item(key = "refresh") { - TextButton(onClick = onRefresh, enabled = !busy) { - Text(stringResource(Res.string.browser_login_refresh), color = LocalContentColor.current) + item(key = "refresh") { + TextButton(onClick = onRefresh, enabled = !busy) { + Text(stringResource(Res.string.browser_login_refresh), color = LocalContentColor.current) + } + } + item(key = "end_of_list") { + EndOfPage() } } - item(key = "end_of_list") { - EndOfPage() - } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AlbumScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AlbumScreen.kt index 2afb0c7ea1..9629375211 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AlbumScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AlbumScreen.kt @@ -68,6 +68,8 @@ import coil3.request.ImageRequest import coil3.request.crossfade import com.kmpalette.rememberPaletteState import com.kyant.backdrop.highlight.Highlight +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.barBlurStyle import com.maxrave.simpmusic.ui.component.DownloadingIndicator import com.maxrave.domain.data.entities.DownloadState @@ -106,6 +108,7 @@ import com.maxrave.simpmusic.ui.icon.Shuffle import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.navigation.destination.list.AlbumDestination import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.AlbumViewModel @@ -437,7 +440,7 @@ fun AlbumScreen( modifier = Modifier .size(280.dp) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) Column( modifier = Modifier.weight(1f), @@ -932,6 +935,10 @@ fun AlbumScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = lazyState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) AnimatedVisibility( visible = shouldHideTopBar && !selectionState.isActive, enter = fadeIn() + slideInVertically(), diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AppLogScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AppLogScreen.kt index 356e7e1817..686405bf28 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AppLogScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/AppLogScreen.kt @@ -60,6 +60,8 @@ import androidx.navigation.NavController import com.maxrave.logger.Logger import com.maxrave.simpmusic.Platform import com.maxrave.simpmusic.expect.copyToClipboard +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.getPlatform import com.maxrave.simpmusic.ui.component.Chip import com.maxrave.simpmusic.ui.component.EndOfPage @@ -348,11 +350,17 @@ fun AppLogScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = logListState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } else -> { var expanded by remember { mutableStateOf(emptySet()) } + val errorListState = rememberLazyListState() LazyColumn( + state = errorListState, contentPadding = PaddingValues(top = 12.dp, bottom = bottomInset), verticalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.padding(horizontal = if (wide) 20.dp else 16.dp), @@ -370,6 +378,10 @@ fun AppLogScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = errorListState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) } } } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/ArtistScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/ArtistScreen.kt index d13ce6a2da..56e231262b 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/ArtistScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/ArtistScreen.kt @@ -95,6 +95,8 @@ import com.maxrave.domain.mediaservice.handler.PlaylistType import com.maxrave.domain.mediaservice.handler.QueueData import com.maxrave.domain.utils.toSongEntity import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.getPlatform import com.maxrave.simpmusic.expect.shareUrl import com.maxrave.simpmusic.expect.ui.MediaPlayerView @@ -718,6 +720,10 @@ fun ArtistScreen( ) } } + VerticalScrollBar( + scrollState = lazyState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) // Haze top bar appears once the header scrolls away. AnimatedVisibility( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/BrowseScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/BrowseScreen.kt index 4b18634481..40d328dea5 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/BrowseScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/BrowseScreen.kt @@ -58,6 +58,8 @@ import com.maxrave.domain.data.model.home.Content import com.maxrave.domain.utils.toSongEntity import com.maxrave.domain.utils.toTrack import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.angledGradientBackground import com.maxrave.simpmusic.extension.artworkScrimBrush import com.maxrave.simpmusic.extension.barBlurStyle @@ -267,6 +269,10 @@ fun BrowseScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = listState, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding() + 64.dp, bottom = DesktopMiniPlayerClearance), + ) } } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/CreditScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/CreditScreen.kt index 5e0be04289..b3a072b4e3 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/CreditScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/CreditScreen.kt @@ -44,6 +44,8 @@ import androidx.compose.ui.unit.sp import androidx.navigation.NavController import com.maxrave.domain.extension.now import com.maxrave.simpmusic.expect.openUrl +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.ultraThinBarStyle import com.maxrave.simpmusic.ui.component.RippleIconButton import com.maxrave.simpmusic.ui.icon.ArrowBackIosNew @@ -67,13 +69,14 @@ fun CreditScreen( navController: NavController, ) { val hazeState = rememberHazeState() + val scrollState = rememberScrollState() Column( modifier = Modifier .fillMaxSize() .padding(paddingValues) .padding(top = 64.dp) - .verticalScroll(rememberScrollState()) + .verticalScroll(scrollState) .hazeSource(state = hazeState), horizontalAlignment = Alignment.CenterHorizontally, ) { @@ -249,6 +252,10 @@ fun CreditScreen( // Bottom spacing Spacer(modifier = Modifier.height(200.dp)) } + VerticalScrollBar( + scrollState = scrollState, + modifier = Modifier.padding(top = paddingValues.calculateTopPadding() + 64.dp, bottom = DesktopMiniPlayerClearance), + ) TopAppBar( modifier = Modifier diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/MoreAlbumsScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/MoreAlbumsScreen.kt index 85add1d4d3..9451b1f827 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/MoreAlbumsScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/MoreAlbumsScreen.kt @@ -17,6 +17,7 @@ import androidx.compose.foundation.lazy.grid.GridCells import androidx.compose.foundation.lazy.grid.GridItemSpan import androidx.compose.foundation.lazy.grid.LazyVerticalGrid import androidx.compose.foundation.lazy.grid.items +import androidx.compose.foundation.lazy.grid.rememberLazyGridState import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text @@ -32,6 +33,8 @@ import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavController import com.maxrave.logger.Logger +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.ultraThinBarStyle import com.maxrave.simpmusic.ui.component.CenterLoadingBox import com.maxrave.simpmusic.ui.component.EndOfPage @@ -84,7 +87,9 @@ fun MoreAlbumsScreen( when (state) { is MoreAlbumsUIState.Success -> { val data = state.albumItems + val gridState = rememberLazyGridState() LazyVerticalGrid( + state = gridState, // As many columns as fit, not a fixed two: HomeItemContentPlaylist is a fixed // 180dp wide, so two columns on a wide window left each tile alone in a huge cell. // 170dp rather than 180 keeps two columns on a 360dp phone (2 × 170 + the 10dp @@ -126,6 +131,10 @@ fun MoreAlbumsScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = gridState, + modifier = Modifier.padding(top = innerPadding.calculateTopPadding() + 64.dp, bottom = DesktopMiniPlayerClearance), + ) TopAppBar( modifier = Modifier diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PlaylistScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PlaylistScreen.kt index 195a68c18a..b0f01b5351 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PlaylistScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PlaylistScreen.kt @@ -85,6 +85,8 @@ import coil3.request.crossfade import coil3.toBitmap import com.kyant.backdrop.highlight.Highlight import com.kmpalette.rememberPaletteState +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.extension.barBlurStyle import com.maxrave.simpmusic.ui.component.DownloadingIndicator import com.maxrave.domain.data.entities.DownloadState @@ -127,6 +129,7 @@ import com.maxrave.simpmusic.ui.icon.Search import com.maxrave.simpmusic.ui.icon.Shuffle import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalIsDarkTheme import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo @@ -600,7 +603,7 @@ fun PlaylistScreen( modifier = Modifier .size(280.dp) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) Column( modifier = Modifier.weight(1f), @@ -1163,6 +1166,10 @@ fun PlaylistScreen( } } } + VerticalScrollBar( + scrollState = lazyState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) AnimatedVisibility( visible = showSearchBar, diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PodcastsScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PodcastsScreen.kt index 062d9c40b6..314e0fe062 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PodcastsScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/PodcastsScreen.kt @@ -51,6 +51,8 @@ import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.ImageBitmap import androidx.compose.ui.graphics.asImageBitmap +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.component.rememberHolderPainter import com.maxrave.simpmusic.expect.ui.toImageBitmap import androidx.compose.ui.layout.ContentScale @@ -86,6 +88,7 @@ import com.maxrave.simpmusic.ui.icon.Share import com.maxrave.simpmusic.ui.icon.Shuffle import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.PodcastUIEvent import com.maxrave.simpmusic.viewModel.PodcastUIState @@ -227,7 +230,7 @@ fun PodcastScreen( .height(250.dp) .wrapContentWidth() .align(Alignment.CenterHorizontally) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) Box( modifier = @@ -410,6 +413,10 @@ fun PodcastScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = lazyState, + modifier = Modifier.padding(bottom = DesktopMiniPlayerClearance), + ) // Animated TopAppBar when scrolling AnimatedVisibility( visible = shouldHideTopBar, diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/SearchScreen.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/SearchScreen.kt index c73e98f50a..2bd6572adb 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/SearchScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/other/SearchScreen.kt @@ -103,8 +103,10 @@ import com.maxrave.domain.utils.connectArtists import com.maxrave.domain.utils.toSongEntity import com.maxrave.domain.utils.toTrack import com.maxrave.simpmusic.Platform +import com.maxrave.simpmusic.expect.ui.DesktopMiniPlayerClearance import com.maxrave.simpmusic.expect.ui.PlatformBackHandler import com.maxrave.simpmusic.expect.ui.SongRecognitionSheet +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.expect.ui.layerBackdrop import com.maxrave.simpmusic.expect.ui.rememberBackdrop import com.maxrave.simpmusic.extension.getScreenSizeInfo @@ -140,6 +142,7 @@ import com.maxrave.simpmusic.ui.navigation.destination.list.ArtistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PlaylistDestination import com.maxrave.simpmusic.ui.navigation.destination.list.PodcastDestination import com.maxrave.simpmusic.ui.navigation.destination.search.SearchDestination +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.LocalLiquidGlassEnabled import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.SearchScreenUIState @@ -537,6 +540,10 @@ fun SearchScreen( ) } } + VerticalScrollBar( + scrollState = suggestionsState, + modifier = Modifier.padding(top = searchBarHeight, bottom = DesktopMiniPlayerClearance), + ) } SearchUIType.SEARCH_HISTORY -> { @@ -629,6 +636,10 @@ fun SearchScreen( } } } + VerticalScrollBar( + scrollState = historyState, + modifier = Modifier.padding(top = searchBarHeight, bottom = DesktopMiniPlayerClearance), + ) } SearchUIType.EMPTY -> { @@ -726,6 +737,10 @@ fun SearchScreen( EndOfPage() } } + VerticalScrollBar( + scrollState = moodGridState, + modifier = Modifier.padding(top = searchBarHeight, bottom = DesktopMiniPlayerClearance), + ) } } } @@ -948,6 +963,10 @@ fun SearchScreen( // Space at bottom to account for bottom navigation and mini player item { Spacer(modifier = Modifier.height(150.dp)) } } + VerticalScrollBar( + scrollState = resultsState, + modifier = Modifier.padding(top = searchBarHeight, bottom = DesktopMiniPlayerClearance), + ) } else { Box( modifier = Modifier.fillMaxSize(), @@ -1292,7 +1311,7 @@ fun SuggestItemRow( if (searchResult is ArtistsResult) { CircleShape } else { - RoundedCornerShape(4.dp) + ArtworkShape }, ), ) diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentAppleMusic.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentAppleMusic.kt index 7e143538bc..580f61953b 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentAppleMusic.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentAppleMusic.kt @@ -110,6 +110,7 @@ import com.maxrave.simpmusic.ui.screen.player.content.applemusic.appleMusicVerti import com.maxrave.simpmusic.ui.screen.player.content.applemusic.displayName import com.maxrave.simpmusic.ui.screen.player.content.applemusic.rememberAppleMusicMesh import com.maxrave.simpmusic.ui.screen.player.content.applemusic.rememberAppleMusicTypography +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.NowPlayingScreenData @@ -739,7 +740,7 @@ private fun AppleMusicMainView( error = rememberHolderPainter(), contentDescription = null, contentScale = ContentScale.Crop, - modifier = Modifier.size(55.dp).clip(RoundedCornerShape(4.dp)), + modifier = Modifier.size(55.dp).clip(ArtworkShape), ) Spacer(modifier = Modifier.width(10.dp)) Column(modifier = Modifier.weight(1f)) { @@ -1052,7 +1053,7 @@ private fun AppleMusicArtworkPage( .size(width = frameWidth, height = frameHeight) // A vertical video stands clear of the screen edges, so it is rounded // like a card; wide ones run edge to edge and stay square. - .then(if (ratio < 1f) Modifier.clip(RoundedCornerShape(12.dp)) else Modifier), + .then(if (ratio < 1f) Modifier.clip(ArtworkShape) else Modifier), ) { MediaPlayerViewWithSubtitle( playerName = MAIN_PLAYER, diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentM3Expressive.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentM3Expressive.kt index 344090b4c1..d3b3eb0839 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentM3Expressive.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentM3Expressive.kt @@ -117,6 +117,7 @@ import com.maxrave.simpmusic.ui.icon.SimpIcons import com.maxrave.simpmusic.ui.screen.player.content.applemusic.AudioOutputSheetHost import com.maxrave.simpmusic.ui.screen.player.content.expressive.ExpressiveTransportRow import com.maxrave.simpmusic.ui.screen.player.content.expressive.WavySeekBar +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.seed import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.UIEvent @@ -720,7 +721,7 @@ internal fun ExpressiveTrackInfoRow( .width(55.dp) .padding(end = 10.dp) .clip( - RoundedCornerShape(4.dp), + ArtworkShape, ).align(Alignment.CenterVertically), ) } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentSpotify.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentSpotify.kt index 60b79e2a83..3207357e61 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentSpotify.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/NowPlayingContentSpotify.kt @@ -157,6 +157,7 @@ import com.maxrave.simpmusic.ui.icon.Subtitles import com.maxrave.simpmusic.ui.icon.SubtitlesOff import com.maxrave.simpmusic.ui.icon.ThumbsUpDown import com.maxrave.simpmusic.ui.screen.player.content.applemusic.AudioOutputSheetHost +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.blackMoreOverlay import com.maxrave.simpmusic.ui.theme.overlay import com.maxrave.simpmusic.ui.theme.typo @@ -554,7 +555,7 @@ fun NowPlayingContentSpotify( .background(Color.Transparent) .shadow( elevation = 3.dp, - shape = RoundedCornerShape(8.dp), + shape = ArtworkShape, spotColor = state.spotShadowColor.copy( alpha = 0.6f, @@ -602,7 +603,7 @@ fun NowPlayingContentSpotify( }, ).background(Color.Transparent) .clip( - RoundedCornerShape(8.dp), + ArtworkShape, ).alpha( if (!state.screenData.isVideo || !state.shouldShowVideo) 1f else 0f, ), @@ -625,7 +626,7 @@ fun NowPlayingContentSpotify( modifier = Modifier .aspectRatio(state.videoAspectRatio) - .clip(RoundedCornerShape(8.dp)) + .clip(ArtworkShape) .background(Color.Black), ) { Box(Modifier.fillMaxSize()) { @@ -781,7 +782,7 @@ fun NowPlayingContentSpotify( .background(Color.Transparent) .shadow( elevation = 3.dp, - shape = RoundedCornerShape(8.dp), + shape = ArtworkShape, spotColor = Color.Black.copy(alpha = 0.4f), ambientColor = Color.Transparent, ), @@ -815,7 +816,7 @@ fun NowPlayingContentSpotify( .padding(3.dp) .fillMaxWidth() .aspectRatio(1f) - .clip(RoundedCornerShape(8.dp)), + .clip(ArtworkShape), ) } } @@ -1852,7 +1853,7 @@ internal fun NowPlayingTrackInfoRow( .width(55.dp) .padding(end = 10.dp) .clip( - RoundedCornerShape(4.dp), + ArtworkShape, ).align(Alignment.CenterVertically), ) } diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicQueueView.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicQueueView.kt index 7cdb222735..fd816a5206 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicQueueView.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicQueueView.kt @@ -57,6 +57,7 @@ import com.maxrave.domain.mediaservice.handler.MediaPlayerHandler import com.maxrave.domain.mediaservice.handler.QueueData import com.maxrave.domain.mediaservice.handler.RepeatState import com.maxrave.simpmusic.expect.ui.DeviceVolumeController +import com.maxrave.simpmusic.expect.ui.VerticalScrollBar import com.maxrave.simpmusic.ui.component.DraggableItem import com.maxrave.simpmusic.ui.component.SongFullWidthItems import com.maxrave.simpmusic.ui.component.rememberDragDropState @@ -289,6 +290,10 @@ internal fun AppleMusicQueueView( } } } + VerticalScrollBar( + scrollState = lazyListState, + modifier = Modifier.padding(top = QUEUE_TOP_FADE, bottom = QUEUE_BOTTOM_FADE), + ) } AppleMusicBottomCluster( diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicShared.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicShared.kt index ce80a25997..e45d14ff51 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicShared.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/screen/player/content/applemusic/AppleMusicShared.kt @@ -110,6 +110,7 @@ import com.maxrave.simpmusic.ui.icon.VolumeDown import com.maxrave.simpmusic.ui.icon.VolumeUp import com.maxrave.simpmusic.ui.screen.player.content.NowPlayingContentActions import com.maxrave.simpmusic.ui.screen.player.content.NowPlayingContentState +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.UIEvent import org.jetbrains.compose.resources.stringResource @@ -434,7 +435,7 @@ internal fun AppleMusicCompactHeader( placeholder = rememberHolderPainter(), error = rememberHolderPainter(), contentDescription = null, - modifier = Modifier.size(55.dp).clip(RoundedCornerShape(4.dp)), + modifier = Modifier.size(55.dp).clip(ArtworkShape), ) Spacer(modifier = Modifier.width(12.dp)) Column(modifier = Modifier.weight(1f)) { diff --git a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/theme/Theme.kt b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/theme/Theme.kt index 3cc8b92fa4..9a89e937d8 100644 --- a/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/theme/Theme.kt +++ b/composeApp/src/commonMain/kotlin/com/maxrave/simpmusic/ui/theme/Theme.kt @@ -1,6 +1,7 @@ package com.maxrave.simpmusic.ui.theme import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.ColorScheme import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi import androidx.compose.material3.LocalContentColor @@ -15,6 +16,7 @@ import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.Immutable import androidx.compose.runtime.staticCompositionLocalOf import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp import com.materialkolor.PaletteStyle import com.materialkolor.rememberDynamicColorScheme import com.maxrave.domain.manager.DataStoreManager @@ -54,6 +56,9 @@ private val LightAppColors = val LocalAppColors = staticCompositionLocalOf { DarkAppColors } +/** The one corner every rounded artwork takes — covers, thumbnails, sleeves — as Spotify's 4dp. */ +val ArtworkShape = RoundedCornerShape(4.dp) + /** True in dark theme. Provided by [AppTheme] so platform glass (blur/tint) can adapt reliably. */ val LocalIsDarkTheme = staticCompositionLocalOf { true } diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt index 69634ef759..7e217f18ff 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/DesktopApp.kt @@ -514,7 +514,7 @@ fun runDesktopApp(args: Array = emptyArray()) { onOpenDesktopNotificationSettings = desktopNotificationManager::openNotificationSettings, ) - LibrarySyncLoginPrompt() + LibrarySyncLoginPrompt(sharedViewModel) ToastHost() } } diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt index 9d3608807b..32dee017eb 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LibrarySync.jvm.kt @@ -33,11 +33,14 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.maxrave.domain.data.model.librarysync.LibrarySyncPairingState import com.maxrave.domain.data.model.librarysync.LibrarySyncProblem import com.maxrave.domain.data.model.librarysync.SyncPeer +import com.maxrave.domain.manager.DataStoreManager import com.maxrave.domain.repository.LibrarySyncHostRepository import com.maxrave.simpmusic.expect.openUrl import com.maxrave.simpmusic.ui.theme.AppTheme +import com.maxrave.simpmusic.ui.theme.parseThemeColorHex import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.LibrarySyncHostViewModel +import com.maxrave.simpmusic.viewModel.SharedViewModel import org.jetbrains.compose.resources.stringResource import org.koin.compose.koinInject import org.koin.compose.viewmodel.koinViewModel @@ -248,12 +251,19 @@ private fun WindowsPublicBox(problem: LibrarySyncProblem?) { * whole window, since the phone sends them whenever its user asks. */ @Composable -fun LibrarySyncLoginPrompt() { +fun LibrarySyncLoginPrompt(sharedViewModel: SharedViewModel) { val repository: LibrarySyncHostRepository = koinInject() val pending by repository.pendingLogins.collectAsStateWithLifecycle() val logins = pending ?: return - // Outside App(), so it brings a theme of its own: the app's default dark one. - AppTheme { + // Outside App(), so it applies the user's theme itself, read the way App() reads it. + val themeMode by sharedViewModel.getThemeMode().collectAsStateWithLifecycle(DataStoreManager.THEME_MODE_DARK) + val themeColorSource by sharedViewModel.getThemeColorSource().collectAsStateWithLifecycle(DataStoreManager.THEME_COLOR_DEFAULT) + val customThemeColorHex by sharedViewModel.getCustomThemeColor().collectAsStateWithLifecycle(DataStoreManager.DEFAULT_THEME_COLOR_HEX) + AppTheme( + themeMode = themeMode, + themeColorSource = themeColorSource, + customThemeColor = parseThemeColorHex(customThemeColorHex), + ) { AlertDialog( onDismissRequest = {}, title = { Text(text = stringResource(Res.string.library_sync_logins_title, logins.fromName), style = typo().titleSmall) }, diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt index 939716c939..184a620d9e 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/LoginSync.jvm.kt @@ -16,6 +16,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll import androidx.compose.material3.AlertDialog import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.LocalContentColor import androidx.compose.material3.RadioButton import androidx.compose.material3.Text import androidx.compose.material3.TextButton @@ -149,14 +150,17 @@ actual fun LoginSyncDialog(onDismiss: () -> Unit) { }, confirmButton = { TextButton(onClick = onDismiss) { - Text(text = stringResource(if (state is LoginSyncHostState.Done) Res.string.ok else Res.string.cancel)) + Text( + text = stringResource(if (state is LoginSyncHostState.Done) Res.string.ok else Res.string.cancel), + color = LocalContentColor.current, + ) } }, dismissButton = if (canRestart) { { TextButton(onClick = viewModel::open) { - Text(text = stringResource(Res.string.login_sync_new_code)) + Text(text = stringResource(Res.string.login_sync_new_code), color = LocalContentColor.current) } } } else { diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.jvm.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.jvm.kt index 7c6013a85a..a3c1d4fd0e 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/expect/ui/Scrollbar.jvm.kt @@ -2,12 +2,18 @@ package com.maxrave.simpmusic.expect.ui import androidx.compose.animation.core.animateFloatAsState import androidx.compose.foundation.HorizontalScrollbar +import androidx.compose.foundation.ScrollState import androidx.compose.foundation.ScrollbarStyle +import androidx.compose.foundation.VerticalScrollbar import androidx.compose.foundation.gestures.FlingBehavior import androidx.compose.foundation.gestures.Orientation import androidx.compose.foundation.gestures.ScrollableState import androidx.compose.foundation.interaction.DragInteraction import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.lazy.grid.LazyGridState import androidx.compose.foundation.rememberScrollbarAdapter @@ -22,6 +28,7 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.unit.dp @@ -165,3 +172,38 @@ actual fun HorizontalScrollBar( interactionSource = interactionSource, ) } + +/** One placement for every vertical overload: the bar on the right edge, 2dp in, over the whole height. */ +@Composable +private fun RightEdgeScrollbar( + adapter: ScrollbarAdapter, + modifier: Modifier, +) { + if (getPlatform() != Platform.Desktop) return + // A full-size Box with no pointer input of its own: presses and the wheel outside the bar fall through to the list. + Box(modifier = modifier.fillMaxSize(), contentAlignment = Alignment.TopEnd) { + VerticalScrollbar( + adapter = adapter, + modifier = Modifier.fillMaxHeight().padding(end = 2.dp), + style = scrollBarStyle, + ) + } +} + +@Composable +actual fun VerticalScrollBar( + scrollState: LazyListState, + modifier: Modifier, +) = RightEdgeScrollbar(rememberScrollbarAdapter(scrollState = scrollState), modifier) + +@Composable +actual fun VerticalScrollBar( + scrollState: LazyGridState, + modifier: Modifier, +) = RightEdgeScrollbar(rememberScrollbarAdapter(scrollState = scrollState), modifier) + +@Composable +actual fun VerticalScrollBar( + scrollState: ScrollState, + modifier: Modifier, +) = RightEdgeScrollbar(rememberScrollbarAdapter(scrollState = scrollState), modifier) diff --git a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/ui/mini_player/MiniPlayerLayout.kt b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/ui/mini_player/MiniPlayerLayout.kt index 4a1b439008..965d7da335 100644 --- a/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/ui/mini_player/MiniPlayerLayout.kt +++ b/composeApp/src/jvmMain/kotlin/com/maxrave/simpmusic/ui/mini_player/MiniPlayerLayout.kt @@ -75,6 +75,7 @@ import com.maxrave.simpmusic.ui.icon.SkipNext import com.maxrave.simpmusic.ui.icon.SkipPrevious import com.maxrave.simpmusic.ui.icon.VolumeOff import com.maxrave.simpmusic.ui.icon.VolumeUp +import com.maxrave.simpmusic.ui.theme.ArtworkShape import com.maxrave.simpmusic.ui.theme.typo import com.maxrave.simpmusic.viewModel.NowPlayingScreenData import com.maxrave.simpmusic.viewModel.UIEvent @@ -298,7 +299,7 @@ fun MediumMiniLayout( Modifier .size(48.dp) .scale(artworkScale) - .clip(RoundedCornerShape(6.dp)) + .clip(ArtworkShape) .hoverable(artworkInteractionSource), ) @@ -521,7 +522,7 @@ fun SquareMiniLayout( .weight(1f) .fillMaxWidth(0.85f) .scale(artworkScale) - .clip(RoundedCornerShape(12.dp)) + .clip(ArtworkShape) .hoverable(artworkInteractionSource), ) @@ -786,7 +787,7 @@ fun ExpandedMiniLayout( Modifier .size(64.dp) .scale(artworkScale) - .clip(RoundedCornerShape(8.dp)) + .clip(ArtworkShape) .hoverable(artworkInteractionSource), )