From d33f4b4896cdd51cebe539dcde0b5a400b7cf8b2 Mon Sep 17 00:00:00 2001 From: FX1922 <120828496+FX192@users.noreply.github.com> Date: Fri, 13 Nov 2026 16:49:48 +0300 Subject: [PATCH] feat: Add Soundtracks tab and music player (#2389) --- app/build.gradle | 2 + app/src/main/AndroidManifest.xml | 9 + .../droiddeck/launcher/FrontEndActivity.kt | 139 ++++++- .../launcher/frontend/AddedSoundtracks.kt | 69 ++++ .../launcher/frontend/GameRemoval.kt | 2 +- .../droiddeck/launcher/frontend/Library.kt | 23 +- .../droiddeck/launcher/frontend/Soundtrack.kt | 308 ++++++++++++++ .../frontend/SoundtrackCollectionArt.kt | 50 +++ .../frontend/SoundtrackCollections.kt | 191 +++++++++ .../launcher/frontend/SoundtrackIndex.kt | 32 ++ .../launcher/frontend/SoundtrackOrder.kt | 67 +++ .../launcher/frontend/SoundtrackShortcuts.kt | 41 ++ .../launcher/frontend/SoundtrackTracks.kt | 30 ++ .../launcher/frontend/SteamGameArt.kt | 6 +- .../launcher/playback/SoundtrackController.kt | 288 +++++++++++++ .../launcher/playback/SoundtrackService.kt | 282 +++++++++++++ .../launcher/playback/SoundtrackSettings.kt | 78 ++++ .../launcher/session/SessionPrefs.kt | 12 + .../launcher/session/SettingsReset.kt | 2 +- .../droiddeck/launcher/ui/AddedGameEditor.kt | 23 +- .../droiddeck/launcher/ui/FrontEndContent.kt | 9 +- .../com/droiddeck/launcher/ui/FrontEndRail.kt | 2 + .../droiddeck/launcher/ui/FrontEndScreen.kt | 22 +- .../droiddeck/launcher/ui/FrontEndSetup.kt | 2 + .../com/droiddeck/launcher/ui/GameDetail.kt | 14 +- .../com/droiddeck/launcher/ui/GameGlass.kt | 8 +- .../com/droiddeck/launcher/ui/LibraryPage.kt | 155 +++++-- .../launcher/ui/SoundtrackCollectionsUi.kt | 295 +++++++++++++ .../droiddeck/launcher/ui/SoundtrackDetail.kt | 391 ++++++++++++++++++ .../droiddeck/launcher/ui/SoundtrackIcon.kt | 15 + .../launcher/ui/SoundtrackOptions.kt | 217 ++++++++++ .../launcher/ui/SoundtrackTrackPanel.kt | 391 ++++++++++++++++++ .../com/droiddeck/launcher/ui/StoreChips.kt | 10 +- app/src/main/res/drawable/ic_repeat_all.xml | 10 + app/src/main/res/drawable/ic_repeat_off.xml | 11 + app/src/main/res/drawable/ic_repeat_one.xml | 10 + app/src/main/res/drawable/ic_shuffle_off.xml | 11 + app/src/main/res/drawable/ic_shuffle_on.xml | 10 + app/src/main/res/drawable/ic_soundtrack.xml | 10 + app/src/main/res/values-ar/strings.xml | 63 +++ app/src/main/res/values-b+es+419/strings.xml | 63 +++ app/src/main/res/values-bg/strings.xml | 63 +++ app/src/main/res/values-cs/strings.xml | 63 +++ app/src/main/res/values-da/strings.xml | 63 +++ app/src/main/res/values-de/strings.xml | 63 +++ app/src/main/res/values-el/strings.xml | 63 +++ app/src/main/res/values-es/strings.xml | 63 +++ app/src/main/res/values-fi/strings.xml | 63 +++ app/src/main/res/values-fr/strings.xml | 63 +++ app/src/main/res/values-hi/strings.xml | 63 +++ app/src/main/res/values-hu/strings.xml | 63 +++ app/src/main/res/values-in/strings.xml | 63 +++ app/src/main/res/values-it/strings.xml | 63 +++ app/src/main/res/values-ja/strings.xml | 63 +++ app/src/main/res/values-ko/strings.xml | 63 +++ app/src/main/res/values-ms/strings.xml | 63 +++ app/src/main/res/values-nb/strings.xml | 63 +++ app/src/main/res/values-nl/strings.xml | 63 +++ app/src/main/res/values-pl/strings.xml | 63 +++ app/src/main/res/values-pt-rPT/strings.xml | 63 +++ app/src/main/res/values-pt/strings.xml | 63 +++ app/src/main/res/values-ro/strings.xml | 63 +++ app/src/main/res/values-ru/strings.xml | 63 +++ app/src/main/res/values-sv/strings.xml | 63 +++ app/src/main/res/values-th/strings.xml | 63 +++ app/src/main/res/values-tr/strings.xml | 63 +++ app/src/main/res/values-uk/strings.xml | 63 +++ app/src/main/res/values-vi/strings.xml | 63 +++ app/src/main/res/values-zh-rCN/strings.xml | 63 +++ app/src/main/res/values-zh-rHK/strings.xml | 63 +++ app/src/main/res/values-zh-rTW/strings.xml | 63 +++ app/src/main/res/values/strings.xml | 64 +++ .../frontend/SoundtrackCollectionsTest.kt | 43 ++ .../launcher/frontend/SoundtrackOrderTest.kt | 34 ++ .../launcher/frontend/SoundtrackTest.kt | 151 +++++++ .../launcher/frontend/SoundtrackTracksTest.kt | 29 ++ .../droiddeck/launcher/ui/DragTargetTest.kt | 20 + docs/development/soundtracks.md | 78 ++++ 78 files changed, 5618 insertions(+), 64 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/AddedSoundtracks.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/Soundtrack.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollectionArt.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollections.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackIndex.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackOrder.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackShortcuts.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackTracks.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/playback/SoundtrackController.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/playback/SoundtrackService.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/playback/SoundtrackSettings.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/SoundtrackCollectionsUi.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/SoundtrackDetail.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/SoundtrackIcon.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/SoundtrackOptions.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/SoundtrackTrackPanel.kt create mode 100644 app/src/main/res/drawable/ic_repeat_all.xml create mode 100644 app/src/main/res/drawable/ic_repeat_off.xml create mode 100644 app/src/main/res/drawable/ic_repeat_one.xml create mode 100644 app/src/main/res/drawable/ic_shuffle_off.xml create mode 100644 app/src/main/res/drawable/ic_shuffle_on.xml create mode 100644 app/src/main/res/drawable/ic_soundtrack.xml create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackCollectionsTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackOrderTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTracksTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/ui/DragTargetTest.kt create mode 100644 docs/development/soundtracks.md diff --git a/app/build.gradle b/app/build.gradle index 57b14a87fc..bb0b7132e5 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -400,6 +400,8 @@ dependencies { exclude group: 'com.google.auto.value', module: 'auto-value' } implementation 'com.google.zxing:core:3.5.3' + implementation 'androidx.media3:media3-exoplayer:1.3.1' + implementation 'androidx.media3:media3-session:1.3.1' testImplementation 'junit:junit:4.13.2' testImplementation 'org.robolectric:robolectric:4.16.1' diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 80c9312fe6..1264c8211a 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -141,6 +141,7 @@ + @@ -334,6 +335,14 @@ android:name=".sync.SyncthingService" android:exported="false" android:foregroundServiceType="dataSync" /> + + + + + >(emptyList()) + private var soundtracksLoaded by mutableStateOf(false) private var gameStoresSpeedTier by mutableStateOf("fast") private var navRequest by mutableStateOf(null) private val gameLaunchRequest = java.util.concurrent.atomic.AtomicLong() @@ -785,6 +789,11 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private var shortcutPicker by mutableStateOf(false) private var shortcutLibraryScanning by mutableStateOf(false) @Volatile private var libraryScanGeneration = 0 + private class SoundtrackRemoval(val op: Int, var scan: Int, var settled: Boolean) + private val soundtrackRemovals = HashMap() + private var soundtrackOp = 0 + private var soundtrackAddScan = -1 + private val soundtrackWork = java.util.concurrent.Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-work").apply { isDaemon = true } } @Volatile private var lastComponentRestore = 0L @Volatile private var componentRestoreRetry = false private val componentRestoreLock = Any() @@ -847,6 +856,15 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet pendingGameLink = null gameLinkReading = false gameLinkTried = false + soundtrackLaunch = false + val soundtrackId = com.droiddeck.launcher.frontend.SoundtrackShortcuts.read(request) + if (soundtrackId != null) { + soundtrackLaunch = true + navRequest = if (SessionPrefs.soundtracksEnabled(this)) "sound:$soundtrackId" else "app:$soundtrackId" + request.data = null + request.action = Intent.ACTION_MAIN + return + } if (GameLaunchIntent.accepts(request.action)) { gameLinkReading = true com.droiddeck.launcher.ui.DualScreenPanel.hide(taskId) @@ -871,6 +889,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet } private fun launchGame(game: Library.SteamGame, returnHome: Boolean = false): Boolean { + if (!SessionPrefs.soundtracksIngame(this)) com.droiddeck.launcher.playback.SoundtrackController.pause(this) if (pkgStage != null) { android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show() return false @@ -1144,6 +1163,8 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet LauncherIcon.repair(this, intent?.component) launcherIcon = LauncherIcon.current(this) gameStoresEnabled = SessionPrefs.gameStoresEnabled(this) + soundtracksEnabled = SessionPrefs.soundtracksEnabled(this) + soundtracksIngame = SessionPrefs.soundtracksIngame(this) gameStoresSpeedTier = SessionPrefs.gameStoresSpeedTier(this) storesShowMature = SessionPrefs.storesShowMature(this) storesSort = SessionPrefs.storesSort(this) @@ -1239,6 +1260,10 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet lowStorageWarning = lowStorageWarning, launcherIcon = launcherIcon, gameStoresEnabled = gameStoresEnabled, + soundtracksEnabled = soundtracksEnabled, + soundtracksIngame = soundtracksIngame, + soundtracks = soundtracks, + soundtracksLoaded = soundtracksLoaded, gameStoresSpeedTier = gameStoresSpeedTier, navigate = navRequest, addedGamesArt = addedGamesArt, @@ -1287,7 +1312,10 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet }, onEpicLauncher = { openEpicLauncher() }, onUninstallEpicLauncher = { uninstallEpicLauncher() }, - onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) }, + onGameShortcut = { g -> + if (g.soundtrack) com.droiddeck.launcher.frontend.SoundtrackShortcuts.pin(this, g) + else com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) + }, onExportGameFile = { g -> pickGameExport(g) }, onSyncGameFiles = { pickGameExport(null) }, onAddGameExe = { path -> addGameExe(path) }, @@ -1312,8 +1340,9 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet }, "game-file-stop-sync").start() }, onCopyGameLink = { g -> - (getSystemService(CLIPBOARD_SERVICE) as ClipboardManager).setPrimaryClip( - ClipData.newPlainText(g.name, com.droiddeck.launcher.frontend.GameLaunchLink.uri(g.gameIdString))) + val link = if (g.soundtrack) com.droiddeck.launcher.frontend.SoundtrackShortcuts.uri(g.appId) + else com.droiddeck.launcher.frontend.GameLaunchLink.uri(g.gameIdString) + (getSystemService(CLIPBOARD_SERVICE) as ClipboardManager).setPrimaryClip(ClipData.newPlainText(g.name, link)) android.widget.Toast.makeText(this, R.string.game_link_copied, android.widget.Toast.LENGTH_SHORT).show() }, onDesktop = { @@ -1338,6 +1367,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet }, onRom = { g -> val e = emulatorList.first { it.id == g.emulatorId } + if (!SessionPrefs.soundtracksIngame(this)) com.droiddeck.launcher.playback.SoundtrackController.pause(this) startActivity(Intent(this, SessionActivity::class.java) .putExtra(SessionService.EXTRA_MODE, SessionService.MODE_RUN) .putExtra(SessionService.EXTRA_PROGRAM, e.program) @@ -1506,6 +1536,15 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet }, onPageBack = { showPerformance = false; showComponents = false; showMapping = false }, onGameStoresEnabled = { on -> SessionPrefs.setGameStoresEnabled(this, on); gameStoresEnabled = on }, + onSoundtracksEnabled = { on -> SessionPrefs.setSoundtracksEnabled(this, on); soundtracksEnabled = on }, + onSoundtracksIngame = { on -> + SessionPrefs.setSoundtracksIngame(this, on) + soundtracksIngame = on + com.droiddeck.launcher.playback.SoundtrackController.setIngame(this, on) + }, + onSoundtrackAdded = { folder -> addSoundtrack(folder) }, + onSoundtracksChanged = { refreshAddedSoundtracks() }, + onSoundtrackRemoved = { g -> removeSoundtrack(g) }, onTheme = { id -> SessionPrefs.setTheme(this, id); theme = id }, onLauncherIcon = { style -> switchLauncherIcon(style) }, onLanguage = { tag -> @@ -1799,7 +1838,10 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet startSteamAtStartupIfEnabled() } + private var soundtrackLaunch = false + private fun startSteamAtStartupIfEnabled(cold: Boolean = false) { + if (soundtrackLaunch) return if (intent.action != Intent.ACTION_MAIN && !(cold && intent.action == null)) return if (isFinishing || isDestroyed) return when (SessionPrefs.startupSession(this)) { @@ -2644,15 +2686,89 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet val version = (steamArtRefreshes[appId] ?: 0) + 1 steamArtRefreshes[appId] = version Thread({ - val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this).firstOrNull { it.appId == appId } ?: return@Thread + val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this, soundtracks = true).firstOrNull { it.appId == appId } ?: return@Thread ui.post { if (steamArtRefreshes[appId] != version) return@post - steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it } + if (fresh.soundtrack) soundtracks = soundtracks.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it } + else steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it } } }, "steam-art-update").start() } + private fun addSoundtrack(folder: java.io.File) { + val op = ++soundtrackOp + soundtrackAddScan = libraryScanGeneration + soundtrackWork.execute { + val added = com.droiddeck.launcher.frontend.AddedSoundtracks.add(this, folder) + val list = com.droiddeck.launcher.frontend.AddedSoundtracks.games(this) + ui.post { + if (added) { + soundtrackRemovals[folder.path]?.takeIf { it.op < op }?.let { + soundtrackRemovals.remove(folder.path) + com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(folder.path)) + } + val visible = list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] }?.let { it.op > op } == true } + soundtracks = soundtracks.filter { it.library != Library.ADDED } + visible + } else android.widget.Toast.makeText(this, R.string.soundtracks_add_empty, android.widget.Toast.LENGTH_SHORT).show() + } + } + } + + private fun refreshAddedSoundtracks() { + val op = soundtrackOp + soundtrackWork.execute { + val list = com.droiddeck.launcher.frontend.AddedSoundtracks.games(this) + ui.post { + if (op != soundtrackOp) return@post + val visible = list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] } != null } + soundtracks = soundtracks.filter { it.library != Library.ADDED } + visible + } + } + } + + private fun removeSoundtrack(g: Library.SteamGame) { + val path = g.gameFiles?.path + val added = g.library == Library.ADDED + val target = if (added) null else com.droiddeck.launcher.frontend.GameRemoval.steamFiles(g) ?: return + com.droiddeck.launcher.playback.SoundtrackController.stopIf(this, g.gameFiles) + val marker = SoundtrackRemoval(++soundtrackOp, libraryScanGeneration, added) + path?.let { soundtrackRemovals[it] = marker } + if (target == null) { + soundtracks = soundtracks.filterNot { it.appId == g.appId && it.library == Library.ADDED } + soundtrackWork.execute { + val removed = com.droiddeck.launcher.frontend.AddedSoundtracks.remove(this, path.orEmpty()) + val list = if (removed) emptyList() else com.droiddeck.launcher.frontend.AddedSoundtracks.games(this) + if (!removed) ui.post { + if (path != null && soundtrackRemovals[path] === marker) { + soundtrackRemovals.remove(path) + com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(path)) + } + soundtracks = soundtracks.filter { it.library != Library.ADDED } + list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] } != null } + android.widget.Toast.makeText(this, getString(R.string.gfiles_remove_failed, g.name), android.widget.Toast.LENGTH_SHORT).show() + } + } + return + } + soundtrackWork.execute { + val deleted = com.droiddeck.launcher.frontend.GameRemoval.delete(target) + ui.post { + if (deleted) { + marker.scan = libraryScanGeneration + marker.settled = true + } else { + if (path != null && soundtrackRemovals[path] === marker) { + soundtrackRemovals.remove(path) + com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(path)) + } + android.widget.Toast.makeText(this, getString(R.string.gfiles_remove_failed, g.name), android.widget.Toast.LENGTH_SHORT).show() + } + refresh() + } + } + } + private fun removeGame(g: Library.SteamGame) { + if (g.soundtrack) { removeSoundtrack(g); return } val folder = g.gameFiles ?: return when (com.droiddeck.launcher.frontend.GameRemoval.kind(g)) { com.droiddeck.launcher.frontend.GameRemoval.Kind.LAUNCHER -> Unit @@ -2936,6 +3052,19 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet } val scannedArch = SessionPrefs.activeSteamClientArch(this) val scannedX64 = scannedArch == "x86_64" + val scannedSoundtracks = runCatching { + (if (ready || com.droiddeck.launcher.runtime.LinuxRuntime.hasRootfs(this)) Library.soundtracks(this, scannedArch) else emptyList()) + + com.droiddeck.launcher.frontend.AddedSoundtracks.games(this) + }.getOrDefault(emptyList()) + ui.post { + if (scanGeneration == libraryScanGeneration) { + val scanned = if (scanGeneration <= soundtrackAddScan) scannedSoundtracks + soundtracks.filter { cur -> cur.library == Library.ADDED && scannedSoundtracks.none { it.library == Library.ADDED && it.appId == cur.appId } } else scannedSoundtracks + val kept = scanned.filterNot { s -> s.gameFiles?.path?.let { p -> soundtrackRemovals[p]?.let { m -> !m.settled || s.library == Library.ADDED || scanGeneration <= m.scan } } == true } + com.droiddeck.launcher.playback.SoundtrackController.allow(kept.mapNotNull { it.gameFiles?.path }) + soundtracks = kept + soundtracksLoaded = true + } + } val games = if (ready || com.droiddeck.launcher.runtime.LinuxRuntime.hasRootfs(this)) Library.launchableGames(this, arch = scannedArch) else emptyList() val all = games.distinctBy { it.gameId } if (ready && scanGeneration == libraryScanGeneration) com.droiddeck.launcher.frontend.LibraryCache.save(this, all, scannedX64) diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedSoundtracks.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedSoundtracks.kt new file mode 100644 index 0000000000..635941cb7a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedSoundtracks.kt @@ -0,0 +1,69 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context +import org.json.JSONArray +import org.json.JSONObject +import java.io.File + +object AddedSoundtracks { + private fun file(context: Context) = File(context.filesDir, "added-soundtracks.json") + + class Entry(val path: String, val name: String, val id: Int = 0) + + internal fun assignIds(list: List): List { + val used = list.filter { it.id != 0 }.map { it.id }.toMutableSet() + return list.map { e -> + if (e.id != 0) e else { + var id = idOf(e.path) + while (id == 0 || !used.add(id)) id = (id + 1) or Int.MIN_VALUE + Entry(e.path, e.name, id) + } + } + } + + @Synchronized + fun entries(context: Context): List = runCatching { + val f = file(context).takeIf { it.isFile } ?: return emptyList() + val array = JSONArray(f.readText()) + val raw = List(array.length()) { i -> array.getJSONObject(i).let { Entry(it.getString("path"), it.getString("name"), it.optInt("id", 0)) } } + val ready = assignIds(raw) + if (raw.any { it.id == 0 }) save(context, ready) + ready + }.getOrDefault(emptyList()) + + @Synchronized + private fun save(context: Context, list: List): Boolean = + runCatching { + val array = JSONArray() + list.forEach { array.put(JSONObject().put("path", it.path).put("name", it.name).put("id", it.id)) } + val f = file(context) + val tmp = File(f.path + ".tmp") + tmp.writeText(array.toString()) + if (tmp.renameTo(f)) true else { tmp.delete(); false } + }.getOrDefault(false) + + fun add(context: Context, folder: File): Boolean { + if (!folder.isDirectory || Soundtrack.audioFiles(folder).isEmpty()) return false + return synchronized(this) { + val list = entries(context) + list.any { it.path == folder.path } || save(context, assignIds(list + Entry(folder.path, folder.name))) + } + } + + fun remove(context: Context, path: String): Boolean = + synchronized(this) { save(context, entries(context).filterNot { it.path == path }) } + + internal fun idOf(path: String): Int = path.hashCode() or Int.MIN_VALUE + + fun games(context: Context): List = entries(context).mapNotNull { e -> + val dir = File(e.path).takeIf { it.isDirectory } ?: return@mapNotNull null + game(context, e, dir, e.id) + } + + private fun game(context: Context, e: Entry, dir: File, id: Int): Library.SteamGame { + return Library.SteamGame( + appId = id, name = e.name, art = SoundtrackCollectionArt.chosen(context, id) ?: Soundtrack.firstCover(context, dir), library = Library.ADDED, gameId = id.toLong() and 0xFFFFFFFFL, + gameFiles = dir, source = Library.ADDED, soundtrack = true, + ) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/GameRemoval.kt b/app/src/main/java/com/droiddeck/launcher/frontend/GameRemoval.kt index 388448e184..a35c71342b 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/GameRemoval.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/GameRemoval.kt @@ -21,7 +21,7 @@ object GameRemoval { fun steamFiles(game: Library.SteamGame): SteamFiles? { val dir = game.gameFiles ?: return null val common = dir.parentFile ?: return null - if (common.name != "common") return null + if (common.name != (if (game.soundtrack) "music" else "common")) return null val steamapps = common.parentFile ?: return null if (steamapps.name != "steamapps") return null val manifest = File(steamapps, "appmanifest_${game.appId}.acf") diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt index 99732653b6..8acbbe18b0 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt @@ -19,9 +19,10 @@ object Library { val storeId: String? = null, val logo: File? = null, val installedAt: Long = 0L, + val soundtrack: Boolean = false, ) { fun withArt(art: File?, hero: File?, icon: File?, logo: File? = this.logo) = - SteamGame(appId, name, art, library, gameId, hero, lastPlayed, gameFiles, protonPrefix, icon, source, storeId, logo, installedAt) + SteamGame(appId, name, art, library, gameId, hero, lastPlayed, gameFiles, protonPrefix, icon, source, storeId, logo, installedAt, soundtrack) val gameIdString: String get() = java.lang.Long.toUnsignedString(gameId) val launchKey: String get() = if (storeId != null) "$source:$storeId" else gameIdString @@ -38,6 +39,7 @@ object Library { const val BATTLENET_LAUNCHER = "battlenet-launcher" const val XBOX_CLOUD = "xbox-cloud" const val SOURCE_STEAM = "steam" + const val SOURCE_COLLECTION = "collection" class Rom(val name: String, val hostPath: File, val guestPath: String, val emulatorId: String, val art: File? = null) class Emulator(val id: String, val name: String, val system: String, val program: String, val installed: Boolean, val games: List) { @@ -123,9 +125,12 @@ object Library { .distinctBy { runCatching { it.canonicalPath }.getOrDefault(it.absolutePath) } } + fun soundtracks(context: Context, arch: String = SessionPrefs.activeSteamClientArch(context)): List = + steamGames(context, arch = arch, withShared = false, soundtracks = true, soundtracksOnly = true) + fun steamGames( context: Context, strictRead: Boolean = false, arch: String = SessionPrefs.activeSteamClientArch(context), - withShared: Boolean = true, + withShared: Boolean = true, soundtracks: Boolean = false, soundtracksOnly: Boolean = false, onlyAppIds: Set? = null, ): List { val root = SessionPrefs.steamRoot(context, arch) @@ -146,16 +151,19 @@ object Library { val name = NAME.find(text)?.groupValues?.get(1)?.trim().orEmpty() val flags = STATE.find(text)?.groupValues?.get(1)?.toIntOrNull() ?: 0 if (name.isEmpty() || flags and 4 == 0) return@forEach + val installDir = INSTALL_DIR.find(text)?.groupValues?.get(1)?.trim() + ?.takeIf { it.isNotEmpty() && it != "." && it != ".." && '/' !in it && '\\' !in it } + val gameFiles = installDir?.let { File(steamapps, "common/$it").takeIf(File::isDirectory) } + val musicFiles = if (gameFiles == null) installDir?.let { File(steamapps, "music/$it").takeIf(File::isDirectory) } else null + if (musicFiles != null && !soundtracks) return@forEach + if (soundtracksOnly && musicFiles == null) return@forEach val images = SteamCacheImages(File(cache, appId.toString())) val art = images.find(STEAM_CAPSULES) val hero = images.find(STEAM_HEROES) val lastPlayed = LAST_PLAYED.find(text)?.groupValues?.get(1)?.toLongOrNull() ?: 0L - val installDir = INSTALL_DIR.find(text)?.groupValues?.get(1)?.trim() - ?.takeIf { it.isNotEmpty() && it != "." && it != ".." && '/' !in it && '\\' !in it } - val gameFiles = installDir?.let { File(steamapps, "common/$it").takeIf(File::isDirectory) } out[appId] = SteamGameArt.withOverrides(context, SteamGame( - appId, name, art, label, hero = hero, lastPlayed = lastPlayed, - gameFiles = gameFiles, + appId, name, art ?: musicFiles?.let { Soundtrack.firstCover(context, it) }, label, hero = hero, lastPlayed = lastPlayed, + gameFiles = gameFiles ?: musicFiles, soundtrack = musicFiles != null, protonPrefix = protonPrefix(context, appId.toLong(), library, roots), icon = images.icon(), logo = images.find(STEAM_LOGOS), @@ -177,6 +185,7 @@ object Library { strictRead = strictRead, arch = other, withShared = false, + soundtracks = soundtracks, onlyAppIds = shared, ) } catch (e: Exception) { diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/Soundtrack.kt b/app/src/main/java/com/droiddeck/launcher/frontend/Soundtrack.kt new file mode 100644 index 0000000000..7f66f20962 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/Soundtrack.kt @@ -0,0 +1,308 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context +import android.media.MediaMetadataRetriever +import org.json.JSONArray +import org.json.JSONObject +import java.io.File + +object Soundtrack { + class Track( + val file: File, val title: String, val disc: Int, val number: Int, val durationMs: Long, val artist: String = "", + val discLabel: String = disc.toString(), + ) { + val id: String get() = file.path + } + + class Album(val disc: Map>, val artist: String, val cover: File?) { + val tracks: List get() = disc.values.flatten() + val discs: List get() = disc.keys.toList() + val multiDisc: Boolean get() = disc.size > 1 + val totalMs: Long get() = tracks.sumOf { it.durationMs } + } + + class Raw( + val file: File, val folder: String, val tagDisc: Int?, val tagTrack: Int?, val tagTitle: String?, val tagArtist: String?, + val durationMs: Long, val size: Long = file.length(), + ) + + val EXTENSIONS = setOf("mp3", "flac", "ogg", "oga", "opus", "wav", "m4a", "aac") + private val LOSSLESS = setOf("flac", "wav") + private val COVERS = listOf("AlbumArtwork", "albumartwork", "cover", "Cover", "folder", "Folder", "front", "Front", "artwork", "Artwork") + internal val COVER_EXT = listOf("png", "jpg", "jpeg", "webp") + private val LEADING = Regex("^\\s*\\d+\\s*[.\\-_)]*\\s+") + private val DIGITS = Regex("^\\s*(\\d+)") + + fun isAudio(file: File): Boolean = file.isFile && file.extension.lowercase() in EXTENSIONS + + fun cleanTitle(fileName: String): String { + val base = fileName.substringBeforeLast('.', fileName).trim() + val tail = if (" - " in base) base.substringAfterLast(" - ") else base + val stripped = tail.replace(LEADING, "").trim() + return stripped.ifEmpty { tail.ifEmpty { base } } + } + + internal fun leadingNumber(fileName: String): Int? = DIGITS.find(fileName.substringAfterLast(" - "))?.groupValues?.get(1)?.toIntOrNull() + + private fun identity(r: Raw): String { + val d = r.tagDisc + val t = r.tagTrack + if (d != null && t != null) return "n:$d:$t" + val title = (r.tagTitle?.takeIf { it.isNotBlank() } ?: cleanTitle(r.file.name)).lowercase().filter { it.isLetterOrDigit() } + return "t:$title:${leadingNumber(r.file.name)}" + } + + private fun better(a: Raw, b: Raw): Raw { + val la = a.file.extension.lowercase() in LOSSLESS + val lb = b.file.extension.lowercase() in LOSSLESS + return when { + la != lb -> if (la) a else b + a.size != b.size -> if (a.size > b.size) a else b + else -> if (a.file.path <= b.file.path) a else b + } + } + + fun group(raws: List): Map> { + if (raws.isEmpty()) return emptyMap() + val unique = LinkedHashMap() + val home = HashMap() + val disc = HashMap() + val track = HashMap() + val title = HashMap() + for (r in raws) { + val id = identity(r) + unique[id] = unique[id]?.let { better(it, r) } ?: r + if (r.folder.isNotEmpty() && home[id].isNullOrEmpty()) home[id] = r.folder + r.tagDisc?.let { disc.putIfAbsent(id, it) } + r.tagTrack?.let { track.putIfAbsent(id, it) } + r.tagTitle?.takeIf { it.isNotBlank() }?.let { title.putIfAbsent(id, it) } + } + val kept = unique.map { (id, r) -> + Raw( + r.file, home[id] ?: r.folder, disc[id] ?: r.tagDisc, track[id] ?: r.tagTrack, title[id] ?: r.tagTitle, r.tagArtist, + r.durationMs, r.size, + ) + } + val folders = kept.filter { it.tagDisc == null }.map { it.folder }.distinct().sortedWith(naturalOrder) + val discs = kept.groupBy { r -> + r.tagDisc ?: if (folders.size <= 1 && kept.none { it.tagDisc != null }) 0 else folders.indexOf(r.folder) + 1 + } + return discs.toSortedMap().mapValues { (disc, list) -> + list.sortedWith( + compareBy({ leadingNumber(it.file.name) ?: it.tagTrack ?: Int.MAX_VALUE }, { it.tagTrack ?: Int.MAX_VALUE }, { it.file.name.lowercase() }), + ).mapIndexed { i, r -> + Track( + r.file, r.tagTitle?.takeIf { it.isNotBlank() } ?: cleanTitle(r.file.name), disc, i + 1, + r.durationMs, r.tagArtist.orEmpty(), labelOf(r, disc), + ) + } + } + } + + private val FOLDER_LABEL = Regex("[0-9][0-9 +&,.\\-]*") + + private fun labelOf(r: Raw, disc: Int): String { + if (r.tagDisc != null) return disc.toString() + val name = r.folder.substringAfterLast('/') + return if (FOLDER_LABEL.matches(name)) name else disc.toString() + } + + private val naturalOrder = Comparator { a, b -> + val x = Regex("\\d+|\\D+").findAll(a.lowercase()).map { it.value }.toList() + val y = Regex("\\d+|\\D+").findAll(b.lowercase()).map { it.value }.toList() + var i = 0 + var out = 0 + while (out == 0 && i < minOf(x.size, y.size)) { + val nx = x[i].toBigIntegerOrNull() + val ny = y[i].toBigIntegerOrNull() + out = if (nx != null && ny != null) nx.compareTo(ny) else x[i].compareTo(y[i]) + i++ + } + if (out != 0) out else x.size.compareTo(y.size) + } + + fun cover(dir: File): File? { + for (name in COVERS) for (ext in COVER_EXT) File(dir, "$name.$ext").takeIf { it.isFile }?.let { return it } + return dir.listFiles()?.filter { it.isFile && it.extension.lowercase() in COVER_EXT }?.minByOrNull { it.name.lowercase() } + } + + private fun parseNumber(value: String?): Int? = value?.substringBefore('/')?.trim()?.toIntOrNull() + + private fun read(file: File, root: File): Raw { + val folder = file.parentFile?.let { parent -> + if (parent.path == root.path) "" else parent.path.removePrefix(root.path).trimStart('/') + }.orEmpty() + val retriever = MediaMetadataRetriever() + return try { + retriever.setDataSource(file.path) + Raw( + file, folder, + parseNumber(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DISC_NUMBER)), + parseNumber(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER)), + retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE), + retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST) + ?: retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST), + retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0L, + ) + } catch (e: Exception) { + Raw(file, folder, null, null, null, null, 0L) + } finally { + runCatching { retriever.release() } + } + } + + private fun cacheFile(context: Context, root: File) = File(context.filesDir, "soundtrack-index/${root.path.hashCode().toUInt()}.json") + + private fun fromCache(context: Context, root: File, files: List): List? = runCatching { + val f = cacheFile(context, root).takeIf { it.isFile } ?: return null + val json = JSONObject(f.readText()) + if (json.optString("root") != root.path) return null + val rows = json.getJSONArray("rows") + val byPath = HashMap() + for (i in 0 until rows.length()) rows.getJSONObject(i).let { byPath[it.getString("p")] = it } + if (byPath.size != files.size) return null + files.map { file -> + val row = byPath[file.path] ?: return null + if (row.getLong("s") != file.length() || row.getLong("m") != file.lastModified()) return null + Raw( + file, row.getString("f"), row.optInt("d", -1).takeIf { it >= 0 }, row.optInt("n", -1).takeIf { it >= 0 }, + row.optString("t").takeIf { it.isNotEmpty() }, row.optString("a").takeIf { it.isNotEmpty() }, row.optLong("l"), + ) + } + }.getOrNull() + + private fun toCache(context: Context, root: File, raws: List) { + runCatching { + val rows = JSONArray() + for (r in raws) rows.put( + JSONObject().put("p", r.file.path).put("s", r.file.length()).put("m", r.file.lastModified()).put("f", r.folder) + .put("d", r.tagDisc ?: -1).put("n", r.tagTrack ?: -1).put("t", r.tagTitle.orEmpty()).put("a", r.tagArtist.orEmpty()) + .put("l", r.durationMs), + ) + val f = cacheFile(context, root) + f.parentFile?.mkdirs() + val tmp = File(f.path + ".tmp") + tmp.writeText(JSONObject().put("root", root.path).put("rows", rows).toString()) + if (!tmp.renameTo(f)) tmp.delete() + } + } + + fun audioFiles(root: File): List { + val out = ArrayList() + fun walk(dir: File, depth: Int) { + val children = dir.listFiles() ?: return + for (c in children.sortedBy { it.name.lowercase() }) { + if (c.isDirectory) { if (depth < 4) walk(c, depth + 1) } else if (isAudio(c)) out += c + } + } + walk(root, 0) + return out + } + + private fun coverCache(context: Context, root: File): File { + val digest = java.security.MessageDigest.getInstance("SHA-256").digest(root.path.toByteArray(Charsets.UTF_8)) + val key = digest.take(16).joinToString("") { "%02x".format(it) } + return File(context.filesDir, "soundtrack-index/cover-$key.jpg") + } + + fun cachedCover(context: Context, root: File): File? = coverCache(context, root).takeIf { it.isFile && it.length() > 0L } + + private fun embeddedBytes(file: File): ByteArray? = runCatching { + val retriever = MediaMetadataRetriever() + try { + retriever.setDataSource(file.path) + retriever.embeddedPicture + } finally { + runCatching { retriever.release() } + } + }.getOrNull()?.takeIf { it.isNotEmpty() } + + private fun hashOf(bytes: ByteArray): String = + java.security.MessageDigest.getInstance("SHA-256").digest(bytes).take(16).joinToString("") { "%02x".format(it) } + + private fun embeddedCover(context: Context, root: File, files: List): File? { + cachedCover(context, root)?.let { return it } + val miss = File(coverCache(context, root).path + ".none") + val probed = files.take(8) + val signature = hashOf(probed.joinToString("\n") { "${it.path}|${it.length()}|${it.lastModified()}" }.toByteArray(Charsets.UTF_8)) + if (runCatching { miss.isFile && miss.readText().trim() == signature }.getOrDefault(false)) return null + for (file in probed) { + val bytes = embeddedBytes(file) ?: continue + val out = coverCache(context, root) + runCatching { + out.parentFile?.mkdirs() + out.writeBytes(bytes) + }.onSuccess { return out } + } + runCatching { + miss.parentFile?.mkdirs() + miss.writeText(signature) + } + return null + } + + fun firstCover(context: Context, root: File): File? = cover(root) ?: embeddedCover(context, root, audioFiles(root)) + + @Synchronized + fun trackCover(context: Context, file: File): File? { + val dir = File(context.filesDir, "soundtrack-index/track-covers") + val marker = File(dir, "t-" + hashOf("${file.path}|${file.length()}|${file.lastModified()}".toByteArray(Charsets.UTF_8))) + if (marker.isFile) { + val name = runCatching { marker.readText().trim() }.getOrDefault("") + if (name.isEmpty()) return null + File(dir, name).takeIf { it.isFile && it.length() > 0L }?.let { + val now = System.currentTimeMillis() + marker.setLastModified(now) + it.setLastModified(now) + return it + } + } + val bytes = embeddedBytes(file) + return runCatching { + dir.mkdirs() + if (bytes == null) { + marker.writeText("") + prune(dir, setOf(marker.name)) + null + } else { + val out = File(dir, "c-" + hashOf(bytes) + ".jpg") + if (!out.isFile || out.length() == 0L) out.writeBytes(bytes) + marker.writeText(out.name) + prune(dir, setOf(marker.name, out.name)) + out + } + }.getOrNull() + } + + private const val TRACK_COVER_BYTES = 64L * 1024 * 1024 + private const val TRACK_COVER_FILES = 2000 + + private fun prune(dir: File, keep: Set) { + val all = dir.listFiles()?.filter { it.isFile } ?: return + var bytes = all.sumOf { it.length() } + var count = all.size + for (f in all.sortedBy { it.lastModified() }) { + if (bytes <= TRACK_COVER_BYTES && count <= TRACK_COVER_FILES) break + if (f.name in keep) continue + bytes -= f.length() + count-- + f.delete() + } + } + + fun load(context: Context, root: File, coverHint: File? = null): Album { + val files = audioFiles(root) + val raws = fromCache(context, root, files) ?: files.map { read(it, root) }.also { toCache(context, root, it) } + val disc = SoundtrackOrder.apply(context, root, group(raws)) + val artist = disc.values.flatten().map { it.artist }.filter { it.isNotBlank() }.groupingBy { it }.eachCount().maxByOrNull { it.value }?.key.orEmpty() + return Album(disc, artist, coverHint ?: cover(root) ?: embeddedCover(context, root, files)) + } + + fun formatLength(ms: Long): String { + val total = ms / 1000 + val h = total / 3600 + val m = (total % 3600) / 60 + val s = total % 60 + return if (h > 0) "%d:%02d:%02d".format(h, m, s) else "%d:%02d".format(m, s) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollectionArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollectionArt.kt new file mode 100644 index 0000000000..44274fb55b --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollectionArt.kt @@ -0,0 +1,50 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context +import java.io.File + +object SoundtrackCollectionArt { + internal fun dir(context: Context, id: Int) = File(context.filesDir, "soundtrack-art/$id") + + private fun sourceFile(context: Context, id: Int) = File(dir(context, id), "source") + + fun chosen(context: Context, id: Int): File? = dir(context, id).takeIf { it.isDirectory }?.let { AddedGameArt.chosen(it, AddedGameArt.Slot.COVER) } + + fun source(context: Context, id: Int): String = + sourceFile(context, id).takeIf { it.isFile }?.readText()?.trim().orEmpty().substringAfter('|', "") + + fun options(context: Context, id: Int, root: File?): List { + val paths = if (root != null) { + val images = root.listFiles()?.filter { it.isFile && it.extension.lowercase() in Soundtrack.COVER_EXT }?.sortedBy { it.name.lowercase() }.orEmpty() + (images + listOfNotNull(Soundtrack.firstCover(context, root))).map { it.path } + } else SoundtrackCollections.tracksOf(id).map { it.cover } + return paths.filter { it.isNotEmpty() && File(it).isFile }.distinct().map { AddedGameArt.Option(AddedGameArt.FOLDER, it, it) } + } + + fun choose(context: Context, id: Int, option: AddedGameArt.Option): Boolean { + val folder = dir(context, id) + val fresh = AddedGameArt.storeNew(folder, AddedGameArt.Slot.COVER, option) ?: return false + AddedGameArt.dropOlder(folder, AddedGameArt.Slot.COVER, fresh) + sourceFile(context, id).writeText(option.group + "|" + option.full) + return true + } + + fun reset(context: Context, id: Int) { + chosen(context, id)?.delete() + sourceFile(context, id).delete() + } + + fun describe(context: Context, id: Int, root: File? = null): List { + val own = chosen(context, id) + val state = if (own != null) AddedGameArt.SlotState(AddedGameArt.Slot.COVER, own, AddedGameArt.FILE, true) + else { + val auto = if (root != null) Soundtrack.firstCover(context, root) else SoundtrackCollections.autoCover(id) + AddedGameArt.SlotState(AddedGameArt.Slot.COVER, auto, if (auto != null) AddedGameArt.FOLDER else AddedGameArt.AUTO, false) + } + return listOf(state) + } + + fun clear(context: Context, id: Int) { + dir(context, id).deleteRecursively() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollections.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollections.kt new file mode 100644 index 0000000000..d680ae0709 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackCollections.kt @@ -0,0 +1,191 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context +import androidx.compose.runtime.mutableStateOf +import org.json.JSONArray +import org.json.JSONObject +import java.io.File +import java.util.concurrent.Executors + +object SoundtrackCollections { + const val FAVORITES_ID = 2_000_000_000 + + class TrackRef(val path: String, val title: String, val artist: String, val album: String, val durationMs: Long, val cover: String = "") + class Collection(val id: Int, val name: String, val tracks: List) + class Snapshot(val favorites: List, val collections: List) + + private val state = mutableStateOf(Snapshot(emptyList(), emptyList())) + private var loaded = false + private val writer = Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-collections").apply { isDaemon = true } } + + val snapshot: Snapshot get() = state.value + + private fun file(context: Context) = File(context.filesDir, "soundtrack-collections.json") + + internal fun toggled(list: List, ref: TrackRef): List = + if (list.any { it.path == ref.path }) list.filterNot { it.path == ref.path } else list + ref + + internal fun merged(list: List, add: List): List { + val have = list.mapTo(HashSet()) { it.path } + return list + add.filter { have.add(it.path) } + } + + internal fun cleanName(raw: String): String = raw.trim().replace(Regex("\\s+"), " ") + + internal fun nameTaken(collections: List, name: String, except: Int? = null): Boolean = + collections.any { it.id != except && it.name.equals(name, ignoreCase = true) } + + internal fun nextId(collections: List): Int = + (collections.maxOfOrNull { it.id } ?: FAVORITES_ID).coerceAtLeast(FAVORITES_ID) + 1 + + private fun encode(s: Snapshot): String { + fun refs(list: List) = JSONArray().also { array -> + list.forEach { + array.put( + JSONObject().put("path", it.path).put("title", it.title).put("artist", it.artist).put("album", it.album) + .put("duration", it.durationMs).put("cover", it.cover), + ) + } + } + val collections = JSONArray() + s.collections.forEach { collections.put(JSONObject().put("id", it.id).put("name", it.name).put("tracks", refs(it.tracks))) } + return JSONObject().put("favorites", refs(s.favorites)).put("collections", collections).toString() + } + + private fun decode(text: String): Snapshot { + fun refs(array: JSONArray?): List = if (array == null) emptyList() else List(array.length()) { i -> + array.getJSONObject(i).let { + TrackRef(it.getString("path"), it.optString("title"), it.optString("artist"), it.optString("album"), it.optLong("duration"), it.optString("cover")) + } + } + val root = JSONObject(text) + val collections = root.optJSONArray("collections") + return Snapshot( + refs(root.optJSONArray("favorites")), + if (collections == null) emptyList() else List(collections.length()) { i -> + collections.getJSONObject(i).let { Collection(it.getInt("id"), it.getString("name"), refs(it.optJSONArray("tracks"))) } + }, + ) + } + + @Synchronized + fun load(context: Context) { + if (loaded) return + loaded = true + val f = file(context) + if (f.isFile) runCatching { state.value = decode(f.readText()) } + } + + private fun commit(context: Context, next: Snapshot) { + state.value = next + val f = file(context) + val json = encode(next) + writer.execute { + runCatching { + val tmp = File(f.path + ".tmp") + tmp.writeText(json) + if (!tmp.renameTo(f)) tmp.delete() + } + } + } + + fun tracksOf(id: Int): List = + if (id == FAVORITES_ID) snapshot.favorites else snapshot.collections.firstOrNull { it.id == id }?.tracks.orEmpty() + + fun isFavorite(path: String): Boolean = snapshot.favorites.any { it.path == path } + + @Synchronized + fun toggleFavorite(context: Context, ref: TrackRef) { + load(context) + val s = snapshot + commit(context, Snapshot(toggled(s.favorites, ref), s.collections)) + } + + @Synchronized + fun create(context: Context, rawName: String, tracks: List): Int? { + load(context) + val s = snapshot + val name = cleanName(rawName) + if (name.isEmpty() || nameTaken(s.collections, name)) return null + val id = nextId(s.collections) + commit(context, Snapshot(s.favorites, s.collections + Collection(id, name, merged(emptyList(), tracks)))) + return id + } + + @Synchronized + fun rename(context: Context, id: Int, rawName: String): Boolean { + load(context) + val s = snapshot + val name = cleanName(rawName) + if (id == FAVORITES_ID || name.isEmpty() || nameTaken(s.collections, name, id)) return false + commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, name, it.tracks) else it })) + return true + } + + @Synchronized + fun delete(context: Context, id: Int) { + load(context) + val s = snapshot + if (id == FAVORITES_ID) return + commit(context, Snapshot(s.favorites, s.collections.filterNot { it.id == id })) + SoundtrackCollectionArt.clear(context, id) + } + + @Synchronized + fun add(context: Context, id: Int, tracks: List) { + load(context) + val s = snapshot + if (id == FAVORITES_ID) commit(context, Snapshot(merged(s.favorites, tracks), s.collections)) + else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, merged(it.tracks, tracks)) else it })) + } + + @Synchronized + fun remove(context: Context, id: Int, paths: Set) { + load(context) + val s = snapshot + if (id == FAVORITES_ID) commit(context, Snapshot(s.favorites.filterNot { it.path in paths }, s.collections)) + else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, it.tracks.filterNot { t -> t.path in paths }) else it })) + } + + @Synchronized + fun reorder(context: Context, id: Int, ordered: List) { + load(context) + val s = snapshot + fun arrange(list: List): List { + val byPath = list.associateBy { it.path } + val placed = ordered.mapNotNull { byPath[it] } + val named = ordered.toSet() + val rest = list.filter { it.path !in named } + return placed + rest + } + if (id == FAVORITES_ID) commit(context, Snapshot(arrange(s.favorites), s.collections)) + else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, arrange(it.tracks)) else it })) + } + + @Synchronized + fun refresh() { + state.value = Snapshot(state.value.favorites, state.value.collections) + } + + internal fun autoCover(id: Int): File? = coverOf(tracksOf(id)) + + private fun coverOf(tracks: List): File? = + tracks.firstNotNullOfOrNull { t -> t.cover.takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile } } + + private fun game(context: Context, id: Int, name: String, tracks: List): Library.SteamGame = Library.SteamGame( + appId = id, name = name, art = SoundtrackCollectionArt.chosen(context, id) ?: coverOf(tracks), library = Library.ADDED, gameId = id.toLong(), + source = Library.SOURCE_COLLECTION, soundtrack = true, + ) + + fun games(context: Context, favoritesLabel: String): List { + val s = snapshot + return listOf(game(context, FAVORITES_ID, favoritesLabel, s.favorites)) + s.collections.map { game(context, it.id, it.name, it.tracks) } + } + + fun album(context: Context, id: Int): Soundtrack.Album { + val tracks = tracksOf(id).filter { File(it.path).isFile }.mapIndexed { i, t -> + Soundtrack.Track(File(t.path), t.title, 1, i + 1, t.durationMs, t.artist) + } + return Soundtrack.Album(mapOf(1 to tracks), "", SoundtrackCollectionArt.chosen(context, id)) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackIndex.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackIndex.kt new file mode 100644 index 0000000000..8da6a884df --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackIndex.kt @@ -0,0 +1,32 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context + +object SoundtrackIndex { + class Hit(val ref: SoundtrackCollections.TrackRef, val game: Library.SteamGame) + + private var cacheKey = "" + private var cache: List = emptyList() + + private fun fingerprint(dir: java.io.File?): Long = + if (dir == null) 0L else Soundtrack.audioFiles(dir).fold(17L) { h, f -> 31 * (31 * (31 * h + f.path.hashCode()) + f.length()) + f.lastModified() } + + fun build(context: Context, games: List): List { + val roots = games.filter { it.gameFiles != null } + val key = roots.joinToString("|") { "${it.appId}:${it.gameFiles?.path}:${it.art?.path}:${fingerprint(it.gameFiles)}" } + synchronized(this) { if (key == cacheKey) return cache } + val hits = roots.flatMap { g -> + val dir = g.gameFiles ?: return@flatMap emptyList() + val album = Soundtrack.load(context, dir, g.art) + val cover = (g.art ?: album.cover)?.path.orEmpty() + album.tracks.map { t -> + Hit(SoundtrackCollections.TrackRef(t.file.path, t.title, t.artist.ifBlank { album.artist }, g.name, t.durationMs, cover), g) + } + } + synchronized(this) { + cacheKey = key + cache = hits + } + return hits + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackOrder.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackOrder.kt new file mode 100644 index 0000000000..a8018825ce --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackOrder.kt @@ -0,0 +1,67 @@ +package com.droiddeck.launcher.frontend + +import android.content.Context +import androidx.compose.runtime.mutableIntStateOf +import org.json.JSONArray +import org.json.JSONObject +import java.io.File +import java.util.concurrent.Executors + +object SoundtrackOrder { + private val changes = mutableIntStateOf(0) + private var cache: Map>? = null + private val writer = Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-order").apply { isDaemon = true } } + + val version: Int get() = changes.intValue + + private fun file(context: Context) = File(context.filesDir, "soundtrack-order.json") + + @Synchronized + private fun read(context: Context): Map> { + cache?.let { return it } + val out = HashMap>() + val f = file(context) + if (f.isFile) runCatching { + val json = JSONObject(f.readText()) + for (key in json.keys()) { + val array = json.getJSONArray(key) + out[key] = List(array.length()) { array.getString(it) } + } + } + cache = out + return out + } + + @Synchronized + fun set(context: Context, root: File, paths: List) { + val next = HashMap(read(context)) + next[root.path] = paths + cache = next + val body = JSONObject().also { json -> next.forEach { (k, v) -> json.put(k, JSONArray(v)) } }.toString() + val target = file(context) + writer.execute { + val tmp = File(target.path + ".tmp") + runCatching { + tmp.writeText(body) + if (!tmp.renameTo(target)) tmp.delete() + } + } + changes.intValue++ + } + + internal fun ordered(disc: Map>, order: List): Map> { + if (order.isEmpty()) return disc + val index = HashMap() + order.forEachIndexed { i, p -> index.putIfAbsent(p, i) } + return disc.mapValues { (_, list) -> + list.sortedBy { index[it.file.path] ?: Int.MAX_VALUE }.mapIndexed { i, t -> + Soundtrack.Track(t.file, t.title, t.disc, i + 1, t.durationMs, t.artist, t.discLabel) + } + } + } + + fun apply(context: Context, root: File, disc: Map>): Map> { + val order = read(context)[root.path] ?: return disc + return ordered(disc, order) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackShortcuts.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackShortcuts.kt new file mode 100644 index 0000000000..c85940cd16 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackShortcuts.kt @@ -0,0 +1,41 @@ +package com.droiddeck.launcher.frontend + +import android.app.Activity +import android.content.Context +import android.content.Intent +import android.content.pm.ShortcutInfo +import android.content.pm.ShortcutManager +import android.graphics.drawable.Icon +import android.net.Uri +import android.widget.Toast +import com.droiddeck.launcher.FrontEndActivity +import com.droiddeck.launcher.LauncherIcon +import com.droiddeck.launcher.R + +object SoundtrackShortcuts { + private val linkPattern = Regex("droiddeck://soundtrack/(-?[0-9]{1,11})") + + fun uri(appId: Int): String = "droiddeck://soundtrack/$appId" + + fun parse(link: String?): Int? = link?.let { linkPattern.matchEntire(it)?.groupValues?.get(1)?.toIntOrNull() } + + fun read(intent: Intent): Int? = if (intent.action == Intent.ACTION_VIEW) parse(intent.dataString) else null + + private fun info(context: Context, game: Library.SteamGame): ShortcutInfo { + val name = game.name.ifBlank { context.getString(R.string.app_name) } + val icon = GameShortcuts.iconBitmap(game)?.let(Icon::createWithBitmap) ?: Icon.createWithResource(context, R.mipmap.ic_launcher) + val intent = Intent(Intent.ACTION_VIEW, Uri.parse(uri(game.appId)), context, FrontEndActivity::class.java) + .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP) + return ShortcutInfo.Builder(context, "soundtrack:${game.appId}") + .setActivity(LauncherIcon.activity(context)) + .setShortLabel(name.take(40)).setLongLabel(name).setIcon(icon).setIntent(intent).build() + } + + fun pin(activity: Activity, game: Library.SteamGame) { + val manager = activity.getSystemService(ShortcutManager::class.java) + val requested = runCatching { + manager.isRequestPinShortcutSupported && manager.requestPinShortcut(info(activity, game), null) + }.getOrDefault(false) + if (!requested) Toast.makeText(activity, R.string.game_shortcut_unsupported, Toast.LENGTH_LONG).show() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackTracks.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackTracks.kt new file mode 100644 index 0000000000..744614710d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SoundtrackTracks.kt @@ -0,0 +1,30 @@ +package com.droiddeck.launcher.frontend + +object SoundtrackTracks { + enum class Sort { DEFAULT, TITLE_ASC, TITLE_DESC, LONGEST, SHORTEST } + + fun sort(items: List, sort: Sort, title: (T) -> String, duration: (T) -> Long): List = when (sort) { + Sort.DEFAULT -> items + Sort.TITLE_ASC -> items.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER, title)) + Sort.TITLE_DESC -> items.sortedWith(compareByDescending(String.CASE_INSENSITIVE_ORDER, title)) + Sort.LONGEST -> items.sortedByDescending(duration) + Sort.SHORTEST -> items.sortedBy(duration) + } + + fun matches(query: String, vararg fields: String): Boolean { + val words = query.trim().lowercase().split(' ').filter { it.isNotEmpty() } + if (words.isEmpty()) return true + val haystack = fields.map { it.lowercase() } + return words.all { word -> haystack.any { it.contains(word) } } + } + + fun rank(query: String, title: String): Int { + val q = query.trim().lowercase() + val t = title.lowercase() + return when { + t == q -> 0 + t.startsWith(q) -> 1 + else -> 2 + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SteamGameArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SteamGameArt.kt index 25a3cb8fb5..d7a6522742 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/SteamGameArt.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/SteamGameArt.kt @@ -24,11 +24,7 @@ object SteamGameArt { val icon = chosenFile(context, game.appId, AddedGameArt.Slot.ICON) val logo = chosenFile(context, game.appId, AddedGameArt.Slot.LOGO) if (cover == null && hero == null && icon == null && logo == null) return game - return Library.SteamGame( - game.appId, game.name, cover ?: game.art, game.library, game.gameId, - hero ?: game.hero, game.lastPlayed, game.gameFiles, game.protonPrefix, icon ?: game.icon, game.source, game.storeId, - logo ?: game.logo, - ) + return game.withArt(cover ?: game.art, hero ?: game.hero, icon ?: game.icon, logo ?: game.logo) } fun chosenSource(context: Context, appId: Int, slot: AddedGameArt.Slot): Pair { diff --git a/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackController.kt b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackController.kt new file mode 100644 index 0000000000..7242fd6615 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackController.kt @@ -0,0 +1,288 @@ +package com.droiddeck.launcher.playback + +import android.content.ComponentName +import android.content.Context +import android.os.Bundle +import android.net.Uri +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.core.content.ContextCompat +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata +import androidx.media3.common.PlaybackParameters +import androidx.media3.common.Player +import androidx.media3.session.MediaController +import androidx.media3.session.SessionToken +import com.droiddeck.launcher.frontend.Soundtrack +import com.google.common.util.concurrent.ListenableFuture +import java.io.File + +object SoundtrackController { + var playing by mutableStateOf(false) + private set + var currentId by mutableStateOf(null) + private set + var title by mutableStateOf("") + private set + var shuffle by mutableStateOf(false) + private set + var repeat by mutableStateOf(Player.REPEAT_MODE_OFF) + private set + var durationMs by mutableStateOf(0L) + private set + var buffering by mutableStateOf(false) + private set + var volume by mutableStateOf(1f) + private set + + var activeCollection by mutableStateOf(null) + private set + + var sleepEndsAt by mutableLongStateOf(0L) + private set + var sleepTrackEnd by mutableStateOf(false) + private set + + private var app: Context? = null + private val removed: MutableSet = java.util.Collections.synchronizedSet(HashSet()) + private var activeRoot: String? = null + private var savedId: String? = null + private var future: ListenableFuture? = null + private var controller: MediaController? = null + private val pending = ArrayList<(MediaController) -> Unit>() + + private val listener = object : Player.Listener { + override fun onEvents(player: Player, events: Player.Events) = sync(player) + } + + private val disconnect = object : MediaController.Listener { + override fun onDisconnected(controller: MediaController) { + if (this@SoundtrackController.controller === controller) { + this@SoundtrackController.controller = null + future = null + reset() + } + } + } + + private fun reset() { + playing = false + currentId = null + title = "" + durationMs = 0L + buffering = false + volume = 1f + activeCollection = null + } + + private fun sync(player: Player) { + playing = player.isPlaying + buffering = player.playbackState == Player.STATE_BUFFERING + currentId = player.currentMediaItem?.mediaId?.takeIf { player.mediaItemCount > 0 } + title = player.mediaMetadata.title?.toString().orEmpty() + shuffle = player.shuffleModeEnabled + repeat = player.repeatMode + durationMs = player.duration.takeIf { it > 0 } ?: 0L + volume = player.volume + if (!player.playWhenReady) sleepTrackEnd = false + persistResume(player) + } + + private fun persistResume(player: Player) { + val context = app ?: return + val id = currentId ?: return + if (activeCollection != null) return + val root = activeRoot ?: SoundtrackSettings.resume(context)?.root?.takeIf { id.startsWith("$it/") }?.also { activeRoot = it } ?: return + if (id != savedId || !player.isPlaying) { + savedId = id + SoundtrackSettings.saveResume(context, root, id, if (player.playbackState == Player.STATE_ENDED) 0L else player.currentPosition) + } + } + + private fun applySettings(c: MediaController) { + val context = app ?: return + SoundtrackSettings.load(context) + c.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch)) + c.sendCustomCommand(SoundtrackService.SKIP_SILENCE, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, SoundtrackSettings.skipSilence) }) + sendEqualizer(c) + c.sendCustomCommand(SoundtrackService.INGAME, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, com.droiddeck.launcher.session.SessionPrefs.soundtracksIngame(context)) }) + } + + private fun sendEqualizer(c: MediaController) { + c.sendCustomCommand( + SoundtrackService.EQUALIZER, + Bundle().apply { + putBoolean(SoundtrackService.ARG_ON, SoundtrackSettings.eqOn) + putIntArray(SoundtrackService.ARG_BANDS, SoundtrackSettings.bands.toIntArray()) + putInt(SoundtrackService.ARG_BASS, SoundtrackSettings.bass) + }, + ) + } + + private fun run(context: Context, block: (MediaController) -> Unit) { + app = context.applicationContext + val live = controller + if (live != null) { block(live); return } + pending += block + if (future != null) return + val app = context.applicationContext + val token = SessionToken(app, ComponentName(app, SoundtrackService::class.java)) + val built = MediaController.Builder(app, token).setListener(disconnect) + .setConnectionHints(Bundle().apply { putBoolean(SoundtrackService.HINT_OWNER, true) }).buildAsync() + future = built + built.addListener({ + val ready = runCatching { built.get() }.getOrNull() + if (ready == null) { + future = null + pending.clear() + return@addListener + } + controller = ready + ready.addListener(listener) + applySettings(ready) + sync(ready) + val queued = pending.toList() + pending.clear() + queued.forEach { it(ready) } + }, ContextCompat.getMainExecutor(app)) + } + + fun connect(context: Context) = run(context) { } + + fun position(): Long = controller?.currentPosition ?: 0L + + fun belongsCollection(id: Int): Boolean = activeCollection == id && currentId != null + + fun belongs(root: File?): Boolean { + if (activeCollection != null) return false + val id = currentId ?: return false + return root != null && id.startsWith(root.path + "/") + } + + private fun items(album: Soundtrack.Album, albumTitle: String): List { + val cover = album.cover?.let { Uri.fromFile(it) } + return album.tracks.map { t -> + MediaItem.Builder() + .setMediaId(t.file.path) + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(t.title) + .setArtist(t.artist.ifBlank { album.artist }.ifBlank { null }) + .setAlbumTitle(albumTitle) + .setTrackNumber(t.number) + .setDiscNumber(t.disc.takeIf { it > 0 }) + .setArtworkUri(cover) + .setIsPlayable(true) + .build(), + ) + .build() + } + } + + fun play( + context: Context, album: Soundtrack.Album, albumTitle: String, startId: String?, shuffled: Boolean? = null, + root: File? = null, startMs: Long = 0L, collection: Int? = null, + ) { + val list = items(album, albumTitle) + if (list.isEmpty()) return + run(context) { c -> + if (root != null && root.path in removed) return@run + val start = list.indexOfFirst { it.mediaId == startId }.coerceAtLeast(0) + root?.let { activeRoot = it.path } + activeCollection = collection + c.setMediaItems(list, start, startMs) + shuffled?.let { c.shuffleModeEnabled = it } + c.prepare() + c.play() + } + } + + fun allow(paths: Collection) { + removed.removeAll(paths.toSet()) + } + + fun toggle(context: Context, album: Soundtrack.Album, albumTitle: String, root: File?, collection: Int? = null) { + run(context) { c -> + if (root != null && root.path in removed) return@run + val mine = if (collection != null) belongsCollection(collection) else belongs(root) + if (mine && c.mediaItemCount > 0) { + if (c.isPlaying) c.pause() else { + if (c.playbackState == Player.STATE_ENDED) c.seekToDefaultPosition(0) + c.play() + } + } else { + val saved = if (collection != null) null else root?.let { r -> SoundtrackSettings.resume(context)?.takeIf { it.root == r.path && album.tracks.any { t -> t.id == it.id } } } + play(context, album, albumTitle, saved?.id ?: album.tracks.firstOrNull()?.id, root = root, startMs = saved?.positionMs ?: 0L, collection = collection) + } + } + } + + fun pause(context: Context) { + val live = controller + if (live != null) live.pause() else if (future != null) pending += { it.pause() } + } + + fun next(context: Context) = run(context) { it.seekToNext() } + fun previous(context: Context) = run(context) { c -> if (c.currentPosition > 3000L) c.seekTo(0) else c.seekToPrevious() } + fun seekTo(context: Context, ms: Long) = run(context) { it.seekTo(ms) } + fun setShuffle(context: Context, on: Boolean) = run(context) { it.shuffleModeEnabled = on } + fun cycleRepeat(context: Context) = run(context) { + it.repeatMode = when (it.repeatMode) { + Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ALL + Player.REPEAT_MODE_ALL -> Player.REPEAT_MODE_ONE + else -> Player.REPEAT_MODE_OFF + } + } + fun setVolume(context: Context, volume: Float) = run(context) { it.volume = volume.coerceIn(0f, 1f) } + + fun setSpeed(context: Context, value: Float) { + SoundtrackSettings.load(context) + SoundtrackSettings.setSpeed(context, value) + run(context) { it.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch)) } + } + + fun setPitch(context: Context, value: Float) { + SoundtrackSettings.load(context) + SoundtrackSettings.setPitch(context, value) + run(context) { it.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch)) } + } + + fun setSkipSilence(context: Context, on: Boolean) { + SoundtrackSettings.load(context) + SoundtrackSettings.setSkipSilence(context, on) + run(context) { it.sendCustomCommand(SoundtrackService.SKIP_SILENCE, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, on) }) } + } + + fun setEqualizer(context: Context, on: Boolean, bands: List, bass: Int) { + SoundtrackSettings.load(context) + SoundtrackSettings.setEqualizer(context, on, bands, bass) + run(context) { sendEqualizer(it) } + } + + fun setIngame(context: Context, on: Boolean) { + run(context) { it.sendCustomCommand(SoundtrackService.INGAME, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, on) }) } + } + + fun setSleep(context: Context, minutes: Int) { + sleepEndsAt = if (minutes > 0) System.currentTimeMillis() + minutes * 60_000L else 0L + sleepTrackEnd = minutes < 0 + run(context) { it.sendCustomCommand(SoundtrackService.SLEEP, Bundle().apply { putInt(SoundtrackService.ARG_MINUTES, minutes) }) } + } + + fun sleepRemainingMs(): Long { + val left = sleepEndsAt - System.currentTimeMillis() + if (sleepEndsAt > 0L && left <= 0L) sleepEndsAt = 0L + return left.coerceAtLeast(0L) + } + + fun stopIf(context: Context, root: File?) { + root?.let { removed.add(it.path) } + if (root == null || currentId?.startsWith(root.path + "/") != true) return + run(context) { c -> + c.stop() + c.clearMediaItems() + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackService.kt b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackService.kt new file mode 100644 index 0000000000..083b935cd5 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackService.kt @@ -0,0 +1,282 @@ +package com.droiddeck.launcher.playback + +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.media.audiofx.BassBoost +import android.media.audiofx.Equalizer +import android.net.Uri +import android.os.Bundle +import android.os.Handler +import android.os.Looper +import android.os.Process +import androidx.media3.common.AudioAttributes +import androidx.media3.common.C +import androidx.media3.common.MediaItem +import androidx.media3.common.Player +import androidx.media3.exoplayer.ExoPlayer +import androidx.media3.session.CommandButton +import androidx.media3.session.DefaultMediaNotificationProvider +import androidx.media3.session.MediaSession +import androidx.media3.session.MediaSessionService +import androidx.media3.session.SessionCommand +import androidx.media3.session.SessionResult +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Soundtrack +import com.google.common.collect.ImmutableList +import com.google.common.util.concurrent.Futures +import com.google.common.util.concurrent.ListenableFuture +import java.io.File + +private class EdgeButtonsProvider(context: Context) : DefaultMediaNotificationProvider(context) { + override fun getMediaButtons( + session: MediaSession, playerCommands: Player.Commands, customLayout: ImmutableList, showPauseButton: Boolean, + ): ImmutableList { + val all = super.getMediaButtons(session, playerCommands, customLayout, showPauseButton) + val custom = all.filter { it.sessionCommand != null } + if (custom.size < 2) return all + return ImmutableList.builder() + .add(custom.first()) + .addAll(all.filter { it.sessionCommand == null }) + .addAll(custom.drop(1)) + .build() + } +} + +class SoundtrackService : MediaSessionService() { + private var session: MediaSession? = null + private var exo: ExoPlayer? = null + private var equalizer: Equalizer? = null + private var bassBoost: BassBoost? = null + private var effectsSession = C.AUDIO_SESSION_ID_UNSET + private var eqOn = false + private var eqBands = IntArray(0) + private var eqBass = 0 + private var sleepAtTrackEnd = false + private val handler = Handler(Looper.getMainLooper()) + private val sleepRunnable = Runnable { session?.player?.pause() } + private val covers = java.util.concurrent.Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-cover").apply { isDaemon = true } } + + override fun onCreate() { + super.onCreate() + val player = ExoPlayer.Builder(this) + .setAudioAttributes(mediaAttributes(), !com.droiddeck.launcher.session.SessionPrefs.soundtracksIngame(this)) + .setHandleAudioBecomingNoisy(true) + .setWakeMode(androidx.media3.common.C.WAKE_MODE_LOCAL) + .build() + exo = player + val sessionIntent = packageManager.getLaunchIntentForPackage(packageName)?.let { + PendingIntent.getActivity(this, 0, it, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE) + } + player.addListener(object : Player.Listener { + override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) = refreshButtons() + override fun onRepeatModeChanged(repeatMode: Int) = refreshButtons() + override fun onAudioSessionIdChanged(audioSessionId: Int) = applyEffects() + override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) { + if (!playWhenReady) sleepAtTrackEnd = false + } + override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) { + refreshTrackCover(mediaItem) + val ended = reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO || reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT + if (sleepAtTrackEnd && ended) { + sleepAtTrackEnd = false + player.pause() + } + } + }) + session = MediaSession.Builder(this, player).setCallback(Resolver()).apply { sessionIntent?.let { setSessionActivity(it) } }.build() + setMediaNotificationProvider(EdgeButtonsProvider(this).apply { setSmallIcon(R.drawable.ic_soundtrack) }) + } + + private fun mediaAttributes(): AudioAttributes = + AudioAttributes.Builder().setUsage(C.USAGE_MEDIA).setContentType(C.AUDIO_CONTENT_TYPE_MUSIC).build() + + private fun buttons(player: Player): ImmutableList = ImmutableList.of( + CommandButton.Builder() + .setDisplayName(getString(R.string.soundtracks_shuffle)) + .setIconResId(if (player.shuffleModeEnabled) R.drawable.ic_shuffle_on else R.drawable.ic_shuffle_off) + .setSessionCommand(SHUFFLE) + .build(), + CommandButton.Builder() + .setDisplayName( + getString( + when (player.repeatMode) { + Player.REPEAT_MODE_ALL -> R.string.soundtracks_repeat_all + Player.REPEAT_MODE_ONE -> R.string.soundtracks_repeat_one + else -> R.string.soundtracks_repeat_off + }, + ), + ) + .setIconResId( + when (player.repeatMode) { + Player.REPEAT_MODE_ALL -> R.drawable.ic_repeat_all + Player.REPEAT_MODE_ONE -> R.drawable.ic_repeat_one + else -> R.drawable.ic_repeat_off + }, + ) + .setSessionCommand(REPEAT) + .build(), + ) + + private fun hasPinnedArt(item: MediaItem): Boolean = + item.mediaMetadata.artworkUri?.path.orEmpty().let { it.contains("/steam-art/") || it.contains("/soundtrack-art/") } + + private fun refreshTrackCover(item: MediaItem?) { + val current = item ?: return + if (hasPinnedArt(current)) return + val file = File(current.mediaId) + covers.execute { + val art = Soundtrack.trackCover(this, file) ?: return@execute + handler.post { + val player = exo ?: return@post + val live = player.currentMediaItem ?: return@post + val uri = Uri.fromFile(art) + if (live.mediaId != current.mediaId || live.mediaMetadata.artworkUri == uri || hasPinnedArt(live)) return@post + player.replaceMediaItem( + player.currentMediaItemIndex, + live.buildUpon().setMediaMetadata(live.mediaMetadata.buildUpon().setArtworkUri(uri).build()).build(), + ) + } + } + } + + private fun releaseEffects() { + runCatching { equalizer?.release() } + runCatching { bassBoost?.release() } + equalizer = null + bassBoost = null + effectsSession = C.AUDIO_SESSION_ID_UNSET + } + + private fun applyEffects() { + val id = exo?.audioSessionId ?: C.AUDIO_SESSION_ID_UNSET + if (!eqOn || id == C.AUDIO_SESSION_ID_UNSET) { + releaseEffects() + return + } + if (id != effectsSession) { + releaseEffects() + effectsSession = id + equalizer = runCatching { Equalizer(0, id) }.getOrNull() + bassBoost = runCatching { BassBoost(0, id) }.getOrNull() + } + runCatching { + equalizer?.let { eq -> + val range = eq.bandLevelRange + for (band in 0 until minOf(eq.numberOfBands.toInt(), eqBands.size)) { + eq.setBandLevel(band.toShort(), eqBands[band].coerceIn(range[0].toInt(), range[1].toInt()).toShort()) + } + eq.enabled = true + } + } + runCatching { + bassBoost?.let { boost -> + if (boost.strengthSupported) boost.setStrength(eqBass.coerceIn(0, 1000).toShort()) + boost.enabled = eqBass > 0 + } + } + } + + private fun setSleep(minutes: Int) { + handler.removeCallbacks(sleepRunnable) + sleepAtTrackEnd = false + if (minutes > 0) handler.postDelayed(sleepRunnable, minutes * 60_000L) + else if (minutes < 0) sleepAtTrackEnd = true + } + + private fun refreshButtons() { + val live = session ?: return + live.setCustomLayout(buttons(live.player)) + } + + override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? = session + + override fun onTaskRemoved(rootIntent: Intent?) { + val player = session?.player + if (player == null || !player.playWhenReady || player.mediaItemCount == 0 || player.playbackState == Player.STATE_ENDED) stopSelf() + } + + override fun onDestroy() { + handler.removeCallbacks(sleepRunnable) + covers.shutdownNow() + releaseEffects() + session?.let { + it.player.release() + it.release() + } + session = null + super.onDestroy() + } + + companion object { + const val HINT_OWNER = "droiddeck.owner" + private val SHUFFLE = SessionCommand("droiddeck.shuffle", Bundle.EMPTY) + private val REPEAT = SessionCommand("droiddeck.repeat", Bundle.EMPTY) + val SKIP_SILENCE = SessionCommand("droiddeck.skipsilence", Bundle.EMPTY) + val EQUALIZER = SessionCommand("droiddeck.equalizer", Bundle.EMPTY) + val SLEEP = SessionCommand("droiddeck.sleep", Bundle.EMPTY) + val INGAME = SessionCommand("droiddeck.ingame", Bundle.EMPTY) + const val ARG_ON = "on" + const val ARG_BANDS = "bands" + const val ARG_BASS = "bass" + const val ARG_MINUTES = "minutes" + } + + private inner class Resolver : MediaSession.Callback { + private fun isOwner(controller: MediaSession.ControllerInfo) = + controller.uid == Process.myUid() && controller.connectionHints.getBoolean(HINT_OWNER, false) + + override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult = + if (controller.uid == Process.myUid() || controller.isTrusted) { + MediaSession.ConnectionResult.AcceptedResultBuilder(session) + .setAvailableSessionCommands( + MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon().add(SHUFFLE).add(REPEAT).add(SKIP_SILENCE).add(EQUALIZER).add(SLEEP).add(INGAME).build(), + ) + .setCustomLayout(buttons(session.player)) + .build() + } else { + MediaSession.ConnectionResult.reject() + } + + override fun onCustomCommand( + session: MediaSession, controller: MediaSession.ControllerInfo, customCommand: SessionCommand, args: Bundle, + ): ListenableFuture { + val player = session.player + when (customCommand.customAction) { + SHUFFLE.customAction -> player.shuffleModeEnabled = !player.shuffleModeEnabled + REPEAT.customAction -> player.repeatMode = when (player.repeatMode) { + Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ALL + Player.REPEAT_MODE_ALL -> Player.REPEAT_MODE_ONE + else -> Player.REPEAT_MODE_OFF + } + SKIP_SILENCE.customAction, EQUALIZER.customAction, SLEEP.customAction, INGAME.customAction -> { + if (!isOwner(controller)) return Futures.immediateFuture(SessionResult(SessionResult.RESULT_ERROR_PERMISSION_DENIED)) + when (customCommand.customAction) { + SKIP_SILENCE.customAction -> exo?.skipSilenceEnabled = args.getBoolean(ARG_ON) + INGAME.customAction -> exo?.setAudioAttributes(mediaAttributes(), !args.getBoolean(ARG_ON)) + EQUALIZER.customAction -> { + eqOn = args.getBoolean(ARG_ON) + eqBands = args.getIntArray(ARG_BANDS) ?: IntArray(0) + eqBass = args.getInt(ARG_BASS) + applyEffects() + } + else -> setSleep(args.getInt(ARG_MINUTES)) + } + } + else -> return Futures.immediateFuture(SessionResult(SessionResult.RESULT_ERROR_NOT_SUPPORTED)) + } + return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS)) + } + + override fun onAddMediaItems( + mediaSession: MediaSession, controller: MediaSession.ControllerInfo, mediaItems: MutableList, + ): ListenableFuture> { + if (!isOwner(controller)) return Futures.immediateFailedFuture(SecurityException("Only DroidDeck can queue soundtrack files")) + val resolved = mediaItems.mapNotNull { item -> + val file = File(item.mediaId) + if (Soundtrack.isAudio(file)) item.buildUpon().setUri(Uri.fromFile(file)).build() else null + }.toMutableList() + return Futures.immediateFuture(resolved) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackSettings.kt b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackSettings.kt new file mode 100644 index 0000000000..c34af1e32e --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/playback/SoundtrackSettings.kt @@ -0,0 +1,78 @@ +package com.droiddeck.launcher.playback + +import android.content.Context +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue + +object SoundtrackSettings { + const val MIN_RATE = 0.5f + const val MAX_RATE = 2f + + var speed by mutableFloatStateOf(1f) + private set + var pitch by mutableFloatStateOf(1f) + private set + var skipSilence by mutableStateOf(false) + private set + var eqOn by mutableStateOf(false) + private set + var bands by mutableStateOf>(emptyList()) + private set + var bass by mutableIntStateOf(0) + private set + + class Resume(val root: String, val id: String, val positionMs: Long) + + private var loaded = false + + private fun prefs(context: Context) = context.applicationContext.getSharedPreferences("soundtrack_settings", Context.MODE_PRIVATE) + + @Synchronized + fun load(context: Context) { + if (loaded) return + loaded = true + val p = prefs(context) + speed = p.getFloat("speed", 1f).coerceIn(MIN_RATE, MAX_RATE) + pitch = p.getFloat("pitch", 1f).coerceIn(MIN_RATE, MAX_RATE) + skipSilence = p.getBoolean("skipSilence", false) + eqOn = p.getBoolean("eqOn", false) + bands = p.getString("bands", "").orEmpty().split(',').mapNotNull { it.trim().toIntOrNull() } + bass = p.getInt("bass", 0).coerceIn(0, 1000) + } + + fun setSpeed(context: Context, value: Float) { + speed = value.coerceIn(MIN_RATE, MAX_RATE) + prefs(context).edit().putFloat("speed", speed).apply() + } + + fun setPitch(context: Context, value: Float) { + pitch = value.coerceIn(MIN_RATE, MAX_RATE) + prefs(context).edit().putFloat("pitch", pitch).apply() + } + + fun setSkipSilence(context: Context, on: Boolean) { + skipSilence = on + prefs(context).edit().putBoolean("skipSilence", on).apply() + } + + fun setEqualizer(context: Context, on: Boolean, levels: List, bassStrength: Int) { + eqOn = on + bands = levels + bass = bassStrength.coerceIn(0, 1000) + prefs(context).edit().putBoolean("eqOn", on).putString("bands", levels.joinToString(",")).putInt("bass", bass).apply() + } + + fun resume(context: Context): Resume? { + val p = prefs(context) + val root = p.getString("resumeRoot", null) ?: return null + val id = p.getString("resumeId", null) ?: return null + return Resume(root, id, p.getLong("resumePosition", 0L)) + } + + fun saveResume(context: Context, root: String, id: String, positionMs: Long) { + prefs(context).edit().putString("resumeRoot", root).putString("resumeId", id).putLong("resumePosition", positionMs.coerceAtLeast(0L)).apply() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index e47f9194bf..f55d994e1c 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -201,6 +201,18 @@ object SessionPrefs { prefs(context).edit().putBoolean("gameStoresEnabled", on).apply() } + fun soundtracksEnabled(context: Context): Boolean = prefs(context).getBoolean("soundtracksEnabled", true) + + fun setSoundtracksEnabled(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("soundtracksEnabled", on).apply() + } + + fun soundtracksIngame(context: Context): Boolean = prefs(context).getBoolean("soundtracksIngame", false) + + fun setSoundtracksIngame(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("soundtracksIngame", on).apply() + } + fun gameStoresSpeedTier(context: Context): String = prefs(context).getString("gameStoresSpeedTier", "fast") ?: "fast" fun setGameStoresSpeedTier(context: Context, tier: String) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index 756b05f45f..6849c621c9 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -14,7 +14,7 @@ object SettingsReset { internal val SESSION_KEYS = setOf( "orientation", "launcherFullscreen", "animations", "lowStorageWarning", "theme", "runSteamAtStartup", "startupSession", "addedGamesArt", "dualScreenMode", "dualScreenSessionMode", "dualScreenLauncher", "dualScreenSessionControls", "androidTextFieldKeyboard", - "gameStoresEnabled", "gameStoresSpeedTier", "gameStoresParallel", "storesOpenTab", "storesShowMature", + "gameStoresEnabled", "soundtracksEnabled", "soundtracksIngame", "gameStoresSpeedTier", "gameStoresParallel", "storesOpenTab", "storesShowMature", "storesInstallLanguage", "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "__KEEP_droidDeckHud__", "__KEEP_droidDeckHudPos__", "backHold", "backActionsInverted", "backDoubleTapMs", "touch", "osc", "shape", "steamController", "gamepadLeft", "gamepadRight", "pipAutoEnter", "unfoldedControls", "unfoldedControlsWithController", diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt index 89e1480869..a1b205e64a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt @@ -70,6 +70,7 @@ import com.droiddeck.launcher.frontend.AddedGameArt import com.droiddeck.launcher.frontend.AddedGameEdits import com.droiddeck.launcher.frontend.AddedGames import com.droiddeck.launcher.frontend.LogoPosition +import com.droiddeck.launcher.frontend.SoundtrackCollectionArt import com.droiddeck.launcher.frontend.SteamGameArt import com.droiddeck.launcher.frontend.SteamGridDb import com.droiddeck.launcher.frontend.SteamLaunchOptions @@ -179,6 +180,16 @@ internal class ArtTarget( { c, value -> AddedGameEdits.setLogoPosition(c, game.folder.path, value) }, ) + fun ofCollection(id: Int, name: String, root: java.io.File? = null) = ArtTarget( + name, + { c, _ -> SoundtrackCollectionArt.source(c, id) }, + { c, _ -> AddedGameArt.Choices(SoundtrackCollectionArt.options(c, id, root), SteamGridDb.Status.OK) }, + { c, _, option -> SoundtrackCollectionArt.choose(c, id, option) }, + { c, _ -> SoundtrackCollectionArt.reset(c, id) }, + { _ -> null }, + { _, _ -> false }, + ) + fun of(game: com.droiddeck.launcher.frontend.Library.SteamGame) = ArtTarget( game.name, { c, slot -> SteamGameArt.chosenSource(c, game.appId, slot).second }, @@ -199,6 +210,12 @@ internal fun SteamGameArtEditor( ArtOnlyEditor(game.name, target, game, { SteamGameArt.describe(it, game) }, onClose, onChanged) } +@Composable +internal fun CollectionArtEditor(id: Int, name: String, root: java.io.File? = null, onClose: () -> Unit, onChanged: () -> Unit) { + val target = remember(id, root) { ArtTarget.ofCollection(id, name, root) } + ArtOnlyEditor(name, target, id, { SoundtrackCollectionArt.describe(it, id, root) }, onClose, onChanged, listOf(AddedGameArt.Slot.COVER)) +} + @Composable internal fun StoreGameArtEditor(folder: String, name: String, onClose: () -> Unit, onChanged: () -> Unit) { val app = LocalContext.current.applicationContext @@ -212,7 +229,7 @@ internal fun StoreGameArtEditor(folder: String, name: String, onClose: () -> Uni @Composable private fun ArtOnlyEditor( name: String, target: ArtTarget?, refresh: Any?, describe: (Context) -> List, - onClose: () -> Unit, onChanged: () -> Unit, + onClose: () -> Unit, onChanged: () -> Unit, slots: List = AddedGameArt.Slot.values().toList(), ) { val app = LocalContext.current.applicationContext val shown = rememberShown(onClose) @@ -233,7 +250,7 @@ private fun ArtOnlyEditor( modifier = Modifier.fillMaxWidth().heightIn(max = maxHeight).verticalScroll(rememberScrollState()), ) { Text(stringResource(R.string.edit_artwork), fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 4.dp, top = 2.dp)) - for (slot in AddedGameArt.Slot.values()) key(slot) { + for (slot in slots) key(slot) { val state = arts.firstOrNull { it.slot == slot } FieldRow(slot.label(), focus = if (slot == AddedGameArt.Slot.COVER) first else null, onClick = { if (target != null) artSlot = slot }) { Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) { @@ -242,7 +259,7 @@ private fun ArtOnlyEditor( } } } - PickerRow(Icons.Outlined.Tune, stringResource(R.string.art_adjust_logo), logoPositionSummary(position?.value), enabled = target != null && position != null) { logoOpen = true } + if (AddedGameArt.Slot.LOGO in slots) PickerRow(Icons.Outlined.Tune, stringResource(R.string.art_adjust_logo), logoPositionSummary(position?.value), enabled = target != null && position != null) { logoOpen = true } } } val chosen = target ?: return diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt index 28b3dc33bb..b99ee02316 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt @@ -115,6 +115,7 @@ internal fun Pane( s.pageKey != null && page != null -> null selected.startsWith("app:") -> s.steamGames.firstOrNull { "app:${it.appId}" == selected }?.art selected == "games" -> s.steamGames.maxByOrNull { it.lastPlayed }?.art + selected.startsWith("sound:") -> s.soundtracks.firstOrNull { "sound:${it.appId}" == selected }?.let { it.hero ?: it.art } selected.startsWith("rom:") -> romFor(s, selected)?.second?.art else -> null } @@ -124,10 +125,12 @@ internal fun Pane( val origins = remember { HashMap() } val paneAt = remember { arrayOf(Offset.Zero) } val livePage by rememberUpdatedState(s.pageKey) - val railContent = if (selected.startsWith("app:")) "games" else selected + val railContent = if (selected.startsWith("app:")) "games" else if (selected.startsWith("sound:")) "soundtracks" else selected val target = if (page != null && s.pageKey != null) s.pageKey else railContent val gameShown = remember { arrayOf("games") } if (selected == "games" || selected.startsWith("app:")) gameShown[0] = selected + val soundShown = remember { arrayOf("soundtracks") } + if (selected == "soundtracks" || selected.startsWith("sound:")) soundShown[0] = selected val before = remember { arrayOf(target) } if (page != null && s.pageKey != null) { pages[s.pageKey] = page @@ -171,7 +174,7 @@ internal fun Pane( label = "pane", ) { key -> val drawn = (if (page != null && key == s.pageKey) page else pages[key]) - ?: { Content(s, if (key == "games") gameShown[0] else key, a, Modifier.fillMaxSize(), onSelect, onAndroidAppClick, onOpenDeveloperOptions, onRequestWirelessAdb, onPairWirelessDebugging) } + ?: { Content(s, if (key == "games") gameShown[0] else if (key == "soundtracks") soundShown[0] else key, a, Modifier.fillMaxSize(), onSelect, onAndroidAppClick, onOpenDeveloperOptions, onRequestWirelessAdb, onPairWirelessDebugging) } val hopSink by androidx.compose.animation.core.animateFloatAsState( if (Hops.sinking == key) 1f else 0f, Motion.tw(260), label = "hopSink", ) @@ -262,7 +265,7 @@ private fun Content( StoresPage(s, a, modifier) return } - if (selected == "games" || selected.startsWith("app:")) { + if (selected == "games" || selected.startsWith("app:") || selected == "soundtracks" || selected.startsWith("sound:")) { LibraryPage(s, a, selected, onSelect, modifier) return } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndRail.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndRail.kt index 599968d9f7..87d8ac6644 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndRail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndRail.kt @@ -126,6 +126,7 @@ internal fun BottomBar( internal fun navigationKeys(s: FrontEndState) = buildList { add("steam"); add("games") + if (s.soundtracksEnabled) add("soundtracks") if (s.gameStoresEnabled) add("stores") add("desktop") if (com.droiddeck.launcher.agent.AgentTab.visible) add("agent") @@ -200,6 +201,7 @@ internal fun SideRail( internal fun railLabelIcon(key: String): Pair = when (key) { "steam" -> R.string.rail_steam to Icons.Outlined.SportsEsports "games" -> R.string.rail_games to Icons.Outlined.VideoLibrary + "soundtracks" -> R.string.rail_music to SoundtrackIcon "stores" -> R.string.rail_stores to Icons.Outlined.LocalMall "desktop" -> R.string.rail_desktop to Icons.Outlined.DesktopWindows "components" -> R.string.rail_components to Icons.Outlined.Layers diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt index f9914d5a38..2d2baaff3f 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -181,6 +181,10 @@ class FrontEndState( val lowStorageWarning: Boolean = true, val launcherIcon: String = com.droiddeck.launcher.LauncherIcon.DARK, val gameStoresEnabled: Boolean = true, + val soundtracksEnabled: Boolean = true, + val soundtracksIngame: Boolean = false, + val soundtracks: List = emptyList(), + val soundtracksLoaded: Boolean = true, val gameStoresSpeedTier: String = "fast", val navigate: String? = null, val addedGamesArt: Boolean = true, @@ -285,6 +289,11 @@ class FrontEndActions( val onDownloadPrefix: (String) -> Unit = {}, val onDownloadProxy: (String) -> Unit = {}, val onGameStoresEnabled: (Boolean) -> Unit = {}, + val onSoundtracksEnabled: (Boolean) -> Unit = {}, + val onSoundtracksIngame: (Boolean) -> Unit = {}, + val onSoundtrackAdded: (java.io.File) -> Unit = {}, + val onSoundtracksChanged: () -> Unit = {}, + val onSoundtrackRemoved: (Library.SteamGame) -> Unit = {}, val onGameStoresSpeedTier: (String) -> Unit = {}, val onNavigated: () -> Unit = {}, val onStoresShowMature: (Boolean) -> Unit = {}, @@ -567,8 +576,14 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com selected = if (selected.startsWith("rom:")) "emu:" + selected.removePrefix("rom:").substringBefore(':') else "desktop" } LaunchedEffect(s.isHomeApp) { if (!s.isHomeApp && selected == "android-apps") selected = "steam" } - LaunchedEffect(s.steamGames.isEmpty()) { - if (s.steamGames.isEmpty() && selected.startsWith("app:") && GameRef.parse(selected).appId != null) selected = "games" + LaunchedEffect(s.soundtracksEnabled) { + if (!s.soundtracksEnabled && (selected == "soundtracks" || selected.startsWith("sound:"))) selected = "games" + } + LaunchedEffect(s.steamGames.isEmpty(), s.soundtracks, s.soundtracksLoaded) { + if (s.steamGames.isEmpty() && selected.startsWith("app:")) { + val id = GameRef.parse(selected).appId + if (id != null && s.soundtracks.none { it.appId == id } && s.soundtracksLoaded) selected = "games" + } } remember { Motion.refresh(ctx); true } @@ -577,6 +592,7 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com s.pageKey == "performance" -> "steam" s.pageKey == "controller-mapping" -> "setup" selected.startsWith("app:") -> "games" + selected.startsWith("sound:") -> "soundtracks" selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:") || selected == "store" -> "desktop" else -> s.pageKey ?: selected } @@ -688,7 +704,7 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com val r = Hops.restore ?: return@LaunchedEffect if (r.surface == HOP_SURFACE_SHEET) return@LaunchedEffect Hops.restore = null - if (r.rail != selected && !(r.rail == "games" && selected.startsWith("app:"))) selected = r.rail + if (r.rail != selected && !(r.rail == "games" && selected.startsWith("app:")) && !(r.rail == "soundtracks" && selected.startsWith("sound:"))) selected = r.rail kotlinx.coroutines.delay(Motion.ms(PAGE_EXIT_MS).toLong()) if (inputModeManager.inputMode != InputMode.Keyboard) return@LaunchedEffect frontFocus.last = r.control diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index 3655ec0959..fa78998cf4 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -457,6 +457,8 @@ internal fun SetupPanel( ToggleRow(host, "rail-labels", stringResource(R.string.setup_rail_labels), stringResource(R.string.setup_rail_labels_hint), RailLabels.shown) { RailLabels.set(railContext, it) } LanguageRow(host, s.language, a.onLanguage) ToggleRow(host, "show-stores", stringResource(R.string.setup_stores), null, s.gameStoresEnabled, onChange = a.onGameStoresEnabled) + ToggleRow(host, "show-soundtracks", stringResource(R.string.setup_soundtracks), null, s.soundtracksEnabled, onChange = a.onSoundtracksEnabled) + if (s.soundtracksEnabled) ToggleRow(host, "soundtracks-ingame", stringResource(R.string.setup_soundtracks_ingame), stringResource(R.string.setup_soundtracks_ingame_hint), s.soundtracksIngame, onChange = a.onSoundtracksIngame) } } val device: @Composable () -> Unit = { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt b/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt index bee82bbd2c..7aba7feb45 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt @@ -148,7 +148,7 @@ internal fun GameDetail( val narrow = LocalNarrowPane.current val stacked = narrow || LocalConfiguration.current.screenWidthDp < 700 val ref = remember(key) { GameRef.parse(key) } - val games = s.steamGames + rememberXboxCloudRows(s) + val games = s.steamGames + rememberXboxCloudRows(s) + if (s.soundtracksEnabled) emptyList() else s.soundtracks val found = ref.game(games) val known = remember(key) { arrayOfNulls>(1) } val store = ref.store ?: Store.byId(found?.source) ?: known[0]?.first @@ -280,7 +280,7 @@ internal fun GameDetail( } @Composable -private fun SourceBadge(source: String) { +internal fun SourceBadge(source: String) { val c = sourceColours(source) Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(7.dp), @@ -574,13 +574,13 @@ private fun buyLabel(item: CatalogItem): String = when { } @Composable -private fun FileButtons(game: Library.SteamGame, a: FrontEndActions) { +internal fun FileButtons(game: Library.SteamGame, a: FrontEndActions) { game.gameFiles?.takeIf { it.isDirectory }?.let { dir -> SecondaryButton(stringResource(R.string.games_files), compact = true) { a.onBrowseFiles(dir) } } game.protonPrefix?.takeIf { it.isDirectory }?.let { dir -> SecondaryButton(stringResource(R.string.games_prefix), compact = true) { a.onBrowseFiles(dir) } } } @Composable -private fun GameShortcutMenu(g: Library.SteamGame, a: FrontEndActions) { +internal fun GameShortcutMenu(g: Library.SteamGame, a: FrontEndActions) { var open by remember(g.gameId) { mutableStateOf(false) } Box { SecondaryButton(stringResource(R.string.game_shortcut), compact = true) { open = !open } @@ -593,7 +593,7 @@ private fun GameShortcutMenu(g: Library.SteamGame, a: FrontEndActions) { } @Composable -private fun rememberEditArt(g: Library.SteamGame): (() -> Unit)? { +internal fun rememberEditArt(g: Library.SteamGame): (() -> Unit)? { val ctx = LocalContext.current val folder = g.gameFiles return when { @@ -607,7 +607,7 @@ private fun rememberEditArt(g: Library.SteamGame): (() -> Unit)? { } @Composable -private fun EditArtButton(g: Library.SteamGame) { +internal fun EditArtButton(g: Library.SteamGame) { val open = rememberEditArt(g) ?: return IconAction(Icons.Outlined.Edit, stringResource(R.string.game_edit_art), "game:edit", onClick = open) } @@ -664,7 +664,7 @@ internal fun IconAction(icon: androidx.compose.ui.graphics.vector.ImageVector, l } @Composable -private fun RemoveButton(title: String, game: Library.SteamGame?, installed: InstalledStoreGame?, a: FrontEndActions) { +internal fun RemoveButton(title: String, game: Library.SteamGame?, installed: InstalledStoreGame?, a: FrontEndActions) { val ctx = LocalContext.current val colors = MaterialTheme.colorScheme if ((installed?.sidecar?.store?.id ?: game?.source) == Store.BATTLENET.id && installed?.sidecar?.id?.let(BattleNetInstall::product) == null) return diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GameGlass.kt b/app/src/main/java/com/droiddeck/launcher/ui/GameGlass.kt index a2660d1b47..e5fd8845bd 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GameGlass.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GameGlass.kt @@ -38,6 +38,7 @@ import androidx.compose.ui.graphics.drawscope.drawIntoCanvas import androidx.compose.ui.graphics.drawscope.DrawScope import androidx.compose.ui.graphics.drawscope.clipRect import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.draw.blur import androidx.compose.ui.graphics.graphicsLayer import androidx.compose.ui.graphics.luminance import androidx.compose.ui.graphics.painter.Painter @@ -147,6 +148,7 @@ internal fun GameBackdrop( fadeTop: Boolean, modifier: Modifier = Modifier, onArtPlaced: (androidx.compose.ui.geometry.Rect?) -> Unit = {}, + artBlur: androidx.compose.ui.unit.Dp = 0.dp, content: @Composable () -> Unit, ) { val ctx = LocalContext.current @@ -178,13 +180,13 @@ internal fun GameBackdrop( glass.fadeBottom(this, size) }, ) - if (art != null) ArtLayer(art, ambient ?: art, fadeTop, onArtPlaced) + if (art != null) ArtLayer(art, ambient ?: art, fadeTop, artBlur, onArtPlaced) CompositionLocalProvider(LocalGlass provides glass) { content() } } } @Composable -private fun ArtLayer(model: Any?, sample: Any?, fadeTop: Boolean, onPlaced: (androidx.compose.ui.geometry.Rect?) -> Unit) { +private fun ArtLayer(model: Any?, sample: Any?, fadeTop: Boolean, blur: androidx.compose.ui.unit.Dp, onPlaced: (androidx.compose.ui.geometry.Rect?) -> Unit) { val colors = MaterialTheme.colorScheme val light = colors.background.luminance() > 0.5f val pale = ((rememberArtBrightness(sample) - 0.28f) / 0.5f).coerceIn(0f, 1f) @@ -208,7 +210,7 @@ private fun ArtLayer(model: Any?, sample: Any?, fadeTop: Boolean, onPlaced: (and model = model, contentDescription = null, contentScale = ContentScale.Crop, alignment = BiasAlignment(0.45f, -0.35f), colorFilter = artFilter, - modifier = Modifier.matchParentSize(), + modifier = Modifier.matchParentSize().then(if (blur > 0.dp) Modifier.blur(blur) else Modifier), ) Box( Modifier.matchParentSize().drawBehind { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt index 73dad7aa70..e3d76dcd1f 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt @@ -42,6 +42,7 @@ import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Add +import androidx.compose.material.icons.filled.BookmarkBorder import androidx.compose.material.icons.filled.FilterAlt import androidx.compose.material.icons.filled.GridView import androidx.compose.material.icons.filled.PlayArrow @@ -61,6 +62,7 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.produceState import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -92,6 +94,11 @@ import androidx.compose.ui.unit.sp import coil.compose.AsyncImage import com.droiddeck.launcher.R import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.frontend.Soundtrack +import com.droiddeck.launcher.frontend.SoundtrackCollections +import com.droiddeck.launcher.frontend.SoundtrackIndex +import com.droiddeck.launcher.frontend.SoundtrackTracks +import com.droiddeck.launcher.playback.SoundtrackController import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.Store @@ -156,7 +163,7 @@ internal fun installedFirst(entries: List): List = e internal const val LIBRARY_ALL = "all" internal fun librarySources(entries: List, order: List, always: Set = emptySet()): List = - (listOf(Library.SOURCE_STEAM) + arrangeStoreTabs(order, emptySet()).map { it.store.id } + Library.ADDED) + (listOf(Library.SOURCE_STEAM) + arrangeStoreTabs(order, emptySet()).map { it.store.id } + Library.ADDED + Library.SOURCE_COLLECTION) .filter { source -> source in always || entries.any { it.source == source } } internal object LibraryDisplay { @@ -215,14 +222,24 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, val inputMode = androidx.compose.ui.platform.LocalInputModeManager.current LaunchedEffect(Unit) { StoresState.refresh(ctx) } remember { LibraryDisplay.load(ctx) } - val stores = s.gameStoresEnabled && !s.shortcutPicker + val soundMode = selected == "soundtracks" || selected.startsWith("sound:") + val stores = s.gameStoresEnabled && !s.shortcutPicker && !soundMode val signedIn = Store.entries.filter { StoresState.isSignedIn(it) } LaunchedEffect(stores, signedIn) { if (stores) signedIn.forEach { StoresState.loadLibrary(ctx, it) } } val owned = if (stores) signedIn.associateWith { StoresState.library[it].orEmpty() } else emptyMap() val installedStore = StoresState.installed.map { it.key }.toSet() val syncing = if (stores) signedIn.mapNotNull { st -> StoresState.status[st]?.let { st to it } } else emptyList() val cloudRows = rememberXboxCloudRows(s) - val all = remember(s.steamGames, cloudRows, owned, installedStore) { libraryEntries(s.steamGames + cloudRows, owned, installedStore) } + remember { SoundtrackCollections.load(ctx) } + val savedSnapshot = SoundtrackCollections.snapshot + val favoritesLabel = stringResource(R.string.soundtracks_favorites) + val all = remember(soundMode, s.steamGames, s.soundtracks, s.soundtracksEnabled, cloudRows, owned, installedStore, savedSnapshot, favoritesLabel) { + if (soundMode) s.soundtracks.map { LibraryEntry("sound:${it.appId}", it.source, it.name, it, null, true) } + + (if (s.soundtracks.isEmpty() && savedSnapshot.favorites.isEmpty() && savedSnapshot.collections.isEmpty()) emptyList() else SoundtrackCollections.games(ctx, favoritesLabel)) + .map { LibraryEntry("sound:${it.appId}", it.source, it.name, it, null, true) } + else libraryEntries(s.steamGames + cloudRows + if (s.soundtracksEnabled) emptyList() else s.soundtracks.filter { it.library != Library.ADDED }, owned, installedStore) + } + var addingSoundtrack by remember { mutableStateOf(false) } LaunchedEffect(Unit) { XboxLibraryFilter.load(ctx) } var showUninstalled by remember(LibraryView.ownedRequest) { mutableStateOf(SessionPrefs.libraryShowUninstalled(ctx)) } var collectionShows by remember { mutableStateOf?>(null) } @@ -240,7 +257,10 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, } val itchSignedIn = owned.containsKey(Store.ITCH) val gameJoltSignedIn = owned.containsKey(Store.GAMEJOLT) - val sources = librarySources(all, SessionPrefs.storesTabOrder(ctx), listOfNotNull(Store.ITCH.id.takeIf { itchSignedIn }, Store.GAMEJOLT.id.takeIf { gameJoltSignedIn }).toSet()) + val sources = librarySources( + all, SessionPrefs.storesTabOrder(ctx), + listOfNotNull(Store.ITCH.id.takeIf { itchSignedIn && !soundMode }, Store.GAMEJOLT.id.takeIf { gameJoltSignedIn && !soundMode }, Library.SOURCE_COLLECTION.takeIf { soundMode }).toSet(), + ) val source = LibraryView.source.takeIf { it == LIBRARY_ALL || it in sources } ?: LIBRARY_ALL val q = LibraryView.query.trim().lowercase() val xboxFilter = if (source == Store.XBOX.id) XboxLibraryFilter.current else XboxLibraryFilter.ALL @@ -265,6 +285,30 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, (source == LIBRARY_ALL || it.source == source) && (q.isEmpty() || it.title.lowercase().contains(q)) && keepsXbox(xboxFilter, it) } val listUninstalled = if (collectionId == null) showUninstalled else collectionShows?.takeIf { it.first == collectionId }?.second ?: true + val trackHits by produceState>(emptyList(), soundMode, q, source, s.soundtracks) { + if (!soundMode || q.isEmpty()) { + value = emptyList() + return@produceState + } + kotlinx.coroutines.delay(150) + value = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { + SoundtrackIndex.build(ctx, s.soundtracks) + .filter { (source == LIBRARY_ALL || it.game.source == source) && SoundtrackTracks.matches(q, it.ref.title, it.ref.artist, it.ref.album) } + .distinctBy { it.ref.path } + .sortedWith(compareBy({ SoundtrackTracks.rank(q, it.ref.title) }, { it.ref.title.lowercase() })) + .take(100) + } + } + val shownHits = trackHits.filter { source == LIBRARY_ALL || it.game.source == source } + val hitScope = rememberCoroutineScope() + val playHit: (SoundtrackIndex.Hit) -> Unit = { hit -> + val dir = hit.game.gameFiles + if (dir != null) hitScope.launch { + val album = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { Soundtrack.load(ctx, dir, hit.game.art) } + SoundtrackController.play(ctx, album, hit.game.name, hit.ref.path, root = dir) + } + } + var savedDialog by remember { mutableStateOf(false) } val candidates = if (listUninstalled) matching else matching.filter { it.installed } val hiddenUninstalled = if (listUninstalled) 0 else matching.count { !it.installed } val sort = s.storesSort @@ -304,18 +348,20 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, var stable by remember { mutableStateOf(emptyList()) } val ordered = if (sizesPending) retainOrder(candidates, stable) { it.key } else sorted SideEffect { if (!sizesPending) stable = sorted } - val visible = installedFirst(ordered) + val visible = installedFirst(ordered).let { list -> + if (soundMode && source == Library.SOURCE_COLLECTION) list.sortedBy { if (it.game?.appId == SoundtrackCollections.FAVORITES_ID) 0 else 1 } else list + } val split = visible.count { it.installed }.takeIf { it in 1 until visible.size } ?: 0 - val open = selected.takeIf { it.startsWith("app:") } - val back = { onSelect("games") } + val open = selected.takeIf { it.startsWith(if (soundMode) "sound:" else "app:") } + val back = { onSelect(if (soundMode) "soundtracks" else "games") } BackHandler(enabled = open == null && LibraryView.query.isNotEmpty()) { LibraryView.query = "" } BackHandler(enabled = open != null) { back() } val lead = remember { FocusRequester() } var detailFocused by remember { mutableStateOf(false) } var lastOpened by remember { mutableStateOf(null) } val wasOpen = remember { booleanArrayOf(false) } - val backLabel = stringResource(R.string.rail_games) + val backLabel = stringResource(if (soundMode) R.string.rail_soundtracks else R.string.rail_games) LaunchedEffect(open) { val closing = open == null && wasOpen[0] wasOpen[0] = open != null @@ -349,7 +395,7 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, kotlinx.coroutines.delay(Motion.ms(240).toLong()) focusWithinFrames({ ff.last?.startsWith("card:") == true }) { if (ff.firstTileAttached > 0) ff.firstTile else FocusRequester.Default } } - if (all.isEmpty() && open == null && !itchSignedIn && !gameJoltSignedIn) { + if (!soundMode && all.isEmpty() && open == null && !itchSignedIn && !gameJoltSignedIn) { LibraryEmpty(s, a, modifier) return } @@ -385,9 +431,26 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, onOpen = { focusManager.clearFocus(force = true); onSelect(it) }, searchCleared = open != null, onFocus = { gridFocused = it }, + soundMode = soundMode, + emptyText = when { + soundMode && all.isEmpty() -> R.string.soundtracks_empty + soundMode && source == Library.SOURCE_COLLECTION && q.isEmpty() -> R.string.soundtracks_collections_empty + else -> R.string.stores_nothing_matches + }, + onAddSoundtrack = { addingSoundtrack = true }, + onCollections = { savedDialog = true }, + trackHits = shownHits, onPlayHit = playHit, ) }, - ) { key -> GameDetail(key, s, a, lead, backLabel, hopRail = "games", onBack = back) } + ) { key -> + if (soundMode || (!s.soundtracksEnabled && s.soundtracks.any { GameRef.key(it) == key })) SoundtrackDetail(key, s, a, lead, backLabel, onBack = back) + else GameDetail(key, s, a, lead, backLabel, hopRail = "games", onBack = back) + } + if (savedDialog) SavedDialog(emptyList(), onOpen = { id -> onSelect("sound:$id") }) { savedDialog = false } + if (addingSoundtrack) SyncFolderPicker(stringResource(R.string.soundtracks_add_title), null, onDismiss = { addingSoundtrack = false }) { dir -> + addingSoundtrack = false + a.onSoundtrackAdded(dir) + } } @Composable @@ -416,6 +479,8 @@ private fun LibraryGrid( sources: List, source: String, sizesPending: Boolean, syncing: List>, showUninstalled: Boolean?, onShowUninstalled: (Boolean) -> Unit, hiddenUninstalled: Int, onSource: (String) -> Unit, onCycle: (Int) -> Unit, onOpen: (String) -> Unit, onFocus: (Boolean) -> Unit, searchCleared: Boolean, + soundMode: Boolean = false, emptyText: Int = R.string.stores_nothing_matches, onAddSoundtrack: () -> Unit = {}, + onCollections: () -> Unit = {}, trackHits: List = emptyList(), onPlayHit: (SoundtrackIndex.Hit) -> Unit = {}, ) { val listMode = s.storesView == "list" val capsules = s.storesView == "capsules" @@ -438,7 +503,7 @@ private fun LibraryGrid( val next = storeGridNeighbor(index, visible.size, if (listMode) 1 else columns, direction, split) when { direction == 0 || index < 0 -> false - next == null -> direction > 0 + next == null -> direction > 0 && trackHits.isEmpty() else -> { if (key.action == KeyEvent.ACTION_DOWN) { val target = "card:${visible[next].key}" @@ -470,7 +535,7 @@ private fun LibraryGrid( contentPadding = PaddingValues(top = 4.dp, bottom = 16.dp), ) { item(key = "header", span = { GridItemSpan(maxLineSpan) }) { - Rise(0) { LibraryHeader(s, a, total, searchCleared, source == Store.XBOX.id, showUninstalled, onShowUninstalled, collections = Store.byId(source)?.takeIf { it == Store.ITCH || it == Store.GAMEJOLT }) } + Rise(0) { LibraryHeader(s, a, total, searchCleared, source == Store.XBOX.id, showUninstalled, onShowUninstalled, collections = Store.byId(source)?.takeIf { it == Store.ITCH || it == Store.GAMEJOLT }, soundMode = soundMode, onAddSoundtrack = onAddSoundtrack, onCollections = onCollections) } } item(key = "filters", span = { GridItemSpan(maxLineSpan) }) { Rise(1) { LibraryFilters(sources, source, onSource) } @@ -488,7 +553,7 @@ private fun LibraryGrid( Text(stringResource(R.string.store_section_loading), fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) } } - val empty = R.string.stores_nothing_matches + val empty = emptyText if (visible.isEmpty() && hiddenUninstalled > 0) item(key = "browse-owned", span = { GridItemSpan(maxLineSpan) }) { Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.fillMaxWidth().padding(vertical = 32.dp)) { Text(stringResource(R.string.library_no_installed_matches), fontSize = 13.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) @@ -502,6 +567,40 @@ private fun LibraryGrid( item(key = "not-installed-label", span = { GridItemSpan(maxLineSpan) }) { SectionLabel(stringResource(R.string.stores_section_not_installed)) } libraryGrid(visible.drop(split), empty, tile) } + if (trackHits.isNotEmpty()) { + item(key = "tracks-label", span = { GridItemSpan(maxLineSpan) }) { SectionLabel(stringResource(R.string.soundtracks_tracks_heading)) } + items(trackHits, key = { "track:${it.ref.path}" }, span = { GridItemSpan(maxLineSpan) }, contentType = { "track" }) { hit -> TrackHitRow(hit, onPlayHit) } + } + } +} + +@Composable +private fun TrackHitRow(hit: SoundtrackIndex.Hit, onPlay: (SoundtrackIndex.Hit) -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) + val shape = RoundedCornerShape(10.dp) + val cover = hit.ref.cover.takeIf { it.isNotEmpty() }?.let { java.io.File(it) }?.takeIf { it.isFile } + Row( + verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), + modifier = Modifier.fillMaxWidth().heightIn(min = 56.dp).paneItem("trackhit:${hit.ref.path}").testTag("track-hit") + .clip(shape).glideBorder(hot, shape, pal.signal, pal.line) + .hoverable(src).clickable(role = Role.Button, interactionSource = src, indication = LocalIndication.current) { onPlay(hit) } + .controllerConfirm { onPlay(hit) } + .padding(horizontal = 10.dp, vertical = 6.dp), + ) { + Box(Modifier.size(44.dp).clip(RoundedCornerShape(8.dp)).background(artBrush(hueOf(hit.ref.album)))) { + if (cover != null) AsyncImage(model = cover, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) + } + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { + Text(hit.ref.title, fontSize = 14.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text( + listOf(hit.ref.album, hit.ref.artist).filter { it.isNotBlank() }.joinToString(" · "), + fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, + ) + } + if (hit.ref.durationMs > 0) Text(Soundtrack.formatLength(hit.ref.durationMs), fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1) } } @@ -532,28 +631,31 @@ private fun LazyGridScope.libraryGrid(entries: List, empty: Int, t private fun LibraryHeader( s: FrontEndState, a: FrontEndActions, total: Int, searchCleared: Boolean, xbox: Boolean, showUninstalled: Boolean?, onShowUninstalled: (Boolean) -> Unit, collections: Store?, + soundMode: Boolean = false, onAddSoundtrack: () -> Unit = {}, onCollections: () -> Unit = {}, ) { val colors = MaterialTheme.colorScheme val narrow = LocalNarrowPane.current + val heading = stringResource(if (soundMode) R.string.rail_soundtracks else R.string.rail_games) ModeHeader( - stringResource(R.string.rail_games), LibraryView.query, { LibraryView.query = it }, - placeholder = stringResource(R.string.stores_search_library), + heading, LibraryView.query, { LibraryView.query = it }, + placeholder = stringResource(if (soundMode) R.string.soundtracks_search else R.string.stores_search_library), clearSearchFocus = searchCleared, inlineWhenStacked = true, lead = { Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.padding(start = 2.dp, end = 4.dp)) { - Text(stringResource(R.string.rail_games), fontSize = if (narrow) 20.sp else 24.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1) - Text(pluralStringResource(R.plurals.mode_added_count, total, total), fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1) + Text(heading, fontSize = if (narrow) 20.sp else 24.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1) + Text(if (soundMode) total.toString() else pluralStringResource(R.plurals.mode_added_count, total, total), fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1) if (s.steamGamesX64 && !narrow) ClientTag() } }, ) { + if (soundMode) HeaderIconButton(stringResource(R.string.soundtracks_saved), Icons.Filled.BookmarkBorder, "collections", onCollections) DisplayButton() - if (showUninstalled != null || xbox) LibraryFilterButton(showUninstalled, onShowUninstalled, xbox) + if (!soundMode && (showUninstalled != null || xbox)) LibraryFilterButton(showUninstalled, onShowUninstalled, xbox) if (collections != null) CollectionsButton(collections) SortButton(s, a) ViewButton(s, a) - GameFileFolderActions(s, a) - if (!s.shortcutPicker) AddGameButton { GamesDialogState.adding = true } + if (!soundMode) GameFileFolderActions(s, a) + if (!s.shortcutPicker) AddGameButton { if (soundMode) onAddSoundtrack() else GamesDialogState.adding = true } } if (s.steamGamesX64 && narrow) Box(Modifier.padding(top = 4.dp)) { ClientTag() } } @@ -570,7 +672,7 @@ private fun LibraryFilters(sources: List, source: String, onSource: (Str val store = Store.byId(src) val dot = when { store != null -> sourceColours(src).dot.copy(alpha = if (StoresState.isSignedIn(store) && StoresState.expired[store] != true) 1f else 0.35f) - src == Library.SOURCE_STEAM -> sourceColours(src).dot + src == Library.SOURCE_STEAM || src == Library.ADDED || src == Library.SOURCE_COLLECTION -> sourceColours(src).dot else -> null } SourceFilterChip(src, if (src == Library.ADDED) stringResource(R.string.library_filter_added) else store?.shortLabel ?: sourceLabel(src), source == src, dot) { onSource(src) } @@ -649,7 +751,7 @@ private fun LibraryArt(e: LibraryEntry, wide: Any?, tall: Any?, download: Downlo } ArtCard( e.title, wide, tall, download, hot, capsule, chip, - badge = if (showSource) ({ SourceChip(e.source, small = true, modifier = Modifier.align(Alignment.TopStart).padding(6.dp)) }) else null, + badge = if (showSource) ({ SourceChip(e.source, small = true, modifier = Modifier.align(Alignment.TopStart).padding(6.dp), label = favoritesBadge(e), colours = favoritesColours(e)) }) else null, ) { LibrarySize(e) } } @@ -786,7 +888,7 @@ private fun LibraryRow(e: LibraryEntry, first: Boolean, navigation: Modifier, ch Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) { Text(e.title, fontSize = 14.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis) Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) { - SourceChip(e.source, small = true) + SourceChip(e.source, small = true, label = favoritesBadge(e), colours = favoritesColours(e)) Text(meta.joinToString(" · "), fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis) } } @@ -1004,3 +1106,10 @@ private fun ViewButton(s: FrontEndState, a: FrontEndActions) { "view", ) { a.onStoresView(next) } } + +@Composable +private fun favoritesBadge(e: LibraryEntry): String? = + if (e.game?.appId == SoundtrackCollections.FAVORITES_ID && e.source == Library.SOURCE_COLLECTION) stringResource(R.string.soundtracks_favorites) else null + +private fun favoritesColours(e: LibraryEntry): SourceColours? = + if (e.game?.appId == SoundtrackCollections.FAVORITES_ID && e.source == Library.SOURCE_COLLECTION) FavoritesColours else null diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackCollectionsUi.kt b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackCollectionsUi.kt new file mode 100644 index 0000000000..2bf1314621 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackCollectionsUi.kt @@ -0,0 +1,295 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.LocalIndication +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.hoverable +import androidx.compose.foundation.interaction.MutableInteractionSource +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.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Add +import androidx.compose.material.icons.filled.Bookmark +import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.Edit +import androidx.compose.material.icons.filled.Remove +import androidx.compose.material.icons.filled.CheckBox +import androidx.compose.material.icons.filled.CheckBoxOutlineBlank +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.produceState +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import coil.compose.AsyncImage +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.frontend.Soundtrack +import com.droiddeck.launcher.frontend.SoundtrackCollections +import com.droiddeck.launcher.frontend.SoundtrackIndex +import com.droiddeck.launcher.frontend.SoundtrackTracks +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +@Composable +internal fun SavedDialog(pending: List, onOpen: ((Int) -> Unit)?, onDismiss: () -> Unit) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + remember { SoundtrackCollections.load(ctx) } + val snapshot = SoundtrackCollections.snapshot + val favoritesLabel = stringResource(R.string.soundtracks_favorites) + var naming by remember { mutableStateOf(false) } + val rows = listOf(Triple(SoundtrackCollections.FAVORITES_ID, favoritesLabel, snapshot.favorites)) + + snapshot.collections.map { Triple(it.id, it.name, it.tracks) } + AlertDialog( + onDismissRequest = onDismiss, + title = { + Row(verticalAlignment = Alignment.CenterVertically) { + Text(stringResource(R.string.soundtracks_saved), modifier = Modifier.weight(1f)) + Icon(Icons.Filled.Bookmark, contentDescription = null, tint = colors.onSurfaceVariant) + } + }, + text = { + Column(Modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) { + SavedRow(stringResource(R.string.soundtracks_create_collection), stringResource(R.string.soundtracks_organise), null, "saved-create", null) { + TextButton(onClick = { naming = true }, modifier = Modifier.focusGlide(CircleShape).testTag("saved-new")) { + Icon(Icons.Filled.Add, contentDescription = null, modifier = Modifier.size(18.dp)) + Text(stringResource(R.string.soundtracks_new)) + } + } + for ((id, name, tracks) in rows) { + val cover = tracks.firstNotNullOfOrNull { t -> t.cover.takeIf { it.isNotEmpty() }?.let { java.io.File(it) }?.takeIf { it.isFile } } + val subtitle = stringResource(R.string.soundtracks_length_value, tracks.size, Soundtrack.formatLength(tracks.sumOf { it.durationMs })) + val added = pending.isNotEmpty() && pending.all { p -> tracks.any { it.path == p.path } } + SavedRow(name, subtitle, cover, "saved-$id", if (pending.isEmpty() && onOpen != null) ({ onDismiss(); onOpen(id) }) else null) { + if (pending.isNotEmpty()) CircleAction(if (added) Icons.Filled.Check else Icons.Filled.Add, name, "saved-add-$id") { + if (added) SoundtrackCollections.remove(ctx, id, pending.map { it.path }.toSet()) + else SoundtrackCollections.add(ctx, id, pending) + } + } + } + } + }, + confirmButton = { TextButton(onClick = onDismiss, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.common_close)) } }, + ) + if (naming) NameDialog( + stringResource(R.string.soundtracks_create_collection), "", stringResource(R.string.soundtracks_create), + onConfirm = { name -> + val id = SoundtrackCollections.create(ctx, name, pending) + if (id != null && pending.isEmpty() && onOpen != null) { onDismiss(); onOpen(id) } + id != null + }, + onDismiss = { naming = false }, + ) +} + +@Composable +private fun SavedRow(title: String, subtitle: String, cover: Any?, tag: String, onClick: (() -> Unit)?, trailing: @Composable () -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) && onClick != null + val shape = RoundedCornerShape(10.dp) + Row( + verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), + modifier = Modifier.fillMaxWidth().testTag(tag).clip(shape).background(if (hot) pal.signal.copy(alpha = 0.12f) else Color.Transparent) + .glideBorder(hot, shape, pal.signal, Color.Transparent) + .then( + if (onClick != null) Modifier.hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick) + .controllerConfirm(onClick = onClick) + else Modifier, + ) + .padding(vertical = 4.dp), + ) { + Box(Modifier.size(52.dp).clip(RoundedCornerShape(8.dp)).background(Color.White.copy(alpha = 0.08f))) { + if (cover != null) AsyncImage(cover, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) + } + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { + Text(title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurface, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text(subtitle, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis) + } + trailing() + } +} + +@Composable +private fun CircleAction(icon: androidx.compose.ui.graphics.vector.ImageVector, label: String, tag: String, onClick: () -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) + Box( + contentAlignment = Alignment.Center, + modifier = Modifier.testTag(tag).size(40.dp).clip(CircleShape).background(if (hot) pal.signal.copy(alpha = 0.16f) else Color.Transparent) + .border(1.dp, if (hot) pal.signal else colors.onSurface.copy(alpha = 0.7f), CircleShape) + .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick) + .controllerConfirm(onClick = onClick) + .semantics { contentDescription = label }, + ) { Icon(icon, contentDescription = null, tint = colors.onSurface, modifier = Modifier.size(20.dp)) } +} + +@Composable +internal fun NameDialog(title: String, initial: String, confirm: String, onConfirm: (String) -> Boolean, onDismiss: () -> Unit) { + var text by remember { mutableStateOf(initial) } + var invalid by remember { mutableStateOf(false) } + val submit: () -> Unit = { + val ok = onConfirm(text) + if (ok) onDismiss() + invalid = !ok + } + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(title) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + AdbTextField( + value = text, onValueChange = { text = it; invalid = false }, label = stringResource(R.string.soundtracks_collection_name), + keyboardType = KeyboardType.Text, imeAction = ImeAction.Done, focusOnShow = true, onDone = submit, + ) + if (invalid) Text(stringResource(R.string.soundtracks_name_invalid), fontSize = 12.sp, color = MaterialTheme.colorScheme.error) + } + }, + confirmButton = { TextButton(onClick = submit, modifier = Modifier.focusGlide(CircleShape).testTag("name-confirm")) { Text(confirm) } }, + dismissButton = { TextButton(onClick = onDismiss, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.common_cancel)) } }, + ) +} + +@Composable +internal fun ManageDialog(id: Int, games: List, onRemoveMode: () -> Unit, onDismiss: () -> Unit) { + val ctx = LocalContext.current + val name = SoundtrackCollections.snapshot.collections.firstOrNull { it.id == id }?.name.orEmpty() + val favorites = id == SoundtrackCollections.FAVORITES_ID + var renaming by remember { mutableStateOf(false) } + var adding by remember { mutableStateOf(false) } + var deleting by remember { mutableStateOf(false) } + val shown = rememberShown(onDismiss) + val close = { shown.targetState = false } + AppDialog(shown, close, "soundtrackManage", wide = false, maxWidth = 420.dp) { + Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) { + DialogTitleRow(stringResource(R.string.soundtracks_manage), onClose = close) + if (!favorites) PickerRow(Icons.Filled.Edit, stringResource(R.string.soundtracks_rename), null) { renaming = true } + PickerRow(Icons.Filled.Add, stringResource(R.string.soundtracks_add_tracks), null) { adding = true } + PickerRow(Icons.Filled.Remove, stringResource(R.string.soundtracks_remove_tracks), null) { onDismiss(); onRemoveMode() } + if (!favorites) PickerRow(Icons.Filled.Delete, stringResource(R.string.soundtracks_delete_collection), null) { deleting = true } + } + } + if (renaming) NameDialog( + stringResource(R.string.soundtracks_rename), name, stringResource(R.string.soundtracks_rename), + onConfirm = { SoundtrackCollections.rename(ctx, id, it) }, onDismiss = { renaming = false }, + ) + if (adding) TrackPickerDialog(id, games) { adding = false } + if (deleting) ConfirmDialog( + title = stringResource(R.string.soundtracks_delete_title, name), text = stringResource(R.string.soundtracks_delete_body), + confirm = stringResource(R.string.common_delete), + onConfirm = { SoundtrackCollections.delete(ctx, id); onDismiss() }, + onDismiss = { deleting = false }, + ) +} + +@Composable +internal fun TrackPickerDialog(id: Int, games: List, onDismiss: () -> Unit) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val hits by produceState?>(null, games) { value = withContext(Dispatchers.IO) { SoundtrackIndex.build(ctx, games) } } + var query by remember { mutableStateOf("") } + var picked by remember { mutableStateOf(setOf()) } + val have = SoundtrackCollections.tracksOf(id).mapTo(HashSet()) { it.path } + val list = hits?.distinctBy { it.ref.path }?.filter { it.ref.path !in have && SoundtrackTracks.matches(query, it.ref.title, it.ref.artist, it.ref.album) } + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringResource(R.string.soundtracks_add_tracks)) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + AdbTextField( + value = query, onValueChange = { query = it }, label = "", keyboardType = KeyboardType.Text, imeAction = ImeAction.Search, + placeholder = stringResource(R.string.soundtracks_search_tracks), compact = true, + ) + Row(horizontalArrangement = Arrangement.spacedBy(4.dp), verticalAlignment = Alignment.CenterVertically) { + TextButton(onClick = { picked = picked + list.orEmpty().map { it.ref.path } }, modifier = Modifier.focusGlide(CircleShape)) { + Text(stringResource(R.string.soundtracks_select_all)) + } + TextButton(onClick = { picked = emptySet() }, modifier = Modifier.focusGlide(CircleShape)) { + Text(stringResource(R.string.soundtracks_deselect_all)) + } + } + if (list == null) Text(stringResource(R.string.store_section_loading), fontSize = 13.sp, color = colors.onSurfaceVariant) + else LazyColumn(Modifier.fillMaxWidth().heightIn(max = 340.dp).testTag("track-picker")) { + items(list, key = { it.ref.path }) { hit -> + val on = hit.ref.path in picked + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) + val toggle = { picked = if (on) picked - hit.ref.path else picked + hit.ref.path } + Row( + verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp), + modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp)).background(if (on) pal.signal.copy(alpha = 0.16f) else if (hot) Color.White.copy(alpha = 0.08f) else Color.Transparent) + .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Checkbox, onClick = toggle) + .controllerConfirm(onClick = toggle).padding(horizontal = 8.dp, vertical = 8.dp), + ) { + Icon( + if (on) Icons.Filled.CheckBox else Icons.Filled.CheckBoxOutlineBlank, contentDescription = null, + tint = if (on) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(20.dp), + ) + Column(Modifier.weight(1f)) { + Text(hit.ref.title, fontSize = 14.sp, color = colors.onSurface, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text( + listOf(hit.ref.album, hit.ref.artist).filter { it.isNotBlank() }.joinToString(" · "), + fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, + ) + } + if (hit.ref.durationMs > 0) Text(Soundtrack.formatLength(hit.ref.durationMs), fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1) + } + } + } + } + }, + confirmButton = { + TextButton( + enabled = picked.isNotEmpty(), + onClick = { + SoundtrackCollections.add(ctx, id, hits.orEmpty().filter { it.ref.path in picked }.map { it.ref }) + onDismiss() + }, + modifier = Modifier.focusGlide(CircleShape).testTag("picker-add"), + ) { Text(stringResource(R.string.soundtracks_add_count, picked.size)) } + }, + dismissButton = { TextButton(onClick = onDismiss, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.common_cancel)) } }, + ) +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackDetail.kt b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackDetail.kt new file mode 100644 index 0000000000..896e94c343 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackDetail.kt @@ -0,0 +1,391 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.LocalIndication +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.hoverable +import androidx.compose.foundation.interaction.MutableInteractionSource +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.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +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.material.icons.Icons +import androidx.compose.material.icons.filled.BookmarkBorder +import androidx.compose.material.icons.filled.Favorite +import androidx.compose.material.icons.filled.FavoriteBorder +import androidx.compose.material.icons.filled.Pause +import androidx.compose.material.icons.filled.PlayArrow +import androidx.compose.material.icons.filled.Repeat +import androidx.compose.material.icons.filled.RepeatOne +import androidx.compose.material.icons.filled.Shuffle +import androidx.compose.material.icons.filled.SkipNext +import androidx.compose.material.icons.filled.SkipPrevious +import androidx.compose.material.icons.filled.VolumeOff +import androidx.compose.material.icons.filled.VolumeUp +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Slider +import androidx.compose.material3.SliderDefaults +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.produceState +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.platform.LocalConfiguration +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.media3.common.Player +import coil.compose.AsyncImage +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.frontend.Soundtrack +import com.droiddeck.launcher.frontend.SoundtrackCollections +import com.droiddeck.launcher.frontend.SoundtrackOrder +import com.droiddeck.launcher.playback.SoundtrackController +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.withContext + +@Composable +internal fun SoundtrackDetail(key: String, s: FrontEndState, a: FrontEndActions, lead: FocusRequester, backLabel: String, onBack: () -> Unit) { + val appId = remember(key) { key.removePrefix("sound:").removePrefix("app:").toIntOrNull() } + val ctx = LocalContext.current + remember { SoundtrackCollections.load(ctx) } + val favoritesLabel = stringResource(R.string.soundtracks_favorites) + val snapshot = SoundtrackCollections.snapshot + val saved = remember(snapshot, favoritesLabel) { SoundtrackCollections.games(ctx, favoritesLabel) } + val game = s.soundtracks.firstOrNull { it.appId == appId } ?: saved.firstOrNull { it.appId == appId } + LaunchedEffect(game == null, s.soundtracksLoaded) { if (game == null && s.soundtracksLoaded) onBack() } + if (game == null) return + val narrow = LocalNarrowPane.current + val stacked = narrow || LocalConfiguration.current.screenWidthDp < 700 + val root = game.gameFiles + val collectionId = if (game.source == Library.SOURCE_COLLECTION) game.appId else null + val target = remember(root, collectionId) { PlayTarget(root, collectionId) } + val loadedAlbum by produceState(null, root, game.art, SoundtrackOrder.version) { + value = root?.let { dir -> withContext(Dispatchers.IO) { Soundtrack.load(ctx, dir, game.art) } } + } + val collectionAlbum = remember(snapshot, collectionId) { collectionId?.let { SoundtrackCollections.album(ctx, it) } } + val album = collectionAlbum ?: loadedAlbum + LaunchedEffect(Unit) { SoundtrackController.connect(ctx) } + val inset = LocalDetailInset.current + val currentTrack = if (target.belongs) SoundtrackController.currentId else null + val trackArt by produceState(null, currentTrack) { + value = currentTrack?.let { id -> withContext(Dispatchers.IO) { Soundtrack.trackCover(ctx, java.io.File(id)) } } + } + val pinned = game.art?.path.orEmpty().let { it.contains("/steam-art/") || it.contains("/soundtrack-art/") } + val art: Any? = if (pinned) game.art else trackArt ?: game.art ?: album?.cover + val refs = remember(snapshot, collectionId) { collectionId?.let { id -> SoundtrackCollections.tracksOf(id).associateBy { it.path } }.orEmpty() } + val coverPath = (game.art ?: album?.cover)?.path.orEmpty() + val refOf: (Soundtrack.Track) -> SoundtrackCollections.TrackRef = { t -> + refs[t.id] ?: SoundtrackCollections.TrackRef(t.id, t.title, t.artist.ifBlank { album?.artist.orEmpty() }, game.name, t.durationMs, coverPath) + } + var selectRequest by remember { mutableIntStateOf(0) } + val onReorder: ((List) -> Unit)? = when { + collectionId != null -> ({ paths: List -> SoundtrackCollections.reorder(ctx, collectionId, paths) }) + game.library == Library.ADDED && root != null -> ({ paths: List -> SoundtrackOrder.set(ctx, root, paths) }) + else -> null + } + GameBackdrop(art, art, hueOf(game.name), fadeTop = inset.top < 8.dp, artBlur = 24.dp) { + Column(Modifier.fillMaxWidth().padding(horizontal = inset.horizontal).padding(top = inset.top)) { + Rise(0) { + Row(Modifier.fillMaxWidth().padding(bottom = 8.dp), verticalAlignment = Alignment.CenterVertically) { + Box(Modifier.glass(CircleShape)) { BackLink(backLabel, compact = true, onClick = onBack) } + Spacer(Modifier.weight(1f)) + SourceBadge(game.source) + } + } + val loaded = album + if (stacked) Column(verticalArrangement = Arrangement.spacedBy(14.dp)) { + Rise(1) { SoundtrackPlayer(game, loaded, art, lead, s, a, target, refOf, collectionId) { selectRequest++ } } + if (loaded != null) Rise(2) { + TrackPanel(loaded, game.name, target, refOf, collectionId, selectRequest, onReorder, Modifier.fillMaxWidth().height((LocalConfiguration.current.screenHeightDp * 0.55f).dp)) + } + } else Row(horizontalArrangement = Arrangement.spacedBy(28.dp), modifier = Modifier.fillMaxWidth()) { + Rise(1, Modifier.weight(0.42f)) { SoundtrackPlayer(game, loaded, art, lead, s, a, target, refOf, collectionId) { selectRequest++ } } + if (loaded != null) Rise(2, Modifier.weight(0.58f)) { + TrackPanel(loaded, game.name, target, refOf, collectionId, selectRequest, onReorder, Modifier.fillMaxWidth().height((LocalConfiguration.current.screenHeightDp * 0.72f).dp)) + } + } + } + } +} + +@Composable +private fun SoundtrackPlayer( + game: Library.SteamGame, album: Soundtrack.Album?, art: Any?, lead: FocusRequester, s: FrontEndState, a: FrontEndActions, + target: PlayTarget, refOf: (Soundtrack.Track) -> SoundtrackCollections.TrackRef, collectionId: Int?, onRemoveMode: () -> Unit, +) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val belongs = target.belongs + val playing = belongs && SoundtrackController.playing + val shownArt: Any? = art + var saving by remember { mutableStateOf(false) } + Column(verticalArrangement = Arrangement.spacedBy(14.dp), modifier = Modifier.fillMaxWidth()) { + Row(horizontalArrangement = Arrangement.spacedBy(16.dp), verticalAlignment = Alignment.Top) { + Box(Modifier.size(120.dp).clip(RoundedCornerShape(10.dp)).background(Color.Black.copy(alpha = 0.35f))) { + if (shownArt != null) AsyncImage(shownArt, contentDescription = game.name, contentScale = ContentScale.Fit, modifier = Modifier.matchParentSize().testTag("soundtrack-cover")) + } + Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.weight(1f)) { + Text( + game.name, fontSize = 22.sp, lineHeight = 26.sp, fontWeight = FontWeight.Black, color = colors.onBackground, + maxLines = 2, overflow = TextOverflow.Ellipsis, + ) + val artist = album?.artist.orEmpty() + if (artist.isNotBlank()) Text(artist, fontSize = 14.sp, color = colors.onBackground.copy(alpha = 0.8f), maxLines = 1, overflow = TextOverflow.Ellipsis) + if (album != null && album.tracks.isNotEmpty()) { + Text( + stringResource(R.string.soundtracks_total_length).uppercase(), fontSize = 11.sp, fontWeight = FontWeight.Bold, letterSpacing = 0.8.sp, + color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 4.dp), + ) + Text( + stringResource(R.string.soundtracks_length_value, album.tracks.size, Soundtrack.formatLength(album.totalMs)), + fontSize = 13.sp, color = colors.onBackground, + ) + } + } + } + Seek(target, album) + val shuffleLabel = stringResource(R.string.soundtracks_shuffle) + val previousLabel = stringResource(R.string.soundtracks_previous) + val playLabel = stringResource(if (playing) R.string.soundtracks_pause else R.string.soundtracks_play) + val nextLabel = stringResource(R.string.soundtracks_next) + val repeatLabel = stringResource( + when (SoundtrackController.repeat) { + Player.REPEAT_MODE_ALL -> R.string.soundtracks_repeat_all + Player.REPEAT_MODE_ONE -> R.string.soundtracks_repeat_one + else -> R.string.soundtracks_repeat_off + }, + ) + val loaded = album?.takeIf { it.tracks.isNotEmpty() } + Row(horizontalArrangement = Arrangement.spacedBy(14.dp, Alignment.CenterHorizontally), verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + TransportButton(Icons.Filled.Shuffle, shuffleLabel, "sound:shuffle", on = belongs && SoundtrackController.shuffle, enabled = loaded != null) { + if (loaded == null) return@TransportButton + if (belongs) SoundtrackController.setShuffle(ctx, !SoundtrackController.shuffle) + else SoundtrackController.play(ctx, loaded, game.name, null, shuffled = true, root = target.root, collection = target.collection) + } + TransportButton(Icons.Filled.SkipPrevious, previousLabel, "sound:previous", enabled = loaded != null) { + if (loaded == null) return@TransportButton + if (belongs) SoundtrackController.previous(ctx) else SoundtrackController.play(ctx, loaded, game.name, null, root = target.root, collection = target.collection) + } + TransportButton( + if (playing) Icons.Filled.Pause else Icons.Filled.PlayArrow, playLabel, "sound:play", big = true, enabled = loaded != null, + modifier = Modifier.focusRequester(lead), + ) { + if (loaded != null) SoundtrackController.toggle(ctx, loaded, game.name, target.root, target.collection) + } + TransportButton(Icons.Filled.SkipNext, nextLabel, "sound:next", enabled = loaded != null) { + if (loaded == null) return@TransportButton + if (belongs) SoundtrackController.next(ctx) else SoundtrackController.play(ctx, loaded, game.name, null, root = target.root, collection = target.collection) + } + TransportButton( + if (SoundtrackController.repeat == Player.REPEAT_MODE_ONE) Icons.Filled.RepeatOne else Icons.Filled.Repeat, repeatLabel, "sound:repeat", + on = SoundtrackController.repeat != Player.REPEAT_MODE_OFF, enabled = loaded != null && belongs, + ) { SoundtrackController.cycleRepeat(ctx) } + } + val heartTrack = if (belongs) loaded?.tracks?.firstOrNull { it.id == SoundtrackController.currentId } else null + val liked = heartTrack != null && SoundtrackCollections.snapshot.favorites.any { it.path == heartTrack.id } + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End, verticalAlignment = Alignment.CenterVertically) { + TransportButton( + if (liked) Icons.Filled.Favorite else Icons.Filled.FavoriteBorder, stringResource(R.string.soundtracks_add_favorites), "sound:favorite", + on = liked, enabled = heartTrack != null, + ) { heartTrack?.let { SoundtrackCollections.toggleFavorite(ctx, refOf(it)) } } + TransportButton(Icons.Filled.BookmarkBorder, stringResource(R.string.soundtracks_saved), "sound:saved", enabled = heartTrack != null) { saving = true } + } + if (saving && heartTrack != null) SavedDialog(listOf(refOf(heartTrack)), null) { saving = false } + Volume() + Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().padding(top = 4.dp)) { + SoundtrackActions(game, s, a, collectionId, onRemoveMode) + } + } +} + +@Composable +private fun Seek(target: PlayTarget, album: Soundtrack.Album?) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val belongs = target.belongs + var position by remember { mutableFloatStateOf(0f) } + var dragging by remember { mutableStateOf(false) } + val duration = if (belongs) SoundtrackController.durationMs else 0L + LaunchedEffect(belongs, SoundtrackController.currentId) { + if (!belongs) { + if (!dragging) position = 0f + return@LaunchedEffect + } + while (true) { + if (!dragging) position = SoundtrackController.position().toFloat() + delay(400) + } + } + Column(verticalArrangement = Arrangement.spacedBy(0.dp), modifier = Modifier.fillMaxWidth()) { + Slider( + value = if (duration > 0) (position / duration).coerceIn(0f, 1f) else 0f, + onValueChange = { dragging = true; position = it * duration }, + onValueChangeFinished = { dragging = false; SoundtrackController.seekTo(ctx, position.toLong()) }, + enabled = belongs && duration > 0 && album != null, + colors = SliderDefaults.colors(thumbColor = pal.signal, activeTrackColor = pal.signal, inactiveTrackColor = colors.onBackground.copy(alpha = 0.18f)), + modifier = Modifier.fillMaxWidth().testTag("soundtrack-seek"), + ) + Row(Modifier.fillMaxWidth().padding(horizontal = 4.dp)) { + Text(Soundtrack.formatLength(position.toLong()), fontSize = 11.sp, color = colors.onSurfaceVariant) + Spacer(Modifier.weight(1f)) + Text(Soundtrack.formatLength(duration), fontSize = 11.sp, color = colors.onSurfaceVariant) + } + } +} + +@Composable +private fun Volume() { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + var level by remember { mutableFloatStateOf(SoundtrackController.volume) } + LaunchedEffect(SoundtrackController.volume) { level = SoundtrackController.volume } + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth()) { + Icon(if (level <= 0.001f) Icons.Filled.VolumeOff else Icons.Filled.VolumeUp, contentDescription = stringResource(R.string.soundtracks_volume), tint = colors.onSurfaceVariant, modifier = Modifier.size(20.dp)) + Slider( + value = level, onValueChange = { level = it; SoundtrackController.setVolume(ctx, it) }, + colors = SliderDefaults.colors(thumbColor = pal.signal, activeTrackColor = pal.signal, inactiveTrackColor = colors.onBackground.copy(alpha = 0.18f)), + modifier = Modifier.weight(1f).testTag("soundtrack-volume"), + ) + } +} + +@Composable +private fun TransportButton( + icon: ImageVector, label: String, id: String, big: Boolean = false, on: Boolean = false, enabled: Boolean = true, + modifier: Modifier = Modifier, onClick: () -> Unit, +) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) && enabled + val size = if (big) 60.dp else 44.dp + val fill = when { + big -> pal.signal.copy(alpha = if (hot) 1f else 0.9f) + hot -> pal.signal.copy(alpha = 0.16f) + else -> Color.Transparent + } + Box( + contentAlignment = Alignment.Center, + modifier = modifier.paneItem(id).testTag(id).size(size).clip(CircleShape).background(fill) + .glideBorder(hot, CircleShape, pal.signal, if (big) Color.Transparent else Color.Transparent) + .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, enabled = enabled, onClick = onClick) + .controllerConfirm(enabled = enabled, onClick = onClick) + .semantics { contentDescription = label }, + ) { + Icon( + icon, contentDescription = null, + tint = when { + big -> colors.background + !enabled -> colors.onSurfaceVariant.copy(alpha = 0.4f) + on -> pal.signal + else -> colors.onBackground + }, + modifier = Modifier.size(if (big) 34.dp else 26.dp), + ) + } +} + +@Composable +private fun SeeMoreButton(label: String, id: String, danger: Boolean = false, modifier: Modifier = Modifier, onClick: () -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) + val shape = RoundedCornerShape(10.dp) + val accent = if (danger) colors.error else pal.signal + Box( + contentAlignment = Alignment.Center, + modifier = modifier.fillMaxWidth().paneItem(id).testTag(id).heightIn(min = 44.dp).clip(shape) + .background(if (hot) accent.copy(alpha = 0.16f) else Color.White.copy(alpha = 0.09f)) + .glideBorder(hot, shape, accent, Color.White.copy(alpha = 0.10f)) + .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick) + .controllerConfirm(onClick = onClick) + .padding(horizontal = 16.dp, vertical = 10.dp), + ) { + Text( + label, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, textAlign = TextAlign.Center, + color = if (danger && hot) colors.error else colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis, + ) + } +} + +@Composable +private fun SoundtrackActions(game: Library.SteamGame, s: FrontEndState, a: FrontEndActions, collectionId: Int?, onRemoveMode: () -> Unit) { + var options by remember { mutableStateOf(false) } + var managing by remember { mutableStateOf(false) } + if (collectionId != null) SeeMoreButton(stringResource(R.string.soundtracks_manage), "sound:manage") { managing = true } + if (managing && collectionId != null) ManageDialog(collectionId, s.soundtracks, onRemoveMode) { managing = false } + SeeMoreButton(stringResource(R.string.soundtracks_options), "sound:options") { options = true } + if (options) SoundtrackOptionsDialog { options = false } + game.gameFiles?.takeIf { it.isDirectory }?.let { dir -> + SeeMoreButton(stringResource(R.string.games_files), "sound:files") { a.onBrowseFiles(dir) } + } + var menu by remember(game.appId) { mutableStateOf(false) } + Box { + SeeMoreButton(stringResource(R.string.game_shortcut), "sound:shortcut") { menu = !menu } + AnchoredMenu(menu, onDismiss = { menu = false }, title = stringResource(R.string.game_shortcut)) { first -> + MenuItem(stringResource(R.string.game_shortcut_add), checked = false, focusRequester = first) { menu = false; a.onGameShortcut(game) } + MenuItem(stringResource(R.string.game_link_copy), checked = false) { menu = false; a.onCopyGameLink(game) } + } + } + var collectionArt by remember(game.appId) { mutableStateOf(false) } + val ownArt = game.library == Library.ADDED + if (ownArt) SeeMoreButton(stringResource(R.string.game_edit_art), "sound:art") { collectionArt = true } + else SeeMoreButton(stringResource(R.string.game_edit_art), "sound:art") { GamesDialogState.steamArt = game } + if (collectionArt && ownArt) CollectionArtEditor( + game.appId, game.name, game.gameFiles, + onClose = { collectionArt = false }, + onChanged = { if (collectionId != null) SoundtrackCollections.refresh() else a.onSoundtracksChanged() }, + ) + if (collectionId != null) return + var asking by remember(game.appId) { mutableStateOf(false) } + val added = game.library == Library.ADDED + val label = stringResource(if (added) R.string.edit_remove else R.string.common_uninstall) + SeeMoreButton(label, "sound:remove", danger = true) { asking = true } + if (asking) ConfirmDialog( + title = if (added) stringResource(R.string.games_remove_title, game.name) else stringResource(R.string.stores_uninstall_title, game.name), + text = if (added) stringResource(R.string.games_remove_body) else stringResource(R.string.games_uninstall_body), + confirm = label, + onConfirm = { a.onSoundtrackRemoved(game) }, + onDismiss = { asking = false }, + ) +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackIcon.kt b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackIcon.kt new file mode 100644 index 0000000000..70c1fd0178 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackIcon.kt @@ -0,0 +1,15 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.SolidColor +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.graphics.vector.addPathNodes +import androidx.compose.ui.unit.dp + +private const val NOTES = "M8.4,4.5 L20,2 V6 L8.4,8.5 Z M8.4,4.5 H10.6 V17.5 H8.4 Z M17.9,2 H20 V15.5 H17.9 Z M7.2,14.7 A3.4,2.8 0 1,0 7.2,20.3 A3.4,2.8 0 1,0 7.2,14.7 Z M16.6,12.7 A3.4,2.8 0 1,0 16.6,18.3 A3.4,2.8 0 1,0 16.6,12.7 Z" + +internal val SoundtrackIcon: ImageVector by lazy { + ImageVector.Builder("Soundtrack", 24.dp, 24.dp, 24f, 24f) + .addPath(addPathNodes(NOTES), fill = SolidColor(Color.Black)) + .build() +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackOptions.kt b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackOptions.kt new file mode 100644 index 0000000000..dc9fadfa28 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackOptions.kt @@ -0,0 +1,217 @@ +package com.droiddeck.launcher.ui + +import android.media.AudioManager +import android.media.audiofx.BassBoost +import android.media.audiofx.Equalizer +import androidx.compose.foundation.background +import androidx.compose.foundation.horizontalScroll +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.rememberScrollState +import androidx.compose.foundation.selection.selectable +import androidx.compose.foundation.selection.toggleable +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Slider +import androidx.compose.material3.SliderDefaults +import androidx.compose.material3.Switch +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.produceState +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Soundtrack +import com.droiddeck.launcher.playback.SoundtrackController +import com.droiddeck.launcher.playback.SoundtrackSettings +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.withContext +import kotlin.math.roundToInt + +private class EqInfo( + val bands: Int, val min: Int, val max: Int, val freqs: List, val presets: List>>, val bassSupported: Boolean, +) + +private fun readEqInfo(audio: AudioManager): EqInfo? = runCatching { + val id = audio.generateAudioSessionId() + val eq = Equalizer(0, id) + try { + val count = eq.numberOfBands.toInt() + val presets = (0 until eq.numberOfPresets.toInt()).map { preset -> + eq.usePreset(preset.toShort()) + eq.getPresetName(preset.toShort()) to (0 until count).map { eq.getBandLevel(it.toShort()).toInt() } + } + val bass = runCatching { BassBoost(0, id).let { b -> try { b.strengthSupported } finally { b.release() } } }.getOrDefault(false) + EqInfo( + count, eq.bandLevelRange[0].toInt(), eq.bandLevelRange[1].toInt(), + (0 until count).map { eq.getCenterFreq(it.toShort()) / 1000 }, presets, bass, + ) + } finally { + eq.release() + } +}.getOrNull() + +@Composable +internal fun SoundtrackOptionsDialog(onDismiss: () -> Unit) { + val ctx = LocalContext.current + LaunchedEffect(Unit) { SoundtrackSettings.load(ctx) } + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringResource(R.string.soundtracks_options)) }, + text = { + Column(Modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(16.dp)) { + RateRow(stringResource(R.string.theme_rgb_speed), SoundtrackSettings.speed, "soundtrack-speed") { SoundtrackController.setSpeed(ctx, it) } + RateRow(stringResource(R.string.soundtracks_pitch), SoundtrackSettings.pitch, "soundtrack-pitch") { SoundtrackController.setPitch(ctx, it) } + SwitchRow(stringResource(R.string.soundtracks_skip_silence), SoundtrackSettings.skipSilence, "soundtrack-skip-silence") { + SoundtrackController.setSkipSilence(ctx, it) + } + SleepSection() + EqualizerSection() + } + }, + confirmButton = { TextButton(onClick = onDismiss, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.common_close)) } }, + ) +} + +@Composable +private fun RateRow(label: String, value: Float, tag: String, onChange: (Float) -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text(label, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurface, modifier = Modifier.weight(1f)) + Text("%.2f×".format(value), fontSize = 14.sp, color = colors.onSurfaceVariant) + TextButton(onClick = { onChange(1f) }, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.soundtracks_reset)) } + } + Slider( + value = value, onValueChange = { v -> (v * 20f).roundToInt().div(20f).let { if (it != value) onChange(it) } }, + valueRange = SoundtrackSettings.MIN_RATE..SoundtrackSettings.MAX_RATE, steps = 29, + colors = SliderDefaults.colors(thumbColor = pal.signal, activeTrackColor = pal.signal, inactiveTrackColor = colors.onSurface.copy(alpha = 0.18f)), + modifier = Modifier.fillMaxWidth().testTag(tag), + ) + } +} + +@Composable +private fun SwitchRow(label: String, checked: Boolean, tag: String, onChange: (Boolean) -> Unit) { + val colors = MaterialTheme.colorScheme + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth().focusGlide(RoundedCornerShape(12.dp)).toggleable(checked, role = Role.Switch, onValueChange = onChange).padding(vertical = 4.dp).testTag(tag), + ) { + Text(label, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurface, modifier = Modifier.weight(1f)) + Switch(checked = checked, onCheckedChange = null) + } +} + +@Composable +private fun OptionChip(label: String, selected: Boolean, onClick: () -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val shape = RoundedCornerShape(99.dp) + Text( + label, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, maxLines = 1, + color = if (selected) pal.signal else colors.onSurface, + modifier = Modifier.focusGlide(shape).clip(shape) + .background(if (selected) pal.signal.copy(alpha = 0.18f) else colors.onSurface.copy(alpha = 0.08f)) + .selectable(selected = selected, role = Role.RadioButton, onClick = onClick) + .padding(horizontal = 14.dp, vertical = 8.dp), + ) +} + +@Composable +private fun SleepSection() { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + var left by remember { mutableLongStateOf(0L) } + LaunchedEffect(Unit) { + while (true) { + left = SoundtrackController.sleepRemainingMs() + delay(1000) + } + } + val trackEnd = SoundtrackController.sleepTrackEnd + val timed = left > 0L + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text(stringResource(R.string.soundtracks_sleep), fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurface, modifier = Modifier.weight(1f)) + if (timed) Text(stringResource(R.string.soundtracks_sleep_left, Soundtrack.formatLength(left)), fontSize = 13.sp, color = colors.onSurfaceVariant) + } + Row(Modifier.horizontalScroll(rememberScrollState()), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + OptionChip(stringResource(R.string.perf_cap_off), !timed && !trackEnd) { SoundtrackController.setSleep(ctx, 0) } + for (minutes in listOf(15, 30, 60)) OptionChip(stringResource(R.string.soundtracks_sleep_minutes, minutes), false) { SoundtrackController.setSleep(ctx, minutes) } + OptionChip(stringResource(R.string.soundtracks_sleep_track_end), trackEnd) { SoundtrackController.setSleep(ctx, -1) } + } + } +} + +@Composable +private fun EqualizerSection() { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val info by produceState(null) { + value = withContext(Dispatchers.IO) { readEqInfo(ctx.getSystemService(AudioManager::class.java)) } + } + val ready = info + val on = SoundtrackSettings.eqOn + val levels = ready?.let { i -> SoundtrackSettings.bands.takeIf { it.size == i.bands } ?: List(i.bands) { 0 } }.orEmpty() + val bass = SoundtrackSettings.bass + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + SwitchRow(stringResource(R.string.soundtracks_equalizer), on && ready != null, "soundtrack-eq") { + if (ready != null) SoundtrackController.setEqualizer(ctx, it, levels, bass) + } + if (ready == null || ready.bands == 0) { + if (ready != null) Text(stringResource(R.string.soundtracks_eq_unavailable), fontSize = 13.sp, color = colors.onSurfaceVariant) + return@Column + } + if (ready.presets.isNotEmpty()) Row(Modifier.horizontalScroll(rememberScrollState()), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + for ((name, preset) in ready.presets) OptionChip(name, on && preset == levels) { SoundtrackController.setEqualizer(ctx, true, preset, bass) } + } + for (band in 0 until ready.bands) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) { + val hz = ready.freqs[band] + Text(if (hz >= 1000) "%.1f kHz".format(hz / 1000f) else "$hz Hz", fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(end = 2.dp)) + Slider( + value = levels[band].toFloat(), valueRange = ready.min.toFloat()..ready.max.toFloat(), + onValueChange = { v -> SoundtrackController.setEqualizer(ctx, true, levels.toMutableList().also { it[band] = v.roundToInt() }, bass) }, + colors = SliderDefaults.colors(thumbColor = pal.signal, activeTrackColor = pal.signal, inactiveTrackColor = colors.onSurface.copy(alpha = 0.18f)), + modifier = Modifier.weight(1f).testTag("soundtrack-eq-$band"), + ) + } + } + if (ready.bassSupported) Column { + Text(stringResource(R.string.soundtracks_bass), fontSize = 13.sp, color = colors.onSurfaceVariant) + Slider( + value = bass.toFloat(), valueRange = 0f..1000f, + onValueChange = { v -> SoundtrackController.setEqualizer(ctx, true, levels, v.roundToInt()) }, + colors = SliderDefaults.colors(thumbColor = pal.signal, activeTrackColor = pal.signal, inactiveTrackColor = colors.onSurface.copy(alpha = 0.18f)), + modifier = Modifier.fillMaxWidth().testTag("soundtrack-bass"), + ) + } + TextButton(onClick = { SoundtrackController.setEqualizer(ctx, on, List(ready.bands) { 0 }, 0) }, modifier = Modifier.focusGlide(CircleShape)) { + Text(stringResource(R.string.soundtracks_reset)) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackTrackPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackTrackPanel.kt new file mode 100644 index 0000000000..c0769536c7 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SoundtrackTrackPanel.kt @@ -0,0 +1,391 @@ +package com.droiddeck.launcher.ui + +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.LocalIndication +import androidx.compose.foundation.background +import androidx.compose.foundation.combinedClickable +import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.hoverable +import androidx.compose.foundation.interaction.MutableInteractionSource +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.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CheckBox +import androidx.compose.material.icons.filled.CheckBoxOutlineBlank +import androidx.compose.material.icons.filled.PlayArrow +import androidx.compose.material.icons.filled.Sort +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.rememberCoroutineScope +import kotlinx.coroutines.launch +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.zIndex +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Soundtrack +import com.droiddeck.launcher.frontend.SoundtrackCollections +import com.droiddeck.launcher.frontend.SoundtrackTracks +import com.droiddeck.launcher.playback.SoundtrackController + +internal class PlayTarget(val root: java.io.File?, val collection: Int?) { + val belongs: Boolean get() = if (collection != null) SoundtrackController.belongsCollection(collection) else SoundtrackController.belongs(root) +} + +private sealed interface SoundRow { + class Disc(val number: Int, val label: String) : SoundRow + class Item(val track: Soundtrack.Track) : SoundRow +} + +private fun rowsOf(album: Soundtrack.Album): List = buildList { + for ((disc, tracks) in album.disc) { + if (album.multiDisc) add(SoundRow.Disc(disc, tracks.firstOrNull()?.discLabel ?: disc.toString())) + tracks.forEach { add(SoundRow.Item(it)) } + } +} + +@Composable +private fun sortLabel(sort: SoundtrackTracks.Sort): String = stringResource( + when (sort) { + SoundtrackTracks.Sort.DEFAULT -> R.string.soundtracks_sort_default + SoundtrackTracks.Sort.TITLE_ASC -> R.string.stores_sort_title_asc + SoundtrackTracks.Sort.TITLE_DESC -> R.string.stores_sort_title_desc + SoundtrackTracks.Sort.LONGEST -> R.string.soundtracks_sort_longest + SoundtrackTracks.Sort.SHORTEST -> R.string.soundtracks_sort_shortest + }, +) + +@Composable +internal fun TrackPanel( + album: Soundtrack.Album, title: String, target: PlayTarget, refOf: (Soundtrack.Track) -> SoundtrackCollections.TrackRef, + collectionId: Int?, selectRequest: Int, onReorder: ((List) -> Unit)?, modifier: Modifier, +) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + var query by remember { mutableStateOf("") } + var sort by remember { mutableStateOf(SoundtrackTracks.Sort.DEFAULT) } + var sortMenu by remember { mutableStateOf(false) } + var selecting by remember { mutableStateOf(false) } + var picked by remember { mutableStateOf(setOf()) } + var saving by remember { mutableStateOf(false) } + val leave: () -> Unit = { + selecting = false + picked = emptySet() + } + LaunchedEffect(selectRequest) { if (selectRequest > 0) selecting = true } + BackHandler(enabled = selecting) { leave() } + val rows: List = remember(album, query, sort) { + if (sort == SoundtrackTracks.Sort.DEFAULT && query.isBlank()) rowsOf(album) + else SoundtrackTracks.sort( + album.tracks.filter { SoundtrackTracks.matches(query, it.title, it.artist) }, sort, { it.title }, { it.durationMs }, + ).map { SoundRow.Item(it) } + } + val rowIds = rows.filterIsInstance().map { it.track.id } + var working by remember(rowIds) { mutableStateOf?>(null) } + val display = working ?: rows + val canReorder = onReorder != null && sort == SoundtrackTracks.Sort.DEFAULT && query.isBlank() && selecting + var dragId by remember { mutableStateOf(null) } + var dragTotal by remember { mutableFloatStateOf(0f) } + var dragTo by remember { mutableIntStateOf(0) } + val numbers = remember(display) { + val out = HashMap() + var n = 0 + for (row in display) { + if (row is SoundRow.Disc) n = 0 + else if (row is SoundRow.Item) out[row.track.id] = ++n + } + out + } + val state = rememberLazyListState() + val scope = rememberCoroutineScope() + val drag = remember { DragState() } + fun applyDrag() { + drag.total = drag.total.coerceIn((drag.lo - drag.from) * drag.size, (drag.hi - drag.from) * drag.size) + dragTotal = drag.total + dragTo = dragTarget(drag.total, drag.size, drag.from, drag.lo, drag.hi) + } + val finishDrag: () -> Unit = { + if (dragId != null) { + val from = drag.from + val to = dragTo + if (to != from && from in drag.base.indices) { + val moved = drag.base.toMutableList().apply { add(to, removeAt(from)) } + val index = state.firstVisibleItemIndex + val offset = state.firstVisibleItemScrollOffset + working = moved + scope.launch { state.scrollToItem(index, offset) } + onReorder?.invoke(moved.filterIsInstance().map { it.track.id }) + } + dragId = null + dragTotal = 0f + dragTo = from + } + } + val rowsNow by rememberUpdatedState(rows) + val finishNow by rememberUpdatedState(finishDrag) + val current = if (target.belongs) SoundtrackController.currentId else null + var scrolledTo by remember { mutableStateOf(null) } + LaunchedEffect(album, current) { + if (current == null) { + scrolledTo = null + return@LaunchedEffect + } + if (dragId != null || current == scrolledTo) return@LaunchedEffect + val at = rows.indexOfFirst { it is SoundRow.Item && it.track.id == current } + if (at >= 0) { + scrolledTo = current + state.animateScrollToItem(at) + } + } + val chosen = album.tracks.filter { it.id in picked }.map(refOf) + Column(modifier) { + Row(Modifier.fillMaxWidth().padding(bottom = 8.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) { + Box(Modifier.weight(1f)) { + AdbTextField( + value = query, onValueChange = { query = it }, label = "", keyboardType = KeyboardType.Text, imeAction = ImeAction.Search, + placeholder = stringResource(R.string.soundtracks_search_tracks), compact = true, + ) + } + Box { + HeaderIconButton(stringResource(R.string.stores_sort), Icons.Filled.Sort, "tracks-sort") { sortMenu = !sortMenu } + AnchoredMenu(sortMenu, onDismiss = { sortMenu = false }, title = stringResource(R.string.stores_sort)) { first -> + SoundtrackTracks.Sort.values().forEachIndexed { i, option -> + MenuItem(sortLabel(option), checked = option == sort, focusRequester = if (i == 0) first else null) { + sort = option + sortMenu = false + } + } + } + } + HeaderIconButton(stringResource(R.string.soundtracks_select), Icons.Filled.CheckBox, "tracks-select") { + if (selecting) leave() else selecting = true + } + } + if (selecting) Row( + Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()).padding(bottom = 6.dp), + horizontalArrangement = Arrangement.spacedBy(2.dp), verticalAlignment = Alignment.CenterVertically, + ) { + Text(stringResource(R.string.soundtracks_selected, picked.size), fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 6.dp)) + TextButton(onClick = { picked = rowIds.toSet() }, modifier = Modifier.focusGlide(CircleShape).testTag("tracks-select-all")) { + Text(stringResource(R.string.soundtracks_select_all)) + } + TextButton(onClick = { picked = emptySet() }, modifier = Modifier.focusGlide(CircleShape).testTag("tracks-deselect-all")) { + Text(stringResource(R.string.soundtracks_deselect_all)) + } + TextButton(enabled = picked.isNotEmpty(), onClick = { saving = true }, modifier = Modifier.focusGlide(CircleShape).testTag("tracks-add-collection")) { + Text(stringResource(R.string.soundtracks_add_to_collection)) + } + TextButton( + enabled = picked.isNotEmpty(), + onClick = { + SoundtrackCollections.add(ctx, SoundtrackCollections.FAVORITES_ID, chosen) + leave() + }, + modifier = Modifier.focusGlide(CircleShape).testTag("tracks-add-favorites"), + ) { Text(stringResource(R.string.soundtracks_add_favorites)) } + if (collectionId != null) TextButton( + enabled = picked.isNotEmpty(), + onClick = { + SoundtrackCollections.remove(ctx, collectionId, picked) + leave() + }, + modifier = Modifier.focusGlide(CircleShape).testTag("tracks-remove"), + ) { Text(stringResource(R.string.soundtracks_remove_from_collection)) } + TextButton(onClick = leave, modifier = Modifier.focusGlide(CircleShape)) { Text(stringResource(R.string.common_cancel)) } + } + if (display.isEmpty()) Text( + stringResource(if (album.tracks.isEmpty()) R.string.soundtracks_no_tracks else R.string.stores_nothing_matches), + fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 12.dp), + ) + else LazyColumn( + state = state, + modifier = Modifier.weight(1f).fillMaxWidth().clip(RoundedCornerShape(10.dp)).background(Color.Black.copy(alpha = 0.28f)).testTag("soundtrack-tracks"), + ) { + items(display, key = { if (it is SoundRow.Item) it.track.id else "disc-${(it as SoundRow.Disc).number}" }) { row -> + when (row) { + is SoundRow.Disc -> Text( + stringResource(R.string.soundtracks_disc, row.label), fontSize = 13.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, + modifier = Modifier.fillMaxWidth().background(Color.White.copy(alpha = 0.12f)).padding(horizontal = 12.dp, vertical = 8.dp), + ) + is SoundRow.Item -> { + val id = row.track.id + val flip = { picked = if (id in picked) picked - id else picked + id } + val dragging = dragId == id + val draggable = canReorder && id in picked + val shift = if (!canReorder) Modifier else Modifier + .zIndex(if (dragging) 1f else 0f) + .graphicsLayer { + translationY = when { + dragId == null -> 0f + dragId == id -> dragTotal + else -> { + val at = drag.index[id] ?: -1 + val f = drag.from + val t = dragTo + if (at < 0) 0f + else if (f < t && at in (f + 1)..t) -drag.size + else if (t < f && at in t until f) drag.size + else 0f + } + } + } + val dragModifier = if (!draggable) shift else shift + .pointerInput(id) { + detectDragGesturesAfterLongPress( + onDragStart = { + val base = working ?: rowsNow + val from = base.indexOfFirst { it is SoundRow.Item && it.track.id == id } + if (from >= 0) { + val disc = (base[from] as SoundRow.Item).track.disc + var lo = from + while (lo > 0 && (base[lo - 1] as? SoundRow.Item)?.track?.disc == disc) lo-- + var hi = from + while (hi < base.lastIndex && (base[hi + 1] as? SoundRow.Item)?.track?.disc == disc) hi++ + val visible = state.layoutInfo.visibleItemsInfo + val me = visible.firstOrNull { it.key == id } + val next = visible.firstOrNull { it.index == (me?.index ?: -2) + 1 && it.key != "disc-0" && base.getOrNull(from + 1) is SoundRow.Item } + val prev = visible.firstOrNull { it.index == (me?.index ?: -2) - 1 && base.getOrNull(from - 1) is SoundRow.Item } + val pitch = when { + me != null && next != null -> (next.offset - me.offset).toFloat() + me != null && prev != null -> (me.offset - prev.offset).toFloat() + else -> me?.size?.toFloat() ?: 0f + } + drag.base = base + drag.index = HashMap().also { m -> base.forEachIndexed { i, r -> if (r is SoundRow.Item) m[r.track.id] = i } } + drag.from = from + drag.lo = lo + drag.hi = hi + drag.size = if (pitch > 0f) pitch else 1f + drag.total = 0f + dragTotal = 0f + dragTo = from + dragId = id + } + }, + onDrag = { change, amount -> + change.consume() + if (dragId == id) { + drag.total += amount.y + applyDrag() + } + }, + onDragEnd = { finishNow() }, + onDragCancel = { finishNow() }, + ) + } + TrackRow( + row.track, numbers[id] ?: row.track.number, dragging, dragModifier, id == current, selecting, id in picked, + onClick = { + if (selecting) flip() + else if (id == current) SoundtrackController.toggle(ctx, album, title, target.root, target.collection) + else SoundtrackController.play(ctx, album, title, id, root = target.root, collection = target.collection) + }, + onLongClick = if (draggable) null else ({ + if (selecting) flip() + else { + selecting = true + picked = setOf(id) + } + }), + ) + } + } + } + } + } + if (saving) SavedDialog(chosen, null) { + saving = false + leave() + } +} + +@OptIn(ExperimentalFoundationApi::class) +@Composable +private fun TrackRow( + track: Soundtrack.Track, number: Int, dragging: Boolean, extra: Modifier, current: Boolean, selecting: Boolean, selected: Boolean, + onClick: () -> Unit, onLongClick: (() -> Unit)?, +) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) + val shape = RoundedCornerShape(8.dp) + val tint = if (current) pal.signal else colors.onBackground + Row( + verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp), + modifier = extra.fillMaxWidth().padding(horizontal = 4.dp, vertical = 1.dp).clip(shape) + .background(if (dragging) pal.signal.copy(alpha = 0.32f) else if (selected) pal.signal.copy(alpha = 0.24f) else if (current) pal.signal.copy(alpha = 0.14f) else if (hot) Color.White.copy(alpha = 0.08f) else Color.Transparent) + .glideBorder(hot, shape, pal.signal, Color.Transparent) + .hoverable(src) + .combinedClickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onLongClick = onLongClick, onClick = onClick) + .controllerConfirm(onClick = onClick) + .padding(horizontal = 10.dp, vertical = 9.dp), + ) { + Box(Modifier.width(28.dp), contentAlignment = Alignment.CenterEnd) { + when { + selecting -> Icon( + if (selected) Icons.Filled.CheckBox else Icons.Filled.CheckBoxOutlineBlank, contentDescription = null, + tint = if (selected) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(20.dp), + ) + current && SoundtrackController.playing -> Icon(Icons.Filled.PlayArrow, contentDescription = null, tint = tint, modifier = Modifier.size(16.dp)) + else -> Text("$number.", fontSize = 13.sp, color = if (current) pal.signal else colors.onSurfaceVariant, maxLines = 1) + } + } + Text( + track.title, fontSize = 14.sp, color = tint, fontWeight = if (current) FontWeight.SemiBold else FontWeight.Normal, + maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f), + ) + if (track.durationMs > 0) Text(Soundtrack.formatLength(track.durationMs), fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1) + } +} + +private class DragState { + var base: List = emptyList() + var index: Map = emptyMap() + var from = 0 + var lo = 0 + var hi = 0 + var size = 1f + var total = 0f +} + +internal fun dragTarget(total: Float, size: Float, from: Int, lo: Int, hi: Int): Int = + (from + Math.round(total / size)).coerceIn(lo, hi) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt index f1afd42c0d..3921df7f32 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt @@ -25,6 +25,8 @@ internal const val FLATHUB = "flathub" internal class SourceColours(val fill: Color, val ink: Color, val dot: Color) +internal val FavoritesColours = SourceColours(Color(0xFF3D1A26), Color(0xFFFFB3C8), Color(0xFFFF5C8A)) + internal fun sourceColours(source: String): SourceColours = when (source) { Store.GOG.id -> SourceColours(Color(0xFF3A1A3C), Color(0xFFE6A3EA), Color(0xFFC25BC8)) Store.EPIC.id -> SourceColours(Color(0xFF2A2A2A), Color(0xFFDDDDDD), Color(0xFFBDBDBD)) @@ -37,6 +39,7 @@ internal fun sourceColours(source: String): SourceColours = when (source) { Store.EA.id -> SourceColours(Color(0xFF3A0E12), Color(0xFFFF9A9A), Color(0xFFFF4747)) Store.ROCKSTAR.id -> SourceColours(Color(0xFF3A2A06), Color(0xFFFFD780), Color(0xFFFCAF17)) Library.SOURCE_STEAM -> SourceColours(Color(0xFF16293D), Color(0xFF7CC4FF), Color(0xFF1A9FFF)) + Library.SOURCE_COLLECTION -> SourceColours(Color(0xFF2B1A3D), Color(0xFFD2A8FF), Color(0xFFA25BFF)) FLATHUB -> SourceColours(Color(0xFF0B2E2B), Color(0xFF9FE3DD), FlathubTeal) else -> SourceColours(Color(0xFF1A1D22), Color(0xFF9AA3AF), Color(0xFF9AA3AF)) } @@ -44,6 +47,7 @@ internal fun sourceColours(source: String): SourceColours = when (source) { @Composable internal fun sourceLabel(source: String): String = when (source) { Library.SOURCE_STEAM -> stringResource(R.string.source_steam) + Library.SOURCE_COLLECTION -> stringResource(R.string.soundtracks_collections) Store.GOG.id -> Store.GOG.label Store.EPIC.id -> Store.EPIC.label Store.AMAZON.id -> Store.AMAZON.label @@ -58,10 +62,10 @@ internal fun sourceLabel(source: String): String = when (source) { } @Composable -internal fun SourceChip(source: String, small: Boolean = false, modifier: Modifier = Modifier) { - val c = sourceColours(source) +internal fun SourceChip(source: String, small: Boolean = false, modifier: Modifier = Modifier, label: String? = null, colours: SourceColours? = null) { + val c = colours ?: sourceColours(source) Text( - sourceLabel(source), fontSize = if (small) 10.sp else 11.sp, fontWeight = FontWeight.Bold, letterSpacing = 0.4.sp, + label ?: sourceLabel(source), fontSize = if (small) 10.sp else 11.sp, fontWeight = FontWeight.Bold, letterSpacing = 0.4.sp, color = c.ink, maxLines = 1, modifier = modifier.clip(RoundedCornerShape(6.dp)).background(c.fill) .padding(horizontal = if (small) 6.dp else 8.dp, vertical = if (small) 1.dp else 2.dp), diff --git a/app/src/main/res/drawable/ic_repeat_all.xml b/app/src/main/res/drawable/ic_repeat_all.xml new file mode 100644 index 0000000000..c696a476a6 --- /dev/null +++ b/app/src/main/res/drawable/ic_repeat_all.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/drawable/ic_repeat_off.xml b/app/src/main/res/drawable/ic_repeat_off.xml new file mode 100644 index 0000000000..e989d57d7b --- /dev/null +++ b/app/src/main/res/drawable/ic_repeat_off.xml @@ -0,0 +1,11 @@ + + + + diff --git a/app/src/main/res/drawable/ic_repeat_one.xml b/app/src/main/res/drawable/ic_repeat_one.xml new file mode 100644 index 0000000000..fda860fcc2 --- /dev/null +++ b/app/src/main/res/drawable/ic_repeat_one.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/drawable/ic_shuffle_off.xml b/app/src/main/res/drawable/ic_shuffle_off.xml new file mode 100644 index 0000000000..3ede806a20 --- /dev/null +++ b/app/src/main/res/drawable/ic_shuffle_off.xml @@ -0,0 +1,11 @@ + + + + diff --git a/app/src/main/res/drawable/ic_shuffle_on.xml b/app/src/main/res/drawable/ic_shuffle_on.xml new file mode 100644 index 0000000000..8f62d5de55 --- /dev/null +++ b/app/src/main/res/drawable/ic_shuffle_on.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/drawable/ic_soundtrack.xml b/app/src/main/res/drawable/ic_soundtrack.xml new file mode 100644 index 0000000000..00839efe01 --- /dev/null +++ b/app/src/main/res/drawable/ic_soundtrack.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 36d31630f5..f92ce94ee7 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -3839,4 +3839,67 @@ ثلج قرمزي + الموسيقى التصويرية + الموسيقى + خيارات التشغيل + المفضلة + المجموعات + لا توجد مجموعات بعد. اضغط على أيقونة الإشارة المرجعية لإنشاء مجموعة. + المحفوظات + إنشاء مجموعة + نظّم ما حفظته + جديد + إنشاء + اسم المجموعة + أدخل اسمًا لا تستخدمه أي مجموعة أخرى + إدارة + إعادة تسمية + إضافة مقاطع + إضافة (%1$d) + إزالة مقاطع + حذف المجموعة + حذف %1$s؟ + تبقى المقاطع على جهازك. تتم إزالة المجموعة فقط. + تحديد + تحديد الكل + إلغاء تحديد الكل + تم تحديد %1$d + إضافة إلى مجموعة + إضافة إلى المفضلة + إزالة من المجموعة + ابحث في المقاطع + ترتيب الألبوم + الأطول أولًا + الأقصر أولًا + المقاطع + طبقة الصوت + إعادة ضبط + تخطي الصمت + مؤقت النوم + %1$d د + نهاية المقطع + متبقي %1$s + المعادل + تعزيز الجهير + المعادل غير متاح على هذا الجهاز + الموسيقى التصويرية + تفعيل أثناء اللعب + استمر في تشغيل الموسيقى التصويرية أثناء تشغيل اللعبة + لا توجد موسيقى تصويرية مثبّتة بعد. + ابحث في الموسيقى التصويرية + إضافة مجلد موسيقى تصويرية + لا توجد ملفات صوتية في هذا المجلد + المدة الإجمالية + %1$d مقطعًا / %2$s + القرص %1$s + عشوائي + السابق + تشغيل + إيقاف مؤقت + التالي + التكرار متوقف + تكرار الكل + تكرار مقطع واحد + مستوى الصوت + لا توجد ملفات صوتية في هذه الموسيقى التصويرية diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index d9ef13c8b1..5139e4953d 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -3694,4 +3694,67 @@ No se pudo importar esta disposición Nieve escarlata Superficies blancas con acentos rojos. + Bandas sonoras + Música + Opciones de reproducción + Favoritos + Colecciones + Aún no hay colecciones. Toca el ícono de marcador para crear una. + Guardados + Crear una colección + Organiza tus guardados + Nueva + Crear + Nombre de la colección + Ingresa un nombre que no use ninguna otra colección + Administrar + Cambiar nombre + Agregar pistas + Agregar (%1$d) + Quitar pistas + Eliminar colección + ¿Eliminar %1$s? + Las pistas permanecen en tu dispositivo. Solo se elimina la colección. + Seleccionar + Seleccionar todo + Deseleccionar todo + %1$d seleccionadas + Agregar a la colección + Agregar a favoritos + Quitar de la colección + Buscar pistas + Orden del álbum + Más largas primero + Más cortas primero + Pistas + Tono + Restablecer + Omitir silencios + Temporizador de sueño + %1$d min + Fin de la pista + Quedan %1$s + Ecualizador + Refuerzo de graves + El ecualizador no está disponible en este dispositivo + Bandas sonoras + Activar en el juego + Mantén la banda sonora sonando mientras se ejecuta un juego + Aún no hay bandas sonoras instaladas. + Buscar bandas sonoras + Añadir una carpeta de banda sonora + No hay archivos de audio en esa carpeta + Duración total + %1$d pistas / %2$s + Disco %1$s + Aleatorio + Anterior + Reproducir + Pausar + Siguiente + Repetición desactivada + Repetir todo + Repetir una + Volumen + No hay archivos de audio en esta banda sonora diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index 55449ac2f4..4b446b2140 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -3683,4 +3683,67 @@ Ален сняг + Саундтраци + Музика + Опции за възпроизвеждане + Любими + Колекции + Все още няма колекции. Докоснете иконата на отметка, за да създадете. + Запазени + Създаване на колекция + Организирайте запазеното + Нова + Създай + Име на колекцията + Въведете име, което не се използва от друга колекция + Управление + Преименуване + Добавяне на песни + Добави (%1$d) + Премахване на песни + Изтриване на колекция + Да се изтрие ли %1$s? + Песните остават на устройството ви. Премахва се само колекцията. + Избор + Избери всички + Отмени избора на всички + Избрани: %1$d + Добави към колекция + Добави в любими + Премахни от колекцията + Търсене на песни + Като в албума + Най-дългите първо + Най-кратките първо + Песни + Височина на тона + Нулиране + Прескачане на тишина + Таймер за заспиване + %1$d мин + Край на песента + Остават %1$s + Еквалайзер + Усилване на басите + Еквалайзерът не е наличен на това устройство + Саундтраци + Включи в играта + Саундтракът да продължи да свири, докато върви игра + Все още няма инсталирани саундтраци. + Търсене на саундтраци + Добавяне на папка със саундтрак + В тази папка няма аудиофайлове + Обща продължителност + %1$d песни / %2$s + Диск %1$s + Разбъркване + Предишна + Пускане + Пауза + Следваща + Повторението е изключено + Повтаряне на всички + Повтаряне на една + Сила на звука + В този саундтрак няма аудиофайлове diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 35282822a5..365c2f1083 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -3761,4 +3761,67 @@ Šarlatový sníh + Soundtracky + Hudba + Možnosti přehrávání + Oblíbené + Kolekce + Zatím žádné kolekce. Klepnutím na ikonu záložky nějakou vytvoříte. + Uloženo + Vytvořit kolekci + Uspořádejte si uložené skladby + Nová + Vytvořit + Název kolekce + Zadejte název, který nepoužívá žádná jiná kolekce + Spravovat + Přejmenovat + Přidat skladby + Přidat (%1$d) + Odebrat skladby + Smazat kolekci + Smazat %1$s? + Skladby zůstanou ve vašem zařízení. Odstraní se pouze kolekce. + Vybrat + Vybrat vše + Zrušit výběr + Vybráno: %1$d + Přidat do kolekce + Přidat do oblíbených + Odebrat z kolekce + Hledat skladby + Pořadí alba + Nejdelší první + Nejkratší první + Skladby + Výška tónu + Obnovit + Přeskakovat ticho + Časovač vypnutí + %1$d min + Konec skladby + Zbývá %1$s + Ekvalizér + Zesílení basů + Ekvalizér není na tomto zařízení k dispozici + Soundtracky + Povolit ve hře + Nechat soundtrack hrát během hry + Zatím nejsou nainstalovány žádné soundtracky. + Hledat soundtracky + Přidat složku se soundtrackem + V této složce nejsou žádné zvukové soubory + Celková délka + Skladeb: %1$d / %2$s + Disk %1$s + Náhodně + Předchozí + Přehrát + Pozastavit + Další + Opakování vypnuto + Opakovat vše + Opakovat jednu + Hlasitost + V tomto soundtracku nejsou žádné zvukové soubory diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 7a5aa072ef..83ee1c91f4 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -3683,4 +3683,67 @@ Skarlagensne + Soundtracks + Musik + Afspilningsindstillinger + Favoritter + Samlinger + Ingen samlinger endnu. Tryk på bogmærkeikonet for at oprette en. + Gemt + Opret en samling + Organiser dine gemte numre + Ny + Opret + Navn på samling + Angiv et navn, som ingen anden samling bruger + Administrer + Omdøb + Tilføj numre + Tilføj (%1$d) + Fjern numre + Slet samling + Slet %1$s? + Numrene bliver på din enhed. Kun samlingen fjernes. + Vælg + Vælg alle + Fravælg alle + %1$d valgt + Føj til samling + Føj til favoritter + Fjern fra samling + Søg i numre + Albumrækkefølge + Længste først + Korteste først + Numre + Tonehøjde + Nulstil + Spring stilhed over + Sovetimer + %1$d min. + Slut på nummer + %1$s tilbage + Equalizer + Bassforstærkning + Equalizeren er ikke tilgængelig på denne enhed + Soundtracks + Aktivér i spil + Lad soundtracket spille, mens et spil kører + Ingen soundtracks installeret endnu. + Søg i soundtracks + Tilføj en soundtrack-mappe + Ingen lydfiler i den mappe + Samlet længde + %1$d numre / %2$s + Disk %1$s + Bland + Forrige + Afspil + Pause + Næste + Gentag fra + Gentag alle + Gentag én + Lydstyrke + Ingen lydfiler i dette soundtrack diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 1d15db3d88..3ed4aa1f1b 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -3683,4 +3683,67 @@ Scharlachroter Schnee + Soundtracks + Musik + Wiedergabeoptionen + Favoriten + Sammlungen + Noch keine Sammlungen. Tippe auf das Lesezeichen-Symbol, um eine zu erstellen. + Gespeichert + Sammlung erstellen + Ordne deine gespeicherten Titel + Neu + Erstellen + Name der Sammlung + Gib einen Namen ein, den keine andere Sammlung verwendet + Verwalten + Umbenennen + Titel hinzufügen + Hinzufügen (%1$d) + Titel entfernen + Sammlung löschen + %1$s löschen? + Die Titel bleiben auf deinem Gerät. Nur die Sammlung wird entfernt. + Auswählen + Alle auswählen + Alle abwählen + %1$d ausgewählt + Zur Sammlung hinzufügen + Zu Favoriten hinzufügen + Aus Sammlung entfernen + Titel suchen + Albumreihenfolge + Längste zuerst + Kürzeste zuerst + Titel + Tonhöhe + Zurücksetzen + Stille überspringen + Schlaftimer + %1$d Min. + Ende des Titels + Noch %1$s + Equalizer + Bassverstärkung + Der Equalizer ist auf diesem Gerät nicht verfügbar + Soundtracks + Im Spiel aktivieren + Soundtrack während eines Spiels weiterspielen + Noch keine Soundtracks installiert. + Soundtracks durchsuchen + Soundtrack-Ordner hinzufügen + Keine Audiodateien in diesem Ordner + Gesamtlänge + %1$d Titel / %2$s + Disc %1$s + Zufällig + Zurück + Wiedergabe + Pause + Weiter + Wiederholen aus + Alle wiederholen + Titel wiederholen + Lautstärke + Keine Audiodateien in diesem Soundtrack diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 27692a1325..d9e2ac10e8 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -3683,4 +3683,67 @@ Κατακόκκινο χιόνι + Soundtrack + Μουσική + Επιλογές αναπαραγωγής + Αγαπημένα + Συλλογές + Δεν υπάρχουν συλλογές ακόμη. Πατήστε το εικονίδιο σελιδοδείκτη για να δημιουργήσετε μία. + Αποθηκευμένα + Δημιουργία συλλογής + Οργανώστε τα αποθηκευμένα σας + Νέα + Δημιουργία + Όνομα συλλογής + Εισαγάγετε ένα όνομα που δεν χρησιμοποιεί άλλη συλλογή + Διαχείριση + Μετονομασία + Προσθήκη κομματιών + Προσθήκη (%1$d) + Κατάργηση κομματιών + Διαγραφή συλλογής + Διαγραφή %1$s; + Τα κομμάτια παραμένουν στη συσκευή σας. Καταργείται μόνο η συλλογή. + Επιλογή + Επιλογή όλων + Αποεπιλογή όλων + %1$d επιλεγμένα + Προσθήκη στη συλλογή + Προσθήκη στα αγαπημένα + Κατάργηση από τη συλλογή + Αναζήτηση κομματιών + Σειρά άλμπουμ + Μεγαλύτερη διάρκεια πρώτα + Μικρότερη διάρκεια πρώτα + Κομμάτια + Τόνος + Επαναφορά + Παράλειψη σιωπής + Χρονοδιακόπτης ύπνου + %1$d λ. + Τέλος κομματιού + Απομένουν %1$s + Ισοσταθμιστής + Ενίσχυση μπάσων + Ο ισοσταθμιστής δεν είναι διαθέσιμος σε αυτή τη συσκευή + Soundtrack + Ενεργοποίηση εντός παιχνιδιού + Η μουσική συνεχίζει να παίζει όσο εκτελείται ένα παιχνίδι + Δεν υπάρχουν εγκατεστημένα soundtrack ακόμη. + Αναζήτηση soundtrack + Προσθήκη φακέλου soundtrack + Δεν υπάρχουν αρχεία ήχου σε αυτόν τον φάκελο + Συνολική διάρκεια + %1$d κομμάτια / %2$s + Δίσκος %1$s + Τυχαία σειρά + Προηγούμενο + Αναπαραγωγή + Παύση + Επόμενο + Επανάληψη ανενεργή + Επανάληψη όλων + Επανάληψη ενός + Ένταση + Δεν υπάρχουν αρχεία ήχου σε αυτό το soundtrack diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index adea64b8f4..7fa671b3ce 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -3722,4 +3722,67 @@ Nieve escarlata + Bandas sonoras + Música + Opciones de reproducción + Favoritos + Colecciones + Aún no hay colecciones. Toca el icono de marcador para crear una. + Guardados + Crear una colección + Organiza tus guardados + Nueva + Crear + Nombre de la colección + Introduce un nombre que no use ninguna otra colección + Gestionar + Cambiar nombre + Añadir pistas + Añadir (%1$d) + Quitar pistas + Eliminar colección + ¿Eliminar %1$s? + Las pistas permanecen en tu dispositivo. Solo se elimina la colección. + Seleccionar + Seleccionar todo + Deseleccionar todo + %1$d seleccionadas + Añadir a la colección + Añadir a favoritos + Quitar de la colección + Buscar pistas + Orden del álbum + Más largas primero + Más cortas primero + Pistas + Tono + Restablecer + Omitir silencios + Temporizador de sueño + %1$d min + Fin de la pista + Quedan %1$s + Ecualizador + Refuerzo de graves + El ecualizador no está disponible en este dispositivo + Bandas sonoras + Activar en el juego + Mantén la banda sonora sonando mientras se ejecuta un juego + Aún no hay bandas sonoras instaladas. + Buscar bandas sonoras + Añadir una carpeta de banda sonora + No hay archivos de audio en esa carpeta + Duración total + %1$d pistas / %2$s + Disco %1$s + Aleatorio + Anterior + Reproducir + Pausar + Siguiente + Repetición desactivada + Repetir todo + Repetir una + Volumen + No hay archivos de audio en esta banda sonora diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 481ed7ca5c..222896d3e6 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -3683,4 +3683,67 @@ Helakanpunainen lumi + Soundtrackit + Musiikki + Toistoasetukset + Suosikit + Kokoelmat + Ei vielä kokoelmia. Luo sellainen napauttamalla kirjanmerkkikuvaketta. + Tallennettu + Luo kokoelma + Järjestä tallennuksesi + Uusi + Luo + Kokoelman nimi + Anna nimi, jota mikään toinen kokoelma ei käytä + Hallitse + Nimeä uudelleen + Lisää kappaleita + Lisää (%1$d) + Poista kappaleita + Poista kokoelma + Poistetaanko %1$s? + Kappaleet säilyvät laitteellasi. Vain kokoelma poistetaan. + Valitse + Valitse kaikki + Poista kaikkien valinta + %1$d valittu + Lisää kokoelmaan + Lisää suosikkeihin + Poista kokoelmasta + Hae kappaleita + Albumin järjestys + Pisin ensin + Lyhin ensin + Kappaleet + Äänenkorkeus + Palauta + Ohita hiljaisuus + Uniajastin + %1$d min + Kappaleen loppu + %1$s jäljellä + Taajuuskorjain + Bassonkorostus + Taajuuskorjain ei ole käytettävissä tällä laitteella + Soundtrackit + Ota käyttöön pelin aikana + Pidä soundtrack soimassa pelin aikana + Soundtrackeja ei ole vielä asennettu. + Hae soundtrackeja + Lisää soundtrack-kansio + Kansiossa ei ole äänitiedostoja + Kokonaiskesto + %1$d kappaletta / %2$s + Levy %1$s + Sekoita + Edellinen + Toista + Tauko + Seuraava + Toisto pois + Toista kaikki + Toista yksi + Äänenvoimakkuus + Tässä soundtrackissa ei ole äänitiedostoja diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 61accc73a6..20c091baca 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -3722,4 +3722,67 @@ Neige écarlate + Bandes originales + Musique + Options de lecture + Favoris + Collections + Aucune collection pour le moment. Touchez l\'icône de favori pour en créer une. + Enregistrés + Créer une collection + Organisez vos titres enregistrés + Nouvelle + Créer + Nom de la collection + Saisissez un nom qu\'aucune autre collection n\'utilise + Gérer + Renommer + Ajouter des morceaux + Ajouter (%1$d) + Retirer des morceaux + Supprimer la collection + Supprimer %1$s ? + Les morceaux restent sur votre appareil. Seule la collection est supprimée. + Sélectionner + Tout sélectionner + Tout désélectionner + %1$d sélectionné(s) + Ajouter à une collection + Ajouter aux favoris + Retirer de la collection + Rechercher des morceaux + Ordre de l\'album + Plus longs d\'abord + Plus courts d\'abord + Morceaux + Hauteur + Réinitialiser + Ignorer les silences + Minuteur de veille + %1$d min + Fin du morceau + %1$s restantes + Égaliseur + Renforcement des basses + L\'égaliseur n\'est pas disponible sur cet appareil + Bandes originales + Activer en jeu + Garder la bande originale active pendant une partie + Aucune bande originale installée pour le moment. + Rechercher des bandes originales + Ajouter un dossier de bande originale + Aucun fichier audio dans ce dossier + Durée totale + %1$d pistes / %2$s + Disque %1$s + Aléatoire + Précédent + Lecture + Pause + Suivant + Répétition désactivée + Tout répéter + Répéter une piste + Volume + Aucun fichier audio dans cette bande originale diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 72f0917b03..4046306fe4 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -3683,4 +3683,67 @@ किरमिज़ी बर्फ + साउंडट्रैक + संगीत + प्लेबैक विकल्प + पसंदीदा + कलेक्शन + अभी तक कोई कलेक्शन नहीं है। बनाने के लिए बुकमार्क आइकन पर टैप करें। + सहेजे गए + कलेक्शन बनाएं + अपने सेव व्यवस्थित करें + नया + बनाएं + कलेक्शन का नाम + ऐसा नाम दर्ज करें जो किसी अन्य कलेक्शन में उपयोग न हुआ हो + प्रबंधित करें + नाम बदलें + ट्रैक जोड़ें + जोड़ें (%1$d) + ट्रैक हटाएं + कलेक्शन हटाएं + %1$s हटाएं? + ट्रैक आपके डिवाइस पर रहेंगे। केवल कलेक्शन हटाया जाएगा। + चुनें + सभी चुनें + सभी चयन हटाएं + %1$d चुने गए + कलेक्शन में जोड़ें + पसंदीदा में जोड़ें + कलेक्शन से हटाएं + ट्रैक खोजें + एल्बम क्रम + सबसे लंबे पहले + सबसे छोटे पहले + ट्रैक + पिच + रीसेट करें + मौन छोड़ें + स्लीप टाइमर + %1$d मिनट + ट्रैक का अंत + %1$s शेष + इक्वलाइज़र + बास बूस्ट + इस डिवाइस पर इक्वलाइज़र उपलब्ध नहीं है + साउंडट्रैक + गेम के दौरान चालू करें + गेम चलते समय साउंडट्रैक बजता रखें + अभी तक कोई साउंडट्रैक इंस्टॉल नहीं है। + साउंडट्रैक खोजें + साउंडट्रैक फ़ोल्डर जोड़ें + उस फ़ोल्डर में कोई ऑडियो फ़ाइल नहीं है + कुल अवधि + %1$d ट्रैक / %2$s + डिस्क %1$s + शफ़ल + पिछला + चलाएँ + रोकें + अगला + रिपीट बंद + सभी दोहराएँ + एक दोहराएँ + वॉल्यूम + इस साउंडट्रैक में कोई ऑडियो फ़ाइल नहीं है diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index 409a9e72f8..4a2c408ac7 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -3683,4 +3683,67 @@ Skarlátvörös hó + Soundtrackek + Zene + Lejátszási beállítások + Kedvencek + Gyűjtemények + Még nincs gyűjtemény. Koppints a könyvjelző ikonra egy létrehozásához. + Mentve + Gyűjtemény létrehozása + Rendezd a mentéseidet + Új + Létrehozás + Gyűjtemény neve + Adj meg egy nevet, amelyet más gyűjtemény nem használ + Kezelés + Átnevezés + Számok hozzáadása + Hozzáadás (%1$d) + Számok eltávolítása + Gyűjtemény törlése + Törlöd ezt: %1$s? + A számok az eszközödön maradnak. Csak a gyűjtemény törlődik. + Kijelölés + Összes kijelölése + Kijelölés törlése + %1$d kijelölve + Hozzáadás gyűjteményhez + Hozzáadás a kedvencekhez + Eltávolítás a gyűjteményből + Számok keresése + Albumsorrend + Leghosszabb elöl + Legrövidebb elöl + Számok + Hangmagasság + Visszaállítás + Csend átugrása + Alvásidőzítő + %1$d perc + Szám vége + %1$s van hátra + Hangszínszabályzó + Mélyhangerősítés + A hangszínszabályzó nem érhető el ezen az eszközön + Soundtrackek + Engedélyezés játék közben + A soundtrack szóljon tovább játék közben + Még nincs telepített soundtrack. + Soundtrackek keresése + Soundtrack mappa hozzáadása + Nincs hangfájl ebben a mappában + Teljes hossz + %1$d szám / %2$s + %1$s. lemez + Keverés + Előző + Lejátszás + Szünet + Következő + Ismétlés kikapcsolva + Összes ismétlése + Egy ismétlése + Hangerő + Nincs hangfájl ebben a soundtrackben diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 81ded51384..d71b8f83f1 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -3653,4 +3653,67 @@ Salju Kirmizi + Soundtrack + Musik + Opsi pemutaran + Favorit + Koleksi + Belum ada koleksi. Ketuk ikon penanda untuk membuatnya. + Tersimpan + Buat koleksi + Atur simpananmu + Baru + Buat + Nama koleksi + Masukkan nama yang tidak dipakai koleksi lain + Kelola + Ganti nama + Tambah lagu + Tambah (%1$d) + Hapus lagu + Hapus koleksi + Hapus %1$s? + Lagu tetap ada di perangkatmu. Hanya koleksinya yang dihapus. + Pilih + Pilih semua + Batalkan semua pilihan + %1$d dipilih + Tambahkan ke koleksi + Tambahkan ke favorit + Hapus dari koleksi + Cari lagu + Urutan album + Terpanjang dulu + Terpendek dulu + Lagu + Nada + Atur ulang + Lewati keheningan + Timer tidur + %1$d mnt + Akhir lagu + Sisa %1$s + Ekualiser + Penguat bass + Ekualiser tidak tersedia di perangkat ini + Soundtrack + Aktifkan saat bermain + Tetap putar soundtrack saat game berjalan + Belum ada soundtrack yang terpasang. + Cari soundtrack + Tambahkan folder soundtrack + Tidak ada file audio di folder itu + Total durasi + %1$d trek / %2$s + Disk %1$s + Acak + Sebelumnya + Putar + Jeda + Berikutnya + Ulangi mati + Ulangi semua + Ulangi satu + Volume + Tidak ada file audio di soundtrack ini diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index f8f6c7866c..e5a9d021e2 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -3722,4 +3722,67 @@ Neve scarlatta + Colonne sonore + Musica + Opzioni di riproduzione + Preferiti + Raccolte + Nessuna raccolta per ora. Tocca l\'icona del segnalibro per crearne una. + Salvati + Crea una raccolta + Organizza i tuoi salvataggi + Nuova + Crea + Nome della raccolta + Inserisci un nome non usato da altre raccolte + Gestisci + Rinomina + Aggiungi brani + Aggiungi (%1$d) + Rimuovi brani + Elimina raccolta + Eliminare %1$s? + I brani restano sul dispositivo. Viene rimossa solo la raccolta. + Seleziona + Seleziona tutto + Deseleziona tutto + %1$d selezionati + Aggiungi alla raccolta + Aggiungi ai preferiti + Rimuovi dalla raccolta + Cerca brani + Ordine dell\'album + Più lunghi prima + Più brevi prima + Brani + Tonalità + Reimposta + Salta i silenzi + Timer di spegnimento + %1$d min + Fine del brano + Restano %1$s + Equalizzatore + Potenziamento bassi + L\'equalizzatore non è disponibile su questo dispositivo + Colonne sonore + Attiva in gioco + Mantieni la colonna sonora in riproduzione durante una partita + Nessuna colonna sonora installata. + Cerca colonne sonore + Aggiungi una cartella di colonna sonora + Nessun file audio in questa cartella + Durata totale + %1$d brani / %2$s + Disco %1$s + Casuale + Precedente + Riproduci + Pausa + Successivo + Ripetizione disattivata + Ripeti tutto + Ripeti uno + Volume + Nessun file audio in questa colonna sonora diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index fe43ef5ee0..bd0e241e4e 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -3653,4 +3653,67 @@ 緋色の雪 + サウンドトラック + 音楽 + 再生オプション + お気に入り + コレクション + コレクションはまだありません。ブックマークアイコンをタップして作成できます。 + 保存済み + コレクションを作成 + 保存した曲を整理 + 新規 + 作成 + コレクション名 + 他のコレクションで使われていない名前を入力してください + 管理 + 名前を変更 + トラックを追加 + 追加(%1$d) + トラックを削除 + コレクションを削除 + %1$sを削除しますか? + トラックはデバイスに残ります。コレクションのみが削除されます。 + 選択 + すべて選択 + すべて選択解除 + %1$d件選択中 + コレクションに追加 + お気に入りに追加 + コレクションから削除 + トラックを検索 + アルバム順 + 長い順 + 短い順 + トラック + ピッチ + リセット + 無音部分をスキップ + スリープタイマー + %1$d分 + トラックの終わり + 残り %1$s + イコライザー + 低音ブースト + このデバイスではイコライザーを使用できません + サウンドトラック + ゲーム中も有効にする + ゲーム実行中もサウンドトラックを再生し続けます + インストール済みのサウンドトラックはまだありません。 + サウンドトラックを検索 + サウンドトラックのフォルダーを追加 + そのフォルダーに音声ファイルがありません + 合計時間 + %1$d トラック / %2$s + ディスク %1$s + シャッフル + 前へ + 再生 + 一時停止 + 次へ + リピートなし + 全曲リピート + 1曲リピート + 音量 + このサウンドトラックに音声ファイルがありません diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index e00a044135..4fadd28078 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -3653,4 +3653,67 @@ 진홍빛 눈 + 사운드트랙 + 음악 + 재생 옵션 + 즐겨찾기 + 컬렉션 + 아직 컬렉션이 없습니다. 북마크 아이콘을 눌러 만들어 보세요. + 저장됨 + 컬렉션 만들기 + 저장한 곡을 정리하세요 + 새로 만들기 + 만들기 + 컬렉션 이름 + 다른 컬렉션에서 사용하지 않는 이름을 입력하세요 + 관리 + 이름 변경 + 트랙 추가 + 추가 (%1$d) + 트랙 제거 + 컬렉션 삭제 + %1$s을(를) 삭제할까요? + 트랙은 기기에 그대로 남습니다. 컬렉션만 삭제됩니다. + 선택 + 모두 선택 + 모두 선택 해제 + %1$d개 선택됨 + 컬렉션에 추가 + 즐겨찾기에 추가 + 컬렉션에서 제거 + 트랙 검색 + 앨범 순서 + 긴 순서 + 짧은 순서 + 트랙 + 피치 + 초기화 + 무음 건너뛰기 + 취침 타이머 + %1$d분 + 트랙 끝 + %1$s 남음 + 이퀄라이저 + 베이스 부스트 + 이 기기에서는 이퀄라이저를 사용할 수 없습니다 + 사운드트랙 + 게임 중 사용 + 게임이 실행되는 동안 사운드트랙 계속 재생 + 설치된 사운드트랙이 아직 없습니다. + 사운드트랙 검색 + 사운드트랙 폴더 추가 + 해당 폴더에 오디오 파일이 없습니다 + 총 재생 시간 + %1$d개 트랙 / %2$s + 디스크 %1$s + 셔플 + 이전 + 재생 + 일시정지 + 다음 + 반복 끔 + 전체 반복 + 한 곡 반복 + 볼륨 + 이 사운드트랙에 오디오 파일이 없습니다 diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index 58caf14b83..cf509abbf8 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -3653,4 +3653,67 @@ Salji Merah Skarlet + Runut bunyi + Muzik + Pilihan main balik + Kegemaran + Koleksi + Belum ada koleksi. Ketik ikon penanda buku untuk mencipta satu. + Disimpan + Cipta koleksi + Susun simpanan anda + Baharu + Cipta + Nama koleksi + Masukkan nama yang tidak digunakan oleh koleksi lain + Urus + Namakan semula + Tambah lagu + Tambah (%1$d) + Alih keluar lagu + Padam koleksi + Padam %1$s? + Lagu kekal pada peranti anda. Hanya koleksi dialih keluar. + Pilih + Pilih semua + Nyahpilih semua + %1$d dipilih + Tambah ke koleksi + Tambah ke kegemaran + Alih keluar daripada koleksi + Cari lagu + Susunan album + Terpanjang dahulu + Terpendek dahulu + Lagu + Pic + Tetapkan semula + Langkau senyap + Pemasa tidur + %1$d min + Hujung lagu + %1$s lagi + Penyama + Peningkat bes + Penyama tidak tersedia pada peranti ini + Runut bunyi + Dayakan dalam permainan + Teruskan memainkan runut bunyi semasa permainan berjalan + Belum ada runut bunyi dipasang. + Cari runut bunyi + Tambah folder runut bunyi + Tiada fail audio dalam folder itu + Jumlah tempoh + %1$d trek / %2$s + Cakera %1$s + Rawak + Sebelumnya + Main + Jeda + Seterusnya + Ulang dimatikan + Ulang semua + Ulang satu + Kelantangan + Tiada fail audio dalam runut bunyi ini diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index f56b734f56..4605b7306f 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -3683,4 +3683,67 @@ Skarlagenssnø + Lydspor + Musikk + Avspillingsalternativer + Favoritter + Samlinger + Ingen samlinger ennå. Trykk på bokmerkeikonet for å opprette en. + Lagret + Opprett en samling + Organiser det du lagrer + Ny + Opprett + Navn på samling + Skriv inn et navn som ingen andre samlinger bruker + Administrer + Gi nytt navn + Legg til spor + Legg til (%1$d) + Fjern spor + Slett samling + Slette %1$s? + Sporene blir værende på enheten din. Bare samlingen fjernes. + Velg + Velg alle + Fjern alle valg + %1$d valgt + Legg til i samling + Legg til i favoritter + Fjern fra samling + Søk i spor + Albumrekkefølge + Lengste først + Korteste først + Spor + Tonehøyde + Tilbakestill + Hopp over stillhet + Søvntimer + %1$d min + Slutten av sporet + %1$s igjen + Equalizer + Bassforsterkning + Equalizeren er ikke tilgjengelig på denne enheten + Lydspor + Aktiver i spill + Fortsett å spille lydsporet mens et spill kjører + Ingen lydspor installert ennå. + Søk i lydspor + Legg til en lydspormappe + Ingen lydfiler i denne mappen + Total lengde + %1$d spor / %2$s + Plate %1$s + Tilfeldig rekkefølge + Forrige + Spill av + Pause + Neste + Gjentakelse av + Gjenta alle + Gjenta ett + Volum + Ingen lydfiler i dette lydsporet diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 4240b47aee..558e70e934 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -3683,4 +3683,67 @@ Scharlakenrode sneeuw + Soundtracks + Muziek + Afspeelopties + Favorieten + Collecties + Nog geen collecties. Tik op het bladwijzericoon om er een te maken. + Opgeslagen + Maak een collectie + Orden je opgeslagen nummers + Nieuw + Maken + Naam van collectie + Voer een naam in die geen andere collectie gebruikt + Beheren + Hernoemen + Nummers toevoegen + Toevoegen (%1$d) + Nummers verwijderen + Collectie verwijderen + %1$s verwijderen? + De nummers blijven op je apparaat. Alleen de collectie wordt verwijderd. + Selecteren + Alles selecteren + Alles deselecteren + %1$d geselecteerd + Toevoegen aan collectie + Toevoegen aan favorieten + Verwijderen uit collectie + Nummers zoeken + Albumvolgorde + Langste eerst + Kortste eerst + Nummers + Toonhoogte + Resetten + Stilte overslaan + Slaaptimer + %1$d min + Einde van het nummer + Nog %1$s + Equalizer + Basversterking + De equalizer is niet beschikbaar op dit apparaat + Soundtracks + In-game inschakelen + Laat de soundtrack doorspelen terwijl een game draait + Nog geen soundtracks geïnstalleerd. + Soundtracks zoeken + Soundtrackmap toevoegen + Geen audiobestanden in deze map + Totale lengte + %1$d nummers / %2$s + Schijf %1$s + Willekeurig + Vorige + Afspelen + Pauzeren + Volgende + Herhalen uit + Alles herhalen + Eén herhalen + Volume + Geen audiobestanden in deze soundtrack diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 2c789b65d2..76cf52a264 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -3761,4 +3761,67 @@ Szkarłatny śnieg + Ścieżki dźwiękowe + Muzyka + Opcje odtwarzania + Ulubione + Kolekcje + Brak kolekcji. Dotknij ikony zakładki, aby utworzyć nową. + Zapisane + Utwórz kolekcję + Uporządkuj swoje zapisy + Nowa + Utwórz + Nazwa kolekcji + Wpisz nazwę, której nie używa żadna inna kolekcja + Zarządzaj + Zmień nazwę + Dodaj utwory + Dodaj (%1$d) + Usuń utwory + Usuń kolekcję + Usunąć %1$s? + Utwory pozostają na urządzeniu. Usunięta zostanie tylko kolekcja. + Zaznacz + Zaznacz wszystko + Odznacz wszystko + Zaznaczono: %1$d + Dodaj do kolekcji + Dodaj do ulubionych + Usuń z kolekcji + Szukaj utworów + Kolejność z albumu + Najdłuższe najpierw + Najkrótsze najpierw + Utwory + Wysokość dźwięku + Resetuj + Pomijaj ciszę + Wyłącznik czasowy + %1$d min + Koniec utworu + Pozostało %1$s + Korektor + Wzmocnienie basów + Korektor nie jest dostępny na tym urządzeniu + Ścieżki dźwiękowe + Włącz w grze + Odtwarzaj ścieżkę dźwiękową podczas działania gry + Brak zainstalowanych ścieżek dźwiękowych. + Szukaj ścieżek dźwiękowych + Dodaj folder ze ścieżką dźwiękową + Brak plików audio w tym folderze + Całkowity czas + Utworów: %1$d / %2$s + Płyta %1$s + Losowo + Poprzedni + Odtwórz + Wstrzymaj + Następny + Powtarzanie wyłączone + Powtarzaj wszystko + Powtarzaj jeden + Głośność + Brak plików audio w tej ścieżce dźwiękowej diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index dde7bf233f..5df34b54fd 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -3722,4 +3722,67 @@ Neve Escarlate + Bandas sonoras + Música + Opções de reprodução + Favoritas + Coleções + Ainda não há coleções. Toque no ícone de marcador para criar uma. + Guardadas + Criar uma coleção + Organize as suas faixas guardadas + Nova + Criar + Nome da coleção + Introduza um nome que nenhuma outra coleção utilize + Gerir + Mudar o nome + Adicionar faixas + Adicionar (%1$d) + Remover faixas + Eliminar coleção + Eliminar %1$s? + As faixas permanecem no seu dispositivo. Apenas a coleção é removida. + Selecionar + Selecionar tudo + Desselecionar tudo + %1$d selecionadas + Adicionar à coleção + Adicionar às favoritas + Remover da coleção + Pesquisar faixas + Ordem do álbum + Mais longas primeiro + Mais curtas primeiro + Faixas + Tom + Repor + Saltar silêncio + Temporizador de suspensão + %1$d min + Fim da faixa + Restam %1$s + Equalizador + Reforço de graves + O equalizador não está disponível neste dispositivo + Bandas sonoras + Ativar durante o jogo + Continuar a reproduzir a banda sonora enquanto um jogo está em execução + Ainda não há bandas sonoras instaladas. + Pesquisar bandas sonoras + Adicionar uma pasta de banda sonora + Nenhum ficheiro de áudio nessa pasta + Duração total + %1$d faixas / %2$s + Disco %1$s + Aleatório + Anterior + Reproduzir + Pausar + Seguinte + Repetição desativada + Repetir tudo + Repetir uma + Volume + Nenhum ficheiro de áudio nesta banda sonora diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 1bf1feb07a..be24a67375 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -3722,4 +3722,67 @@ Neve Escarlate + Trilhas sonoras + Música + Opções de reprodução + Favoritas + Coleções + Nenhuma coleção ainda. Toque no ícone de marcador para criar uma. + Salvas + Criar uma coleção + Organize suas faixas salvas + Nova + Criar + Nome da coleção + Digite um nome que nenhuma outra coleção use + Gerenciar + Renomear + Adicionar faixas + Adicionar (%1$d) + Remover faixas + Excluir coleção + Excluir %1$s? + As faixas continuam no seu dispositivo. Somente a coleção é removida. + Selecionar + Selecionar tudo + Desmarcar tudo + %1$d selecionadas + Adicionar à coleção + Adicionar às favoritas + Remover da coleção + Pesquisar faixas + Ordem do álbum + Mais longas primeiro + Mais curtas primeiro + Faixas + Tom + Redefinir + Pular silêncio + Timer de sono + %1$d min + Fim da faixa + Restam %1$s + Equalizador + Reforço de graves + O equalizador não está disponível neste dispositivo + Trilhas sonoras + Ativar durante o jogo + Continuar tocando a trilha sonora enquanto um jogo está em execução + Nenhuma trilha sonora instalada ainda. + Pesquisar trilhas sonoras + Adicionar uma pasta de trilha sonora + Nenhum arquivo de áudio nessa pasta + Duração total + %1$d faixas / %2$s + Disco %1$s + Aleatório + Anterior + Reproduzir + Pausar + Próxima + Repetição desativada + Repetir tudo + Repetir uma + Volume + Nenhum arquivo de áudio nesta trilha sonora diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index a2e10057d6..059d8c8d45 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -3722,4 +3722,67 @@ Zăpadă stacojie + Coloane sonore + Muzică + Opțiuni de redare + Favorite + Colecții + Nicio colecție încă. Atinge pictograma de marcaj pentru a crea una. + Salvate + Creează o colecție + Organizează-ți piesele salvate + Nouă + Creează + Numele colecției + Introdu un nume pe care nu îl folosește nicio altă colecție + Gestionează + Redenumește + Adaugă piese + Adaugă (%1$d) + Elimină piese + Șterge colecția + Ștergi %1$s? + Piesele rămân pe dispozitiv. Se elimină doar colecția. + Selectează + Selectează tot + Deselectează tot + %1$d selectate + Adaugă în colecție + Adaugă la favorite + Elimină din colecție + Caută piese + Ordinea albumului + Cele mai lungi primele + Cele mai scurte primele + Piese + Înălțime + Resetează + Omite tăcerea + Temporizator de somn + %1$d min + Sfârșitul piesei + Mai sunt %1$s + Egalizator + Amplificare bas + Egalizatorul nu este disponibil pe acest dispozitiv + Coloane sonore + Activează în joc + Continuă redarea coloanei sonore cât timp rulează un joc + Nicio coloană sonoră instalată încă. + Caută coloane sonore + Adaugă un dosar de coloană sonoră + Niciun fișier audio în acel dosar + Durată totală + Piese: %1$d · %2$s + Discul %1$s + Amestecare + Anterior + Redare + Pauză + Următor + Repetare dezactivată + Repetă tot + Repetă una + Volum + Niciun fișier audio în această coloană sonoră diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 88dbfbc2fd..34bb4b9cb1 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -3844,4 +3844,67 @@ Алый снег + Саундтреки + Музыка + Параметры воспроизведения + Избранное + Коллекции + Коллекций пока нет. Нажмите на значок закладки, чтобы создать её. + Сохранено + Создать коллекцию + Упорядочите сохранённое + Новая + Создать + Название коллекции + Введите название, которое не используется в другой коллекции + Управление + Переименовать + Добавить треки + Добавить (%1$d) + Убрать треки + Удалить коллекцию + Удалить %1$s? + Треки останутся на устройстве. Будет удалена только коллекция. + Выбрать + Выбрать все + Снять выбор + Выбрано: %1$d + Добавить в коллекцию + Добавить в избранное + Убрать из коллекции + Поиск треков + Порядок в альбоме + Сначала длинные + Сначала короткие + Треки + Высота тона + Сбросить + Пропускать тишину + Таймер сна + %1$d мин + Конец трека + Осталось %1$s + Эквалайзер + Усиление баса + Эквалайзер недоступен на этом устройстве + Саундтреки + Включить в игре + Продолжать воспроизведение саундтрека во время игры + Саундтреки ещё не установлены. + Поиск саундтреков + Добавить папку саундтрека + В этой папке нет аудиофайлов + Общая длительность + Треков: %1$d / %2$s + Диск %1$s + Перемешать + Назад + Воспроизвести + Пауза + Далее + Повтор выключен + Повторять всё + Повторять один + Громкость + В этом саундтреке нет аудиофайлов diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index e0754fe02b..1fcbc9a807 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -3683,4 +3683,67 @@ Scharlakansröd snö + Soundtracks + Musik + Uppspelningsalternativ + Favoriter + Samlingar + Inga samlingar än. Tryck på bokmärkesikonen för att skapa en. + Sparade + Skapa en samling + Organisera dina sparade spår + Ny + Skapa + Samlingens namn + Ange ett namn som ingen annan samling använder + Hantera + Byt namn + Lägg till spår + Lägg till (%1$d) + Ta bort spår + Ta bort samling + Ta bort %1$s? + Spåren finns kvar på din enhet. Bara samlingen tas bort. + Välj + Välj alla + Avmarkera alla + %1$d valda + Lägg till i samling + Lägg till i favoriter + Ta bort från samling + Sök spår + Albumordning + Längst först + Kortast först + Spår + Tonhöjd + Återställ + Hoppa över tystnad + Insomningstimer + %1$d min + Slutet av spåret + %1$s kvar + Equalizer + Basförstärkning + Equalizern är inte tillgänglig på den här enheten + Soundtracks + Aktivera i spel + Fortsätt spela soundtracket medan ett spel körs + Inga soundtracks installerade än. + Sök bland soundtracks + Lägg till en soundtrackmapp + Inga ljudfiler i den mappen + Total längd + %1$d spår / %2$s + Skiva %1$s + Blanda + Föregående + Spela + Pausa + Nästa + Upprepning av + Upprepa alla + Upprepa ett + Volym + Inga ljudfiler i detta soundtrack diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index e483bfead0..bd7ccd6ad8 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -3653,4 +3653,67 @@ หิมะสีแดงชาด + ซาวด์แทร็ก + เพลง + ตัวเลือกการเล่น + รายการโปรด + คอลเลกชัน + ยังไม่มีคอลเลกชัน แตะไอคอนบุ๊กมาร์กเพื่อสร้าง + บันทึกแล้ว + สร้างคอลเลกชัน + จัดระเบียบรายการที่บันทึกไว้ + ใหม่ + สร้าง + ชื่อคอลเลกชัน + ป้อนชื่อที่ไม่ซ้ำกับคอลเลกชันอื่น + จัดการ + เปลี่ยนชื่อ + เพิ่มแทร็ก + เพิ่ม (%1$d) + เอาแทร็กออก + ลบคอลเลกชัน + ลบ %1$s หรือไม่? + แทร็กยังอยู่ในอุปกรณ์ของคุณ จะลบเฉพาะคอลเลกชัน + เลือก + เลือกทั้งหมด + ยกเลิกการเลือกทั้งหมด + เลือกแล้ว %1$d รายการ + เพิ่มในคอลเลกชัน + เพิ่มในรายการโปรด + เอาออกจากคอลเลกชัน + ค้นหาแทร็ก + ลำดับอัลบั้ม + ยาวที่สุดก่อน + สั้นที่สุดก่อน + แทร็ก + ระดับเสียง + รีเซ็ต + ข้ามช่วงเงียบ + ตั้งเวลาปิด + %1$d นาที + จบแทร็ก + เหลือ %1$s + อีควอไลเซอร์ + เพิ่มเสียงเบส + อุปกรณ์นี้ไม่รองรับอีควอไลเซอร์ + ซาวด์แทร็ก + เปิดใช้ขณะเล่นเกม + เล่นซาวด์แทร็กต่อไปขณะที่เกมทำงาน + ยังไม่มีซาวด์แทร็กที่ติดตั้ง + ค้นหาซาวด์แทร็ก + เพิ่มโฟลเดอร์ซาวด์แทร็ก + ไม่พบไฟล์เสียงในโฟลเดอร์นั้น + ความยาวทั้งหมด + %1$d แทร็ก / %2$s + ดิสก์ %1$s + สุ่ม + ก่อนหน้า + เล่น + หยุดชั่วคราว + ถัดไป + ปิดการเล่นซ้ำ + เล่นซ้ำทั้งหมด + เล่นซ้ำหนึ่งเพลง + ระดับเสียง + ไม่พบไฟล์เสียงในซาวด์แทร็กนี้ diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 479e767c1b..889d71ef48 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -3683,4 +3683,67 @@ Kızıl Kar + Oyun müzikleri + Müzik + Oynatma seçenekleri + Favoriler + Koleksiyonlar + Henüz koleksiyon yok. Oluşturmak için yer imi simgesine dokun. + Kaydedilenler + Koleksiyon oluştur + Kayıtlarını düzenle + Yeni + Oluştur + Koleksiyon adı + Başka bir koleksiyonun kullanmadığı bir ad gir + Yönet + Yeniden adlandır + Parça ekle + Ekle (%1$d) + Parçaları kaldır + Koleksiyonu sil + %1$s silinsin mi? + Parçalar cihazında kalır. Yalnızca koleksiyon kaldırılır. + Seç + Tümünü seç + Tüm seçimleri kaldır + %1$d seçildi + Koleksiyona ekle + Favorilere ekle + Koleksiyondan kaldır + Parça ara + Albüm sırası + Önce en uzun + Önce en kısa + Parçalar + Perde + Sıfırla + Sessizliği atla + Uyku zamanlayıcısı + %1$d dk + Parçanın sonu + %1$s kaldı + Ekolayzır + Bas güçlendirme + Ekolayzır bu cihazda kullanılamıyor + Oyun müzikleri + Oyun içinde etkinleştir + Oyun çalışırken oyun müziği çalmaya devam etsin + Henüz oyun müziği yüklenmedi. + Oyun müziklerinde ara + Oyun müziği klasörü ekle + Bu klasörde ses dosyası yok + Toplam süre + %1$d parça / %2$s + Disk %1$s + Karıştır + Önceki + Oynat + Duraklat + Sonraki + Tekrar kapalı + Tümünü tekrarla + Birini tekrarla + Ses düzeyi + Bu oyun müziğinde ses dosyası yok diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index ea4e958377..670d07f991 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -3761,4 +3761,67 @@ Багряний сніг + Саундтреки + Музика + Параметри відтворення + Улюблене + Колекції + Колекцій ще немає. Торкніться значка закладки, щоб створити. + Збережено + Створити колекцію + Упорядкуйте свої збережені треки + Нова + Створити + Назва колекції + Введіть назву, яку не використовує жодна інша колекція + Керувати + Перейменувати + Додати треки + Додати (%1$d) + Вилучити треки + Видалити колекцію + Видалити %1$s? + Треки залишаються на вашому пристрої. Буде видалено лише колекцію. + Вибрати + Вибрати все + Скасувати вибір + Вибрано: %1$d + Додати до колекції + Додати до улюбленого + Вилучити з колекції + Пошук треків + Порядок в альбомі + Спочатку найдовші + Спочатку найкоротші + Треки + Висота тону + Скинути + Пропускати тишу + Таймер сну + %1$d хв + Кінець треку + Залишилось %1$s + Еквалайзер + Підсилення басів + Еквалайзер недоступний на цьому пристрої + Саундтреки + Вмикати в грі + Відтворювати саундтрек, поки запущено гру + Саундтреки ще не встановлено. + Пошук саундтреків + Додати теку саундтреку + У цій теці немає аудіофайлів + Загальна тривалість + Треків: %1$d / %2$s + Диск %1$s + Перемішати + Назад + Відтворити + Пауза + Далі + Повтор вимкнено + Повторювати все + Повторювати один + Гучність + У цьому саундтреку немає аудіофайлів diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index e6b9a21732..a85d7b4c88 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -3653,4 +3653,67 @@ Tuyết đỏ thẫm + Nhạc nền + Nhạc + Tùy chọn phát + Yêu thích + Bộ sưu tập + Chưa có bộ sưu tập nào. Chạm vào biểu tượng dấu trang để tạo. + Đã lưu + Tạo bộ sưu tập + Sắp xếp các bài đã lưu + Mới + Tạo + Tên bộ sưu tập + Nhập tên chưa được bộ sưu tập nào khác sử dụng + Quản lý + Đổi tên + Thêm bài hát + Thêm (%1$d) + Xóa bài hát + Xóa bộ sưu tập + Xóa %1$s? + Các bài hát vẫn còn trên thiết bị của bạn. Chỉ bộ sưu tập bị xóa. + Chọn + Chọn tất cả + Bỏ chọn tất cả + Đã chọn %1$d + Thêm vào bộ sưu tập + Thêm vào yêu thích + Xóa khỏi bộ sưu tập + Tìm bài hát + Thứ tự album + Dài nhất trước + Ngắn nhất trước + Bài hát + Cao độ + Đặt lại + Bỏ qua khoảng lặng + Hẹn giờ ngủ + %1$d phút + Hết bài + Còn %1$s + Bộ cân bằng âm + Tăng âm trầm + Thiết bị này không có bộ cân bằng âm + Nhạc nền + Bật trong game + Tiếp tục phát nhạc nền khi game đang chạy + Chưa có nhạc nền nào được cài đặt. + Tìm nhạc nền + Thêm thư mục nhạc nền + Không có tệp âm thanh trong thư mục đó + Tổng thời lượng + %1$d bài / %2$s + Đĩa %1$s + Phát ngẫu nhiên + Trước + Phát + Tạm dừng + Tiếp + Tắt lặp lại + Lặp lại tất cả + Lặp lại một bài + Âm lượng + Không có tệp âm thanh trong nhạc nền này diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 67e815130d..38946ef8c7 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -3657,4 +3657,67 @@ 猩红之雪 + 原声音乐 + 音乐 + 播放选项 + 收藏 + 合集 + 还没有合集。点按书签图标即可创建。 + 已保存 + 创建合集 + 整理你的收藏 + 新建 + 创建 + 合集名称 + 请输入未被其他合集使用的名称 + 管理 + 重命名 + 添加曲目 + 添加(%1$d) + 移除曲目 + 删除合集 + 删除 %1$s? + 曲目仍保留在你的设备上,只会删除合集。 + 选择 + 全选 + 取消全选 + 已选择 %1$d 项 + 添加到合集 + 添加到收藏 + 从合集中移除 + 搜索曲目 + 专辑顺序 + 最长优先 + 最短优先 + 曲目 + 音调 + 重置 + 跳过静音 + 睡眠定时 + %1$d 分钟 + 曲目结束 + 剩余 %1$s + 均衡器 + 低音增强 + 此设备不支持均衡器 + 原声音乐 + 在游戏中启用 + 游戏运行时继续播放原声音乐 + 尚未安装任何原声音乐。 + 搜索原声音乐 + 添加原声音乐文件夹 + 该文件夹中没有音频文件 + 总时长 + %1$d 首曲目 / %2$s + 第 %1$s 张 + 随机播放 + 上一首 + 播放 + 暂停 + 下一首 + 关闭重复 + 全部重复 + 单曲重复 + 音量 + 此原声音乐中没有音频文件 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index f97f66c3a1..b81f12305a 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -3656,4 +3656,67 @@ 緋紅之雪 + 原聲帶 + 音樂 + 播放選項 + 最愛 + 合集 + 暫時未有合集。點按書籤圖示即可建立。 + 已儲存 + 建立合集 + 整理你的收藏 + 新增 + 建立 + 合集名稱 + 請輸入未被其他合集使用的名稱 + 管理 + 重新命名 + 新增曲目 + 新增(%1$d) + 移除曲目 + 刪除合集 + 刪除 %1$s? + 曲目仍會保留在你的裝置上,只會刪除合集。 + 選取 + 全選 + 取消全選 + 已選取 %1$d 項 + 加入合集 + 加入最愛 + 從合集中移除 + 搜尋曲目 + 專輯順序 + 最長優先 + 最短優先 + 曲目 + 音調 + 重設 + 略過靜音 + 睡眠計時器 + %1$d 分鐘 + 曲目結束 + 剩餘 %1$s + 等化器 + 重低音增強 + 此裝置不支援等化器 + 原聲帶 + 在遊戲中啟用 + 遊戲運行時繼續播放原聲帶 + 尚未安裝任何原聲帶。 + 搜尋原聲帶 + 新增原聲帶資料夾 + 該資料夾中沒有音訊檔案 + 總長度 + %1$d 首曲目 / %2$s + 第 %1$s 張 + 隨機播放 + 上一首 + 播放 + 暫停 + 下一首 + 關閉重複 + 全部重複 + 單曲重複 + 音量 + 此原聲帶中沒有音訊檔案 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index ee48c655e2..da5e460fc2 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -3656,4 +3656,67 @@ 緋紅之雪 + 原聲帶 + 音樂 + 播放選項 + 我的最愛 + 合集 + 尚無合集。點選書籤圖示即可建立。 + 已儲存 + 建立合集 + 整理你的收藏 + 新增 + 建立 + 合集名稱 + 請輸入未被其他合集使用的名稱 + 管理 + 重新命名 + 新增曲目 + 新增(%1$d) + 移除曲目 + 刪除合集 + 刪除 %1$s? + 曲目仍會保留在你的裝置上,只會刪除合集。 + 選取 + 全選 + 取消全選 + 已選取 %1$d 項 + 加入合集 + 加入我的最愛 + 從合集中移除 + 搜尋曲目 + 專輯順序 + 最長優先 + 最短優先 + 曲目 + 音調 + 重設 + 略過靜音 + 睡眠計時器 + %1$d 分鐘 + 曲目結束 + 剩餘 %1$s + 等化器 + 重低音增強 + 此裝置不支援等化器 + 原聲帶 + 在遊戲中啟用 + 遊戲執行時繼續播放原聲帶 + 尚未安裝任何原聲帶。 + 搜尋原聲帶 + 新增原聲帶資料夾 + 該資料夾中沒有音訊檔案 + 總長度 + %1$d 首曲目 / %2$s + 第 %1$s 張 + 隨機播放 + 上一首 + 播放 + 暫停 + 下一首 + 關閉重複 + 全部重複 + 單曲重複 + 音量 + 此原聲帶中沒有音訊檔案 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 734bfbb25e..ce55a06e1e 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -3999,5 +3999,69 @@ Scarlet Snow White surfaces with red accents. + Soundtracks + Music + Playback options + Favorites + Collections + No collections yet. Tap the bookmark icon to create one. + Saved + Create a collection + Organise your saves + New + Create + Collection name + Enter a name that no other collection uses + Manage + Rename + Add tracks + Add (%1$d) + Remove tracks + Delete collection + Delete %1$s? + The tracks stay on your device. Only the collection is removed. + Select + Select all + Deselect all + %1$d selected + Add to collection + Add to favorites + Remove from collection + Search tracks + Album order + Longest first + Shortest first + Tracks + Pitch + Reset + Skip silence + Sleep timer + %1$d min + End of track + %1$s left + Equalizer + Bass boost + The equalizer is not available on this device + Soundtracks + Enable ingame + Keep the soundtrack playing while a game runs + No soundtracks installed yet. + Search soundtracks + Add a soundtrack folder + No audio files found in that folder + Total length + %1$d Tracks / %2$s + Disc %1$s + Shuffle + Previous + Play + Pause + Next + Repeat off + Repeat all + Repeat one + Volume + No audio files found in this soundtrack + Launch unavailable No web browser is available to open this link. diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackCollectionsTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackCollectionsTest.kt new file mode 100644 index 0000000000..6aa9bb1640 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackCollectionsTest.kt @@ -0,0 +1,43 @@ +package com.droiddeck.launcher.frontend + +import com.droiddeck.launcher.frontend.SoundtrackCollections.Collection +import com.droiddeck.launcher.frontend.SoundtrackCollections.TrackRef +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class SoundtrackCollectionsTest { + private fun ref(path: String) = TrackRef(path, path, "", "", 0) + + @Test fun toggledAddsThenRemoves() { + val once = SoundtrackCollections.toggled(emptyList(), ref("a")) + assertEquals(listOf("a"), once.map { it.path }) + assertTrue(SoundtrackCollections.toggled(once, ref("a")).isEmpty()) + } + + @Test fun mergedSkipsDuplicatesAndKeepsOrder() { + val result = SoundtrackCollections.merged(listOf(ref("a"), ref("b")), listOf(ref("b"), ref("c"), ref("c"))) + assertEquals(listOf("a", "b", "c"), result.map { it.path }) + } + + @Test fun cleanNameTrimsAndCollapsesSpaces() = assertEquals("My mix", SoundtrackCollections.cleanName(" My mix ")) + + @Test fun nameTakenIgnoresCaseAndExcludedId() { + val list = listOf(Collection(2_000_000_001, "Chill", emptyList())) + assertTrue(SoundtrackCollections.nameTaken(list, "chill")) + assertFalse(SoundtrackCollections.nameTaken(list, "chill", except = 2_000_000_001)) + assertFalse(SoundtrackCollections.nameTaken(list, "Focus")) + } + + @Test fun nextIdStartsAboveFavoritesAndGrows() { + assertEquals(SoundtrackCollections.FAVORITES_ID + 1, SoundtrackCollections.nextId(emptyList())) + val list = listOf(Collection(2_000_000_005, "x", emptyList())) + assertEquals(2_000_000_006, SoundtrackCollections.nextId(list)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackOrderTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackOrderTest.kt new file mode 100644 index 0000000000..167d2c96b9 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackOrderTest.kt @@ -0,0 +1,34 @@ +package com.droiddeck.launcher.frontend + +import java.io.File +import org.junit.Assert.assertEquals +import org.junit.Test + +class SoundtrackOrderTest { + private fun track(name: String, disc: Int, number: Int) = Soundtrack.Track(File("/music/$name"), name, disc, number, 1000L) + + @Test fun savedOrderIsAppliedAndRenumbered() { + val disc = mapOf(1 to listOf(track("a", 1, 1), track("b", 1, 2), track("c", 1, 3))) + val result = SoundtrackOrder.ordered(disc, listOf("/music/c", "/music/a", "/music/b")) + assertEquals(listOf("c", "a", "b"), result.getValue(1).map { it.title }) + assertEquals(listOf(1, 2, 3), result.getValue(1).map { it.number }) + } + + @Test fun unknownTracksKeepTheirOrderAfterKnownOnes() { + val disc = mapOf(1 to listOf(track("a", 1, 1), track("b", 1, 2), track("c", 1, 3))) + val result = SoundtrackOrder.ordered(disc, listOf("/music/c")) + assertEquals(listOf("c", "a", "b"), result.getValue(1).map { it.title }) + } + + @Test fun discsStayApart() { + val disc = mapOf(1 to listOf(track("a", 1, 1), track("b", 1, 2)), 2 to listOf(track("c", 2, 1), track("d", 2, 2))) + val result = SoundtrackOrder.ordered(disc, listOf("/music/d", "/music/b", "/music/a", "/music/c")) + assertEquals(listOf("b", "a"), result.getValue(1).map { it.title }) + assertEquals(listOf("d", "c"), result.getValue(2).map { it.title }) + } + + @Test fun emptyOrderChangesNothing() { + val disc = mapOf(1 to listOf(track("a", 1, 1), track("b", 1, 2))) + assertEquals(disc, SoundtrackOrder.ordered(disc, emptyList())) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTest.kt new file mode 100644 index 0000000000..ed96285429 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTest.kt @@ -0,0 +1,151 @@ +package com.droiddeck.launcher.frontend + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import java.io.File + +class SoundtrackTest { + private fun raw( + folder: String, name: String, disc: Int? = null, track: Int? = null, title: String? = null, size: Long = 1000L, + ) = Soundtrack.Raw(File("/music/album/${if (folder.isEmpty()) "" else "$folder/"}$name"), folder, disc, track, title, null, 60_000L, size) + + @Test fun titlesDropArtistAlbumAndNumber() { + assertEquals("Once Upon a Time", Soundtrack.cleanTitle("toby fox - UNDERTALE Soundtrack - 01 Once Upon a Time.mp3")) + assertEquals("ANOTHER HIM", Soundtrack.cleanTitle("001 ANOTHER HIM.flac")) + assertEquals("Chapter 5 Logo", Soundtrack.cleanTitle("166 Chapter 5 Logo.mp3")) + assertEquals("Query-", Soundtrack.cleanTitle("094 Query-.mp3")) + assertEquals("Ruins", Soundtrack.cleanTitle("Ruins.ogg")) + } + + @Test fun flatAlbumIsOneDiscOrderedByNumber() { + val disc = Soundtrack.group( + listOf(raw("", "toby fox - X - 10 Ten.mp3"), raw("", "toby fox - X - 02 Two.mp3"), raw("", "toby fox - X - 01 One.mp3")), + ) + assertEquals(listOf(0), disc.keys.toList()) + assertEquals(listOf("One", "Two", "Ten"), disc.getValue(0).map { it.title }) + assertEquals(listOf(1, 2, 3), disc.getValue(0).map { it.number }) + } + + @Test fun subfoldersBecomeDiscs() { + val disc = Soundtrack.group( + listOf(raw("2", "041 B.mp3"), raw("1", "001 A.mp3"), raw("10", "200 C.mp3"), raw("1", "002 A2.mp3")), + ) + assertEquals(listOf(1, 2, 3), disc.keys.toList()) + assertEquals(listOf("A", "A2"), disc.getValue(1).map { it.title }) + assertEquals(listOf("B"), disc.getValue(2).map { it.title }) + assertEquals(listOf("C"), disc.getValue(3).map { it.title }) + } + + @Test fun losslessCopyReplacesLossyDuplicateAndKeepsItsFolder() { + val disc = Soundtrack.group( + listOf( + raw("", "001 ANOTHER HIM.flac", size = 4_130_000L), + raw("", "002 Beginning.flac", size = 4_870_000L), + raw("1", "001 ANOTHER HIM.mp3", size = 1_940_000L), + raw("1", "002 Beginning.mp3", size = 2_320_000L), + raw("2", "041 Faint Glow.mp3"), + ), + ) + assertEquals(listOf(1, 2), disc.keys.toList()) + assertEquals(listOf("flac", "flac"), disc.getValue(1).map { it.file.extension }) + assertEquals(listOf("ANOTHER HIM", "Beginning"), disc.getValue(1).map { it.title }) + assertEquals(listOf("Faint Glow"), disc.getValue(2).map { it.title }) + } + + @Test fun tagsDecideDiscsAndFileNamesDecideOrder() { + val disc = Soundtrack.group( + listOf( + raw("3+4", "088 Late.mp3", disc = 4, track = 1, title = "Old wooden rafters"), + raw("3+4", "001 Early.mp3", disc = 3, track = 2, title = "Second"), + raw("3+4", "002 Early.mp3", disc = 3, track = 1, title = "First"), + ), + ) + assertEquals(listOf(3, 4), disc.keys.toList()) + assertEquals(listOf("Second", "First"), disc.getValue(3).map { it.title }) + assertEquals("Old wooden rafters", disc.getValue(4).single().title) + } + + @Test fun sameTagsCollapseDuplicates() { + val disc = Soundtrack.group( + listOf( + raw("", "a.flac", disc = 1, track = 1, title = "Song", size = 5000L), + raw("1", "a.mp3", disc = 1, track = 1, title = "Song", size = 900L), + ), + ) + assertEquals(1, disc.getValue(1).size) + assertEquals("flac", disc.getValue(1).single().file.extension) + } + + @Test fun renamedPunctuationStillMatchesAcrossFormats() { + val disc = Soundtrack.group( + listOf( + raw("", "094 Query?.flac", size = 5000L), + raw("3+4", "094 Query-.mp3", size = 900L), + raw("3+4", "095 Quiz!.mp3", size = 900L), + ), + ) + assertEquals(2, disc.getValue(0).size + disc.filterKeys { it != 0 }.values.sumOf { it.size }) + assertEquals(listOf("flac", "mp3"), disc.values.flatten().map { it.file.extension }) + } + + @Test fun sameTitleWithDifferentNumbersStaysSeparate() { + val disc = Soundtrack.group(listOf(raw("", "01 Fanfare.mp3"), raw("", "07 Fanfare.mp3"))) + assertEquals(2, disc.values.flatten().size) + } + + @Test fun folderDiscsKeepTheirFolderNameAsLabel() { + val disc = Soundtrack.group( + listOf(raw("3+4", "088 A.mp3", track = 1), raw("3+4", "165 B.mp3", track = 78), raw("5", "166 C.mp3", track = 1), raw("Bonus", "300 D.mp3")), + ) + assertEquals(listOf("3+4", "5", "3"), disc.values.map { it.first().discLabel }.let { it.take(2) + disc.getValue(3).first().discLabel }) + assertEquals(listOf("A", "B"), disc.getValue(1).map { it.title }) + } + + @Test fun tagsFromTheDroppedDuplicateFillTheKeptOne() { + val disc = Soundtrack.group( + listOf( + raw("", "165 Concert for you.flac", size = 90_000L), + raw("3+4", "165 Concert for you.mp3", track = 78, title = "Concert for you", size = 98_000L), + raw("", "088 Flashback (Excerpt).flac", size = 4_800_000L), + raw("3+4", "088 Flashback (Excerpt).mp3", track = 1, title = "Flashback (Excerpt)", size = 1_280_000L), + ), + ) + val tracks = disc.values.flatten() + assertEquals(listOf("Flashback (Excerpt)", "Concert for you"), tracks.map { it.title }) + assertEquals(listOf("flac", "flac"), tracks.map { it.file.extension }) + } + + @Test fun emptyInputGivesNothing() { + assertTrue(Soundtrack.group(emptyList()).isEmpty()) + } + + @Test fun lengthFormatting() { + assertEquals("0:48", Soundtrack.formatLength(48_000L)) + assertEquals("1:20", Soundtrack.formatLength(80_000L)) + assertEquals("4:15:37", Soundtrack.formatLength((4 * 3600 + 15 * 60 + 37) * 1000L)) + } + + @Test fun shortcutLinksRoundTrip() { + assertEquals(391540, SoundtrackShortcuts.parse(SoundtrackShortcuts.uri(391540))) + assertEquals(-5, SoundtrackShortcuts.parse(SoundtrackShortcuts.uri(-5))) + assertNull(SoundtrackShortcuts.parse("droiddeck://game/12")) + assertNull(SoundtrackShortcuts.parse(null)) + } + + @Test fun addedSoundtracksNeverCollideWithSteamIds() { + assertTrue(AddedSoundtracks.idOf("/storage/emulated/0/Music/Album") < 0) + } + + @Test fun addedIdsStayStableWhenAnotherFolderIsRemoved() { + assertEquals("Aa".hashCode(), "BB".hashCode()) + val first = AddedSoundtracks.Entry("/m/Aa", "A") + val second = AddedSoundtracks.Entry("/m/BB", "B") + val assigned = AddedSoundtracks.assignIds(listOf(first, second)) + assertTrue(assigned[0].id != assigned[1].id) + assertTrue(assigned.all { it.id < 0 }) + val after = AddedSoundtracks.assignIds(assigned.drop(1)) + assertEquals(assigned[1].id, after[0].id) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTracksTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTracksTest.kt new file mode 100644 index 0000000000..c601653ca7 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/frontend/SoundtrackTracksTest.kt @@ -0,0 +1,29 @@ +package com.droiddeck.launcher.frontend + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class SoundtrackTracksTest { + private class T(val title: String, val ms: Long) + private val items = listOf(T("banana", 300), T("Apple", 100), T("cherry", 200)) + private fun sorted(s: SoundtrackTracks.Sort) = SoundtrackTracks.sort(items, s, { it.title }, { it.ms }).map { it.title } + + @Test fun defaultKeepsOrder() = assertEquals(listOf("banana", "Apple", "cherry"), sorted(SoundtrackTracks.Sort.DEFAULT)) + @Test fun titleAscIgnoresCase() = assertEquals(listOf("Apple", "banana", "cherry"), sorted(SoundtrackTracks.Sort.TITLE_ASC)) + @Test fun titleDesc() = assertEquals(listOf("cherry", "banana", "Apple"), sorted(SoundtrackTracks.Sort.TITLE_DESC)) + @Test fun longestFirst() = assertEquals(listOf("banana", "cherry", "Apple"), sorted(SoundtrackTracks.Sort.LONGEST)) + @Test fun shortestFirst() = assertEquals(listOf("Apple", "cherry", "banana"), sorted(SoundtrackTracks.Sort.SHORTEST)) + + @Test fun blankQueryMatchesEverything() = assertTrue(SoundtrackTracks.matches(" ", "anything")) + @Test fun wordsMayHitDifferentFields() = assertTrue(SoundtrackTracks.matches("main theme", "Main Menu", "Theme Composer")) + @Test fun everyWordMustMatch() = assertFalse(SoundtrackTracks.matches("main boss", "Main Menu", "Composer")) + @Test fun matchIsCaseInsensitive() = assertTrue(SoundtrackTracks.matches("MENU", "main menu")) + + @Test fun rankOrdersExactPrefixContains() { + assertEquals(0, SoundtrackTracks.rank("Menu", "menu")) + assertEquals(1, SoundtrackTracks.rank("men", "Menu Theme")) + assertEquals(2, SoundtrackTracks.rank("theme", "Menu Theme")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/DragTargetTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/DragTargetTest.kt new file mode 100644 index 0000000000..3a35e77f23 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/DragTargetTest.kt @@ -0,0 +1,20 @@ +package com.droiddeck.launcher.ui + +import org.junit.Assert.assertEquals +import org.junit.Test + +class DragTargetTest { + @Test fun smallMovesStayInPlace() = assertEquals(5, dragTarget(20f, 100f, 5, 0, 9)) + + @Test fun halfRowMovesToNextSlot() { + assertEquals(6, dragTarget(60f, 100f, 5, 0, 9)) + assertEquals(4, dragTarget(-60f, 100f, 5, 0, 9)) + } + + @Test fun longMovesSkipSeveralRows() = assertEquals(8, dragTarget(310f, 100f, 5, 0, 9)) + + @Test fun staysInsideTheDisc() { + assertEquals(9, dragTarget(900f, 100f, 5, 0, 9)) + assertEquals(2, dragTarget(-900f, 100f, 5, 2, 9)) + } +} diff --git a/docs/development/soundtracks.md b/docs/development/soundtracks.md new file mode 100644 index 0000000000..a1b11a3997 --- /dev/null +++ b/docs/development/soundtracks.md @@ -0,0 +1,78 @@ +# Soundtracks + +Steam soundtracks get their own tab under Library, a built-in music player, and an Android media session. + +## Where soundtracks live + +Steam installs a soundtrack to `/steamapps/music/`, next to a normal `appmanifest_.acf`. This holds for the internal Steam library and for a second library folder. + +`Library.steamGames()` skips any manifest whose install directory exists only under `steamapps/music`. `Library.soundtracks()` returns exactly those entries, marked with `SteamGame.soundtrack`. While the Music tab is enabled, games and soundtracks therefore never mix in the Library tab, the launch drawer, game file sync or component preparation. + +Folders added by hand (Soundtracks tab, plus button) are stored in `added-soundtracks.json` and carry a negative app id, so they cannot collide with a Steam app id. + +## Turning it off + +Setup > Launcher > Soundtracks. When off, the tab disappears and installed Steam soundtracks show in Library again, as they did before. + +## Tracks, discs and duplicates + +`Soundtrack.load()` walks the folder (four levels deep) for mp3, flac, ogg, opus, wav, m4a and aac. Tags come from `MediaMetadataRetriever` and are cached per folder in `files/soundtrack-index`, keyed by path, size and modification time. + +`Soundtrack.group()` is pure and unit tested: + +1. The same track in several formats collapses to one. Identity is disc and track number when both tags exist, otherwise the cleaned title. Lossless wins over lossy. +2. Disc comes from the disc tag, otherwise from the subfolder (natural order), labelled with the folder name when it is numeric (for example `3+4`). A folder with no subfolders is one disc and shows no disc headers. Tags missing on the kept copy are filled from its duplicates, since FLAC files often use tag names Android does not read. +3. Tracks sort by the number at the start of the file name, then by track tag, then by name. This matches Valve's soundtrack documentation, which says the Steam music player takes play order from file names and not from metadata. Numbers shown on screen are positions inside the disc. +4. Titles come from the tag, otherwise from the file name with the artist, album and track number removed. + +## Cover art + +Steam's own library cache image first, then `AlbumArtwork`, `cover`, `folder` and similar files in the soundtrack folder. When none exists, the picture embedded in the first track that has one is used, so the grid shows it without opening the album. The player page shows the embedded picture of the track that is playing and falls back to the album cover for tracks without one. The media notification and the system media panel follow the same rule: while a track plays, its embedded picture replaces the item artwork in place, which does not restart playback, unless a cover was chosen in the art changer. The SteamGridDB artwork changer applies to Steam soundtracks like any other Steam entry. + +## Player page + +The layout follows Steam's soundtrack page and uses the DroidDeck theme colors and shapes, so every theme works. Cover, title, artist and total length sit on the left with seek, shuffle, previous, play or pause, next, repeat and volume. The track list with disc headers sits on the right. Portrait stacks the two. The action buttons (game files, shortcut, edit art, uninstall) use the same wide pill style as Steam's See More button. + +Controller: d-pad moves between buttons and rows, A confirms, B goes back, the sliders respond to left and right. + +Shortcuts use `droiddeck://soundtrack/` and open the soundtrack page. + +## Playback and Android media controls + +`SoundtrackService` is a media3 `MediaSessionService` with an `ExoPlayer`. It runs as a foreground service of type `mediaPlayback`, so playback keeps going when DroidDeck is closed and the notification and lock screen controls show the cover, title and artist. `SoundtrackController` connects a `MediaController` to it and exposes Compose state. + +Launching a game pauses the music unless Enable ingame is on (see Playing during games). Audio focus and headphone unplug are handled by ExoPlayer. + +Added dependencies: `androidx.media3:media3-exoplayer` and `androidx.media3:media3-session` 1.3.1. + +## Playback options + +The player page has a Playback options button that opens a panel with: + +- Speed and pitch, from 0.5x to 2x in 0.05 steps, applied through ExoPlayer's playback parameters. +- Skip silence. +- A sleep timer for 15, 30 or 60 minutes or the end of the current track. The timer runs in `SoundtrackService`, so it still fires when DroidDeck is closed. +- An equalizer with the device presets, one slider per band, and bass boost where the device supports it. The effects are attached to the player's audio session in the service. + +Settings are saved in `soundtrack_settings` and sent to the service whenever the controller connects. The last album, track and position are saved too, so the play button on an album resumes where it stopped. The position is saved on track changes, pauses and seeks. + +## Playing during games + +Setup › Launcher has an Enable ingame toggle, shown while soundtracks are on. When it is off, launching a game pauses the soundtrack. When it is on, the soundtrack keeps playing and the service stops requesting audio focus, so the game's own audio mixes with it. The setting is sent to the service with the `INGAME` session command and is read again when the service starts. + +## Searching and sorting + +Inside a soundtrack, a search field above the track list filters by title, artist and album, and a sort button orders the list by album order, title or length. Track numbers always count from 1 by position in the list shown. + +Custom (added) soundtracks, collections and Favorites can be reordered: select tracks first (long-press one, or use the select button), then with Album order selected and no search text, long-press a selected track and drag it. The order of an added soundtrack is stored in `soundtrack-order.json` and applied by `Soundtrack.load` within each disc; a collection stores its order in `soundtrack-collections.json`. Steam soundtracks cannot be reordered. The Music tab search also looks up tracks: soundtracks and collections whose names match come first, followed by a Tracks section. + +## Favorites and collections + +- The heart under the transport controls adds or removes the current track from Favorites. The bookmark button next to it opens the Saved panel to add the track to a collection or create one. +- The Music tab has a Collections chip. Favorites is the first entry under it. The bookmark in the Music header opens the same Saved panel to open or create a collection. +- Long-press a track to select. The selection bar has Select all, Deselect all, Add to collection, Add to favorites and, on a collection page, Remove from collection. +- A collection page has a Manage button to rename, add tracks, remove tracks or delete. Favorites cannot be renamed or deleted. +- Collection pages have Manage, Playback options, Shortcut and Edit art. Edit art changes the cover only, from a track cover or an image of your own, and is stored in `soundtrack-art/`. Added soundtracks have the same Edit art, with the images in their folder and the first track cover as the choices; Steam soundtracks keep the Steam art editor. +- Collections are stored in `soundtrack-collections.json` in the app files directory as snapshots of path, title, artist, album, length and cover. Tracks whose files are gone are skipped when a collection is played. +- Collection and Favorites playback does not overwrite the saved resume position of an album. +