diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index 5fb8eea126..eda3e08a5b 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -79,6 +79,7 @@ import com.droiddeck.launcher.session.SessionArtifacts import com.droiddeck.launcher.session.SessionPhase import com.droiddeck.launcher.session.SessionState import com.droiddeck.launcher.session.GameStorage +import com.droiddeck.launcher.session.SteamLibraries import com.droiddeck.launcher.input.SecondScreenDisplay import com.droiddeck.launcher.input.SecondScreenDisplays @@ -494,6 +495,20 @@ class FrontEndActivity : ComponentActivity() { private val pickGameStorage = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> if (r.resultCode == RESULT_OK) InAppFilePicker.pickedPath(r.data)?.let { path -> setGameStorage(path, GameStorage.labelFor(this, path)) } } + private var steamLibraries by mutableStateOf>(emptyList()) + private val pickSteamLibrary = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> + val path = if (r.resultCode == RESULT_OK) InAppFilePicker.pickedPath(r.data) else null + if (path != null) Thread({ + val result = SteamLibraries.add(this, path) + ui.post { + steamLibraries = SteamLibraries.list(this) + refresh() + if (result is SteamLibraries.AddResult.Refused) { + android.widget.Toast.makeText(this, getString(R.string.main_storage_not_usable, result.reason), android.widget.Toast.LENGTH_LONG).show() + } + } + }, "steam-library-add").start() + } private var romsDir by mutableStateOf(null) private var steamGames by mutableStateOf>(emptyList()) private var steamGamesX64 by mutableStateOf(false) @@ -2117,6 +2132,7 @@ class FrontEndActivity : ComponentActivity() { mic = if (mode == SessionService.MODE_STEAM) mic else null, gameStorage = if (mode == SessionService.MODE_STEAM) gameStorage else null, storageOptions = storageOptions, + steamLibraries = steamLibraries, storageDiagnostics = mode == SessionService.MODE_STEAM && storageDiagnostics, fexPreset = if (mode == SessionService.MODE_STEAM) fexPreset else null, forceSsbs = forceSsbs, @@ -2181,6 +2197,19 @@ class FrontEndActivity : ComponentActivity() { onPickGameStorageFolder = { pickGameStorage.launch(InAppFilePicker.buildDirIntent(this, getString(R.string.main_pick_game_storage), gameStorage.ifEmpty { null })) }, + onAddSteamLibrary = { + pickSteamLibrary.launch(InAppFilePicker.buildDirIntent(this, getString(R.string.libraries_pick), null)) + }, + onRenameSteamLibrary = { id, label -> + SteamLibraries.rename(this, id, label) + steamLibraries = SteamLibraries.list(this) + refresh() + }, + onRemoveSteamLibrary = { id -> + SteamLibraries.remove(this, id) + steamLibraries = SteamLibraries.list(this) + refresh() + }, onStorageDiagnostics = { on -> SessionPrefs.setStorageDiagnosticsEnabled(this, on) storageDiagnostics = on @@ -2415,6 +2444,7 @@ class FrontEndActivity : ComponentActivity() { mic = SessionPrefs.micEnabled(this) refreshWifiDiscovery() gameStorage = SessionPrefs.gameStorage(this) + steamLibraries = SteamLibraries.list(this) storageDiagnostics = SessionPrefs.storageDiagnosticsEnabled(this) settingsMode = mode Thread({ diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt index 20f158bc54..0c3481e585 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt @@ -6,6 +6,7 @@ import com.droiddeck.launcher.runtime.LinuxRuntime import org.json.JSONObject import com.droiddeck.launcher.session.GameStorage import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SteamLibraries import com.droiddeck.launcher.stores.Store import com.droiddeck.launcher.stores.StoreGameSidecar import com.droiddeck.launcher.stores.StoreInstallRoot @@ -69,6 +70,10 @@ object AddedGames { if (path.startsWith("$roms/")) return "/root/ROMs/" + path.removePrefix("$roms/") } StoreInstallRoot.externalGuestPath(context, host)?.let { return it } + for (lib in SteamLibraries.list(context)) { + if (path == lib.path) return lib.guest + if (path.startsWith("${lib.path}/")) return lib.guest + "/" + path.removePrefix("${lib.path}/") + } GameStorage.effective(context)?.let { lib -> if (path.startsWith("${lib.path}/")) return "$LIBRARY/" + path.removePrefix("${lib.path}/") } @@ -83,6 +88,7 @@ object AddedGames { if (!guest.startsWith("/") || guest.split('/').any { it == ".." }) return null val mapped = roots(context).map { it.host to it.guest } + StoreInstallRoot.externalRoots(context) + listOfNotNull(GameStorage.effective(context)?.let { File(it.path) to LIBRARY }) + + SteamLibraries.list(context).map { it.host to it.guest } + (android.os.Environment.getExternalStorageDirectory() to "/root/Storage") for ((host, root) in mapped.sortedByDescending { it.second.length }) { if (guest == root) return host 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 896d32d8d4..723181f080 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt @@ -5,6 +5,7 @@ import com.droiddeck.launcher.R import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.session.GameStorage import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SteamLibraries import com.droiddeck.launcher.session.SecondaryLibrary import java.io.File @@ -88,11 +89,13 @@ object Library { internal fun steamLibraries(context: Context, arch: String = SessionPrefs.activeSteamClientArch(context)): List> { val root = SessionPrefs.steamRoot(context, arch) val card = GameStorage.effective(context) - if (arch == "x86_64") return listOfNotNull(root to "internal", card?.let { File(it.path, GameStorage.X64_CARD_DIR) to it.label }) + val added = SteamLibraries.list(context).filter { it.host.isDirectory } + if (arch == "x86_64") return listOfNotNull(root to "internal", card?.let { File(it.path, GameStorage.X64_CARD_DIR) to it.label }) + + added.map { it.x64Host to it.label } return listOfNotNull( root to "internal", card?.let { File(it.path) to it.label }, - ) + GameStorage.gamesFolderLibraries(context).map { it.host to it.label } + ) + added.map { it.host to it.label } + GameStorage.gamesFolderLibraries(context).map { it.host to it.label } } fun protonPrefix( diff --git a/app/src/main/java/com/droiddeck/launcher/session/GameStorage.kt b/app/src/main/java/com/droiddeck/launcher/session/GameStorage.kt index b4bd458a5d..eb5bb4e0d9 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/GameStorage.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/GameStorage.kt @@ -62,12 +62,14 @@ object GameStorage { fun gamesFolderLibraries(context: Context): List { if (SessionPrefs.gameStorage(context).isNotEmpty()) return emptyList() val card = effective(context)?.let { canonical(File(it.path)) } + val added = SteamLibraries.list(context).map { canonical(it.host) } val sm = context.getSystemService(StorageManager::class.java) return AddedGames.roots(context).mapNotNull { root -> val host = canonical(root.host) if (!hasInstalledGames(root.host)) return@mapNotNull null if ('"' in root.guest || '\\' in root.guest || !root.host.isDirectory || !root.host.canWrite()) return@mapNotNull null if (card != null && (host == card || host.startsWith("$card/") || card.startsWith("$host/"))) return@mapNotNull null + if (added.any { SteamLibraries.overlaps(it, host) }) return@mapNotNull null val volume = try { sm?.getStorageVolume(root.host)?.getDescription(context) } catch (e: Exception) { null } val name = root.host.name.ifEmpty { context.getString(R.string.gstore_folder) } val label = if (volume.isNullOrBlank()) name else context.getString(R.string.gstore_folder_on_volume, name, volume) 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 bf189a174d..a41b437f87 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -1422,4 +1422,16 @@ object SessionPrefs { fun setGameStorage(context: Context, path: String, label: String) { prefs(context).edit().putString("gameStorage", path).putString("gameStorageLabel", label).apply() } + + fun steamLibraries(context: Context): String = prefs(context).getString("steamLibraries", "") ?: "" + + fun setSteamLibraries(context: Context, json: String) { + prefs(context).edit().putString("steamLibraries", json).apply() + } + + fun steamLibraryNextId(context: Context): Int = prefs(context).getInt("steamLibraryNextId", 1) + + fun setSteamLibraryNextId(context: Context, id: Int) { + prefs(context).edit().putInt("steamLibraryNextId", id).apply() + } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index f43a7f55a2..04bedeefb0 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -1107,6 +1107,42 @@ class SessionService : Service() { } } } + val addedLibraries = ArrayList() + val cardPath = storageDiagnosticLibrary?.let { library?.path }?.let { runCatching { File(it).canonicalPath }.getOrDefault(it) } + for (entry in SteamLibraries.list(this)) { + if (cardPath != null && SteamLibraries.overlaps(cardPath, runCatching { entry.host.canonicalPath }.getOrDefault(entry.path))) { + Log.w(TAG, "added steam library: ${entry.path} overlaps the card library; not a library this session") + continue + } + if (!entry.host.isDirectory) { + Log.w(TAG, "added steam library: ${entry.path} is not attached; not a library this session") + continue + } + val problem = GameStorage.prepare(this, entry.path) + if (problem != null) { + Log.w(TAG, "added steam library: $problem") + continue + } + try { + val room = if (ProotFastPath.enabled(this)) { + ProotFastPath.MAX_BINDS - LinuxRuntime.binds(this, sessionRoot, runtimeDir, Environment.getExternalStorageDirectory(), binds).size + } else Int.MAX_VALUE + val content = SecondaryLibrary.contentPath(entry.host) + val extra = SecondaryLibrary.binds(filesDir, entry.host, listOf(entry.guest), content = content) + if (extra.size > room) { + Log.w(TAG, "added steam library: ${entry.path} needs ${extra.size} binds, $room left for the fast path; not a library this session") + continue + } + File(LinuxRuntime.rootDir(this), entry.guest.removePrefix("/")).mkdirs() + binds.addAll(extra) + libraries.add(entry.guest to entry.label) + steamLibraryMounts = steamLibraryMounts + (entry.guest to content) + addedLibraries.add(entry) + Log.i(TAG, "added steam library: ${content.path} -> ${entry.guest} (\"${entry.label}\")") + } catch (e: Exception) { + Log.w(TAG, "added steam library: ${entry.path} private directories could not be prepared", e) + } + } val x64Libraries = org.json.JSONArray() val x64Here = SessionPrefs.steamClientArch(this) == "x86_64" || (SessionState.mode == MODE_DESKTOP && @@ -1132,6 +1168,27 @@ class SessionService : Service() { Log.w(TAG, "x86-64 steam library: $x64 private directories could not be prepared", e) } } + if (x64Here) for (entry in addedLibraries) { + val problem = GameStorage.prepare(this, entry.x64Host.path) + if (problem != null) { + Log.w(TAG, "x86-64 steam library: $problem") + continue + } + try { + val room = if (ProotFastPath.enabled(this)) { + ProotFastPath.MAX_BINDS - LinuxRuntime.binds(this, sessionRoot, runtimeDir, Environment.getExternalStorageDirectory(), binds).size + } else Int.MAX_VALUE + val extra = SecondaryLibrary.binds(filesDir, entry.x64Host, listOf(entry.x64Guest)).drop(1) + if (extra.size > room) { + Log.w(TAG, "x86-64 steam library: ${entry.x64Host} needs ${extra.size} binds, $room left for the fast path; not a library this session") + continue + } + binds.addAll(extra) + x64Libraries.put(org.json.JSONObject().put("path", entry.x64Guest).put("label", entry.label)) + } catch (e: Exception) { + Log.w(TAG, "x86-64 steam library: ${entry.x64Host} private directories could not be prepared", e) + } + } try { val listing = File(filesDir, "session/steam-libraries-x64.json").apply { parentFile?.mkdirs() } listing.writeText(x64Libraries.toString()) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamLibraries.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamLibraries.kt new file mode 100644 index 0000000000..2d1ea267fc --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamLibraries.kt @@ -0,0 +1,100 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import android.os.storage.StorageManager +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.AddedGames +import java.io.File +import org.json.JSONArray +import org.json.JSONObject + +/** Steam libraries the user added beside the internal one and the card library, each a folder of its own. */ +object SteamLibraries { + const val GUEST_ROOT = "/mnt/droiddeck-lib" + // Each library costs a bind per redirected tool and prefix folder; the PRoot fast path holds 256 in all. + const val MAX = 4 + private val lock = Any() + + class Entry(val id: String, val path: String, val label: String) { + val host: File get() = File(path) + val guest: String get() = "$GUEST_ROOT/$id" + val x64Host: File get() = File(path, GameStorage.X64_CARD_DIR) + val x64Guest: String get() = "$guest/${GameStorage.X64_CARD_DIR}" + } + + fun list(context: Context): List = parse(SessionPrefs.steamLibraries(context)) + + internal fun parse(json: String): List { + if (json.isBlank()) return emptyList() + val array = runCatching { JSONArray(json) }.getOrNull() ?: return emptyList() + return (0 until array.length()).mapNotNull { i -> + val o = array.optJSONObject(i) ?: return@mapNotNull null + val id = o.optString("id") + val path = o.optString("path") + if (!id.matches(Regex("[0-9]{1,6}")) || path.isEmpty()) null else Entry(id, path, clean(o.optString("label")).ifEmpty { File(path).name }) + }.distinctBy { it.id } + } + + private fun save(context: Context, entries: List) { + val array = JSONArray() + for (e in entries) array.put(JSONObject().put("id", e.id).put("path", e.path).put("label", e.label)) + SessionPrefs.setSteamLibraries(context, array.toString()) + } + + /** Steam's libraryfolders.vdf stores labels between quotes with no escaping DroidDeck relies on. */ + internal fun clean(label: String): String = label.replace('"', ' ').replace('\\', ' ').replace(Regex("\\s+"), " ").trim() + + sealed class AddResult { + class Added(val entry: Entry) : AddResult() + class Refused(val reason: String) : AddResult() + } + + fun add(context: Context, path: String, label: String = defaultLabel(context, File(path))): AddResult { + val entries = list(context) + if (entries.size >= MAX) return AddResult.Refused(context.getString(R.string.libraries_full, MAX)) + val host = canonical(File(path)) + val taken = entries.map { canonical(it.host) } + listOfNotNull( + GameStorage.effective(context)?.let { canonical(File(it.path)) }, + canonical(SessionPrefs.steamRoot(context, "arm64")), + ) + if (taken.any { overlaps(it, host) }) return AddResult.Refused(context.getString(R.string.libraries_overlap)) + // Adding a Games folder itself is fine; a child of one would make it overlap and hide the rest of that folder. + if (AddedGames.roots(context).any { host.startsWith(canonical(it.host) + "/") }) return AddResult.Refused(context.getString(R.string.libraries_overlap)) + GameStorage.prepare(context, path)?.let { return AddResult.Refused(it) } + synchronized(lock) { + val current = list(context) + if (current.size >= MAX) return AddResult.Refused(context.getString(R.string.libraries_full, MAX)) + if (current.any { overlaps(canonical(it.host), host) }) return AddResult.Refused(context.getString(R.string.libraries_overlap)) + // A removed library's mount stays registered with Steam until its next session, so ids are never reused. + val next = maxOf(SessionPrefs.steamLibraryNextId(context), (current.maxOfOrNull { it.id.toInt() } ?: 0) + 1) + val entry = Entry(next.toString(), path, clean(label).ifEmpty { File(path).name }) + save(context, current + entry) + SessionPrefs.setSteamLibraryNextId(context, next + 1) + return AddResult.Added(entry) + } + } + + fun rename(context: Context, id: String, label: String) { + val name = clean(label).takeIf { it.isNotEmpty() } ?: return + synchronized(lock) { save(context, list(context).map { if (it.id == id) Entry(it.id, it.path, name) else it }) } + } + + /** Forgets the library; its folder and games stay where they are. */ + fun remove(context: Context, id: String) { + synchronized(lock) { save(context, list(context).filterNot { it.id == id }) } + } + + fun defaultLabel(context: Context, folder: File): String { + val volume = try { + context.getSystemService(StorageManager::class.java)?.getStorageVolume(folder)?.getDescription(context) + } catch (e: Exception) { + null + } + val name = folder.name.ifEmpty { context.getString(R.string.gstore_folder) } + return clean(if (volume.isNullOrBlank()) name else context.getString(R.string.gstore_folder_on_volume, name, volume)) + } + + internal fun overlaps(a: String, b: String): Boolean = a == b || a.startsWith("$b/") || b.startsWith("$a/") + + private fun canonical(file: File): String = runCatching { file.canonicalPath }.getOrDefault(file.absolutePath) +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index 568cbca87d..63508ba42e 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -74,6 +74,7 @@ class ModeSettings( val mic: Boolean?, val gameStorage: String? = null, val storageOptions: List = emptyList(), + val steamLibraries: List = emptyList(), val storageDiagnostics: Boolean = false, val fexPreset: String? = null, val forceSsbs: Boolean = false, @@ -124,6 +125,9 @@ class ModeSettingsActions( val onGameStorage: (path: String, label: String) -> Unit = { _, _ -> }, val onPickGameStorageFolder: () -> Unit = {}, val onStorageDiagnostics: (Boolean) -> Unit = {}, + val onAddSteamLibrary: () -> Unit = {}, + val onRenameSteamLibrary: (id: String, label: String) -> Unit = { _, _ -> }, + val onRemoveSteamLibrary: (id: String) -> Unit = {}, val onFexPreset: (String) -> Unit = {}, val onForceSsbs: (Boolean) -> Unit = {}, val onSyncBackend: (String) -> Unit = {}, @@ -402,6 +406,34 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: onChange = a.onStorageDiagnostics, ) } + if (s.gameStorage != null) SettingsGroup(stringResource(R.string.libraries_title), detail = stringResource(R.string.libraries_applies_next)) { + var renaming by remember { mutableStateOf(null) } + for (library in s.steamLibraries) { + val attached = library.host.isDirectory + SettingsRow(library.label, if (attached) library.path else stringResource(R.string.libraries_missing, library.path)) { + Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(6.dp)) { + SecondaryButton(stringResource(R.string.libraries_rename), compact = true) { renaming = library } + SecondaryButton(stringResource(R.string.edit_remove), compact = true) { a.onRemoveSteamLibrary(library.id) } + } + } + } + SettingsRow( + stringResource(R.string.libraries_add), + if (s.steamLibraries.size < com.droiddeck.launcher.session.SteamLibraries.MAX) stringResource(R.string.libraries_hint) + else stringResource(R.string.libraries_full, com.droiddeck.launcher.session.SteamLibraries.MAX), + ) { + SecondaryButton( + stringResource(R.string.mode_choose_folder), + enabled = s.steamLibraries.size < com.droiddeck.launcher.session.SteamLibraries.MAX, + onClick = a.onAddSteamLibrary, + ) + } + renaming?.let { library -> + TextEntryDialog(stringResource(R.string.libraries_rename_title), library.label, onDismiss = { renaming = null }) { name -> + a.onRenameSteamLibrary(library.id, name) + } + } + } } if (tab == SheetTab.STEAM && steam) { extras.account(host) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d80833d7da..1c12b8283d 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -454,6 +454,16 @@ Internal only Folder: %1$s Second library + More Steam libraries + Folders Steam can install to and play from, each under its own name. Removing one keeps its games on disk. + Add library + Rename + Library name + Choose a folder for the library + At most %1$d added libraries + That folder is already a library or inside one + %1$s ยท not available + Applies from the next Steam session Games that stream assets from SD or shared storage may stutter. Storage diagnostics Record allocation results and sampled storage timings in Share logs. May slow installs while enabled. Applies next session. diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamLibrariesTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamLibrariesTest.kt new file mode 100644 index 0000000000..183618ab85 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/SteamLibrariesTest.kt @@ -0,0 +1,73 @@ +package com.droiddeck.launcher.session + +import com.droiddeck.launcher.frontend.AddedGames +import com.droiddeck.launcher.frontend.Library +import java.io.File +import org.junit.Assert.* +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class SteamLibrariesTest { + private val app get() = RuntimeEnvironment.getApplication() + @get:Rule val tmp = TemporaryFolder() + + private fun added(path: String, label: String = File(path).name): SteamLibraries.Entry = + (SteamLibraries.add(app, path, label) as SteamLibraries.AddResult.Added).entry + + @Test fun addedLibrariesGetStableMountsThatSurviveRenameAndRemoval() { + SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "") + val docs = added(tmp.newFolder("Documents").path, "Docs") + val usb = added(tmp.newFolder("USB").path) + assertEquals(listOf("/mnt/droiddeck-lib/1", "/mnt/droiddeck-lib/2"), SteamLibraries.list(app).map { it.guest }) + assertTrue(File(docs.path, "steamapps").isDirectory) + + SteamLibraries.rename(app, docs.id, "My \"Docs\"") + assertEquals("My Docs", SteamLibraries.list(app).first().label) + assertEquals("/mnt/droiddeck-lib/1", SteamLibraries.list(app).first().guest) + + SteamLibraries.remove(app, docs.id) + assertEquals(listOf(usb.id), SteamLibraries.list(app).map { it.id }) + assertTrue(File(docs.path, "steamapps").isDirectory) + assertEquals("3", added(tmp.newFolder("Again").path).id) + } + + @Test fun overlappingFoldersAndAFifthLibraryAreRefused() { + SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "") + val games = tmp.newFolder("Games") + added(games.path) + assertTrue(SteamLibraries.add(app, games.path) is SteamLibraries.AddResult.Refused) + assertTrue(SteamLibraries.add(app, File(games, "inner").apply { mkdirs() }.path) is SteamLibraries.AddResult.Refused) + repeat(SteamLibraries.MAX - 1) { added(tmp.newFolder("L$it").path) } + assertTrue(SteamLibraries.add(app, tmp.newFolder("Full").path) is SteamLibraries.AddResult.Refused) + } + + @Test fun addedLibrariesAreListedMappedAndKeepGamesFoldersFromDoubling() { + val pc = tmp.newFolder("PC") + File(pc, "steamapps").mkdirs() + File(pc, "steamapps/appmanifest_220.acf").writeText("x") + SessionPrefs.setAddedGamesDirs(app, listOf(pc.path)) + val lib = added(pc.path, "PC") + assertTrue(GameStorage.gamesFolderLibraries(app).isEmpty()) + assertEquals(1, Library.steamLibraries(app, "arm64").count { it.first == pc }) + assertTrue(Library.steamLibraries(app, "x86_64").any { it.first == File(pc, GameStorage.X64_CARD_DIR) }) + assertEquals(File(pc, "steamapps/common"), AddedGames.hostPath(app, "${lib.guest}/steamapps/common")) + val docs = added(tmp.newFolder("Documents").path) + assertEquals("${docs.guest}/steamapps", AddedGames.guestPath(app, File(docs.path, "steamapps"))) + val nested = File(pc, "Other").apply { mkdirs() } + SteamLibraries.remove(app, lib.id) + assertTrue(SteamLibraries.add(app, nested.path) is SteamLibraries.AddResult.Refused) + } + + @Test fun unreadableOrInvalidEntriesAreDropped() { + assertTrue(SteamLibraries.parse("{oops").isEmpty()) + assertEquals(listOf("2"), SteamLibraries.parse("""[{"id":"../x","path":"/a"},{"id":"2","path":"/b","label":""}]""").map { it.id }) + assertEquals("b", SteamLibraries.parse("""[{"id":"2","path":"/b","label":""}]""").single().label) + } +} diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-bookmarks b/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-bookmarks index feb1f304bd..5cbf57b4aa 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-bookmarks +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-desktop-bookmarks @@ -12,6 +12,7 @@ import xml.etree.ElementTree as ET LIBRARY = Path("/mnt/droiddeck-sd") +ADDED = Path("/mnt/droiddeck-lib") URI = "file:///mnt/droiddeck-sd" KDE_OWNER = "http://www.kde.org" MARK = "DroidDeckSteamLibrary" @@ -42,7 +43,7 @@ def steam_libraries(home, data): if not isinstance(path, str): continue path = Path(re.sub(r'\\(["\\])', r'\1', path)) - managed = path == LIBRARY or path.is_relative_to(home / "Games") + managed = path == LIBRARY or path.is_relative_to(home / "Games") or path.is_relative_to(ADDED) if selected is not None and managed and path not in selected: continue if path == LIBRARY and selected is None and not os.environ.get("BL_LIBRARY_LABEL"): diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists b/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists index 17a7418ec7..6bec47b94d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-seed-redists @@ -190,10 +190,14 @@ present() { awk -F'\t' -v hive="$hive" ' regs=() for reg in "$steam_root"/steamapps/common/Proton*/files/share/default_pfx*/system.reg \ /mnt/droiddeck-sd/steamapps/common/Proton*/files/share/default_pfx*/system.reg \ + /mnt/droiddeck-lib/*/steamapps/common/Proton*/files/share/default_pfx*/system.reg \ + /mnt/droiddeck-lib/*/x86-64/steamapps/common/Proton*/files/share/default_pfx*/system.reg \ /root/Games/*/steamapps/common/Proton*/files/share/default_pfx*/system.reg \ "$steam_root"/compatibilitytools.d/*/files/share/default_pfx*/system.reg \ "$steam_root"/steamapps/compatdata/*/pfx/system.reg \ /mnt/droiddeck-sd/steamapps/compatdata/*/pfx/system.reg \ + /mnt/droiddeck-lib/*/steamapps/compatdata/*/pfx/system.reg \ + /mnt/droiddeck-lib/*/x86-64/steamapps/compatdata/*/pfx/system.reg \ /root/Games/*/steamapps/compatdata/*/pfx/system.reg; do [ -f "$reg" ] && regs+=("$reg") done diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 7ad97e5480..b0cbc0a553 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -1217,12 +1217,12 @@ case $mode in : > "$compat_restarted" compat_restarts=0 compat_settled() { - local app m flags r card=/mnt/droiddeck-sd - [ "$steam_x64" = 1 ] && card=/mnt/droiddeck-sd/x86-64 + local app m flags r card=/mnt/droiddeck-sd added=(/mnt/droiddeck-lib/*) + [ "$steam_x64" = 1 ] && { card=/mnt/droiddeck-sd/x86-64; added=(/mnt/droiddeck-lib/*/x86-64); } while read -r app; do [ -n "$app" ] || continue m= - for r in "$steam_root" "$card"; do + for r in "$steam_root" "$card" "${added[@]}"; do [ -f "$r/steamapps/appmanifest_$app.acf" ] && { m=$r/steamapps/appmanifest_$app.acf; break; } done [ -n "$m" ] || return 1 @@ -1291,7 +1291,7 @@ case $mode in done fi if [ "$beat" -le 720 ] && [ "$((beat % 3))" -eq 0 ] && { [ -z "$library_job" ] || ! kill -0 "$library_job" 2>/dev/null; }; then - libraries=("$steam_root/steamapps" /mnt/droiddeck/steamapps /mnt/droiddeck-sd/steamapps /root/Games/*/steamapps) + libraries=("$steam_root/steamapps" /mnt/droiddeck/steamapps /mnt/droiddeck-sd/steamapps /mnt/droiddeck-lib/*/steamapps /mnt/droiddeck-lib/*/x86-64/steamapps /root/Games/*/steamapps) seed=; compat= seed_due && seed=1 compat_due && compat=1 diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library index 6bd6a85494..5577e1aad7 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-library @@ -142,6 +142,7 @@ def relabel(steam_root, target, label): GAMES_DIR = "/root/Games/" +ADDED_DIR = "/mnt/droiddeck-lib/" def wanted(): @@ -182,7 +183,7 @@ def main(): if managed: keep = {library for library, _ in libraries} for library in registered(steam_root): - if library not in keep and (library == LIBRARIES[0][0] or library.startswith(GAMES_DIR)): + if library not in keep and (library == LIBRARIES[0][0] or library.startswith((GAMES_DIR, ADDED_DIR))): forget(steam_root, library) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 index 2db8dce5ab..2a97bcb81d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 @@ -82,8 +82,12 @@ x64_map_direct() { [ "${1:-}" = --live ] && mode=live [ -f "$STEAM_X64/config/config.vdf" ] || return 0 if [ "$mode" = write ] && pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then return 0; fi + local libraries="$STEAM_X64/steamapps:/mnt/droiddeck-sd/x86-64/steamapps:$X64_HOME/shared/arm64/steamapps" library + for library in /mnt/droiddeck-lib/*/x86-64/steamapps; do + [ -d "$library" ] && libraries="$libraries:$library" + done python3 - "$mode" "$STEAM_X64/config/config.vdf" "$STEAM_X64/appcache/appinfo.vdf" "$X64_HOME/direct-auto.json" \ - "$X64_HOME/direct-sniper" "$STEAM_X64/steamapps:/mnt/droiddeck-sd/x86-64/steamapps:$X64_HOME/shared/arm64/steamapps" "$(x64_default_tool)" \ + "$X64_HOME/direct-sniper" "$libraries" "$(x64_default_tool)" \ "$REAL_HOME/.bl-compat-pending" ${BL_X64_DIRECT_APPS:-550} \ <<'PY' || { [ "$mode" = live ] || step "could not map titles to DroidDeck direct"; } # Steam does not swap an installed build when the tool changes: a title installed for Windows stays on Proton. diff --git a/tools/tests/test_steam_libraries.py b/tools/tests/test_steam_libraries.py index 95ae20c24a..18c477a78a 100644 --- a/tools/tests/test_steam_libraries.py +++ b/tools/tests/test_steam_libraries.py @@ -90,6 +90,20 @@ class LibraryListTest(unittest.TestCase): self.assertIn(self.pc, self.paths(self.run_main())) self.assertIn(self.card, self.paths(self.vdf.read_text())) + def test_added_library_is_registered_while_listed_and_forgotten_once_removed(self): + added = self.root / "lib" / "1" + manifest(added / "steamapps", 20) + with patch.object(library, "ADDED_DIR", str(self.root / "lib") + "/"): + self.listing.write_text(json.dumps([{"path": str(added), "label": "Documents"}])) + text = self.run_main() + self.assertIn(added, self.paths(text)) + self.assertIn('"20"\t\t"0"', text) + self.listing.write_text(json.dumps([])) + text = self.run_main() + self.assertNotIn(added, self.paths(text)) + self.assertIn(self.user, self.paths(text)) + self.assertTrue((added / "steamapps/appmanifest_20.acf").is_file()) + def test_without_a_list_only_the_card_is_managed(self): text = self.run_main(listing=False) self.assertEqual([self.steam, self.old, self.user, self.card], self.paths(text))