From 15b9700f0377fe9f26916bba40ff96e8dac953e8 Mon Sep 17 00:00:00 2001 From: The412Banner <205237651+The412Banner@users.noreply.github.com> Date: Sat, 7 Nov 2026 06:11:08 +0000 Subject: [PATCH] feat(stores): Steam store that downloads outside the Steam client Steam joins the Stores list. Games download with the Rust engine into the libraries the active Steam client offers and are registered so the client sees them installed. Downloads show in the store downloads list with cancel; uninstall uses the usual confirmation. The Steam session cannot start while a Steam store download runs, and installs refuse while the session runs. With no saved Steam sign-in the store only offers to open Steam. --- .../main/java/com/droiddeck/launcher/App.kt | 1 + .../droiddeck/launcher/FrontEndActivity.kt | 4 + .../com/droiddeck/launcher/SessionActivity.kt | 6 + .../droiddeck/launcher/stores/CloudSaves.kt | 6 +- .../droiddeck/launcher/stores/LoginFlows.kt | 2 +- .../com/droiddeck/launcher/stores/Store.kt | 3 +- .../launcher/stores/StoreAccounts.kt | 2 +- .../launcher/stores/StoreInstallRoot.kt | 4 +- .../droiddeck/launcher/stores/StoreSizes.kt | 3 +- .../droiddeck/launcher/stores/StoresState.kt | 4 + .../launcher/stores/steam/SteamClient.kt | 121 ++++++ .../launcher/stores/steam/SteamEngine.kt | 91 +++++ .../launcher/stores/steam/SteamInstallJob.kt | 145 ++++++++ .../stores/steam/SteamLibraryFolders.kt | 150 ++++++++ .../launcher/stores/steam/SteamNative.kt | 12 + .../launcher/stores/steam/SteamStore.kt | 346 ++++++++++++++++++ .../droiddeck/launcher/ui/FrontEndScreen.kt | 1 + .../com/droiddeck/launcher/ui/GameDetail.kt | 41 ++- .../com/droiddeck/launcher/ui/LibraryPage.kt | 4 +- .../com/droiddeck/launcher/ui/StoreChips.kt | 4 +- .../launcher/ui/StoresInstallDialog.kt | 59 +++ .../com/droiddeck/launcher/ui/StoresPage.kt | 44 ++- app/src/main/res/values-ar/strings.xml | 2 + app/src/main/res/values-b+es+419/strings.xml | 2 + app/src/main/res/values-bg/strings.xml | 2 + app/src/main/res/values-cs/strings.xml | 2 + app/src/main/res/values-da/strings.xml | 2 + app/src/main/res/values-de/strings.xml | 2 + app/src/main/res/values-el/strings.xml | 2 + app/src/main/res/values-es/strings.xml | 2 + app/src/main/res/values-fi/strings.xml | 2 + app/src/main/res/values-fr/strings.xml | 2 + app/src/main/res/values-hi/strings.xml | 2 + app/src/main/res/values-hu/strings.xml | 2 + app/src/main/res/values-in/strings.xml | 2 + app/src/main/res/values-it/strings.xml | 2 + app/src/main/res/values-ja/strings.xml | 2 + app/src/main/res/values-ko/strings.xml | 2 + app/src/main/res/values-ms/strings.xml | 2 + app/src/main/res/values-nb/strings.xml | 2 + app/src/main/res/values-nl/strings.xml | 2 + app/src/main/res/values-pl/strings.xml | 2 + app/src/main/res/values-pt-rPT/strings.xml | 2 + app/src/main/res/values-pt/strings.xml | 2 + app/src/main/res/values-ro/strings.xml | 2 + app/src/main/res/values-ru/strings.xml | 2 + app/src/main/res/values-sv/strings.xml | 2 + app/src/main/res/values-th/strings.xml | 2 + app/src/main/res/values-tr/strings.xml | 2 + app/src/main/res/values-uk/strings.xml | 2 + app/src/main/res/values-vi/strings.xml | 2 + app/src/main/res/values-zh-rCN/strings.xml | 2 + app/src/main/res/values-zh-rHK/strings.xml | 2 + app/src/main/res/values-zh-rTW/strings.xml | 2 + app/src/main/res/values/strings.xml | 2 + .../stores/steam/SteamLibraryFoldersTest.kt | 274 ++++++++++++++ 56 files changed, 1365 insertions(+), 28 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamClient.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamEngine.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamInstallJob.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamLibraryFolders.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamNative.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/stores/steam/SteamStore.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/stores/steam/SteamLibraryFoldersTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 5ef39f6b6..db5a3f97c 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -61,6 +61,7 @@ class App : Application() { com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.xbox.XboxBackend) com.droiddeck.launcher.sync.Syncthing.init(this) com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.battlenet.BattleNetBackend) + com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.steam.SteamBackend) } private fun prefetchAddonPacks() { diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index dd9c787f7..d6b718cd5 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -2956,6 +2956,10 @@ class FrontEndActivity : ComponentActivity() { android.widget.Toast.makeText(this, R.string.storage_cleanup_busy, android.widget.Toast.LENGTH_SHORT).show() return false } + if (!SessionState.running && com.droiddeck.launcher.stores.steam.SteamStore.blocksSession(intent)) { + android.widget.Toast.makeText(this, R.string.steam_store_session_wait, android.widget.Toast.LENGTH_SHORT).show() + return false + } refreshPhantomStatus() if (steamSession && PhantomProcessLimit.blocksSteam(phantomProcessStatus)) { showPhantomGate = true diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 99fe2528f..b1da46c67 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -629,6 +629,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { finish() return } + if (savedInstanceState == null && !SessionState.running && com.droiddeck.launcher.stores.steam.SteamStore.blocksSession(intent)) { + runtimeRemovalBlocked = true + android.widget.Toast.makeText(this, R.string.steam_store_session_wait, android.widget.Toast.LENGTH_SHORT).show() + finish() + return + } if (!SessionState.running && SessionState.phase in setOf(SessionPhase.IDLE, SessionPhase.FAILED)) { val mode = intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM SessionState.programArgs = intent.getStringArrayExtra(SessionService.EXTRA_PROGRAM_ARGS)?.toList().orEmpty() diff --git a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt index 48244c489..f9828c674 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt @@ -87,7 +87,7 @@ object CloudSaves { val item = sidecar.extra["catalogItemId"].orEmpty() if (ns.isEmpty() || item.isEmpty()) "" else EpicApiClient.getCustomAttribute(token, ns, item, "CloudSaveFolder") } - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET -> "" + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.STEAM -> "" } ?: return null p.edit() .putString("cloud_template_$id", fetched.ifEmpty { TEMPLATE_NONE }) @@ -148,7 +148,7 @@ object CloudSaves { val dir = when (store) { Store.GOG -> CloudSavePaths.gog(template, pfx, folder) Store.EPIC -> CloudSavePaths.epic(template, pfx, folder, EpicCredentialStore.load(context)?.accountId.orEmpty(), id) - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET -> null + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.STEAM -> null } return dir to (if (dir == null) "unresolved" else "ok") } @@ -173,7 +173,7 @@ object CloudSaves { val account = EpicCredentialStore.load(context)?.accountId.orEmpty() if (token == null || account.isEmpty()) null else EpicCloud(account, id, token) } - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET -> null + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.STEAM -> null } private fun gogScopedToken(context: Context, id: String, clientId: String): String? { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt b/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt index 4e53c5ea0..424995396 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt @@ -13,7 +13,7 @@ internal object LoginFlows { Store.EPIC -> epicFlow() Store.AMAZON -> amazonFlow() Store.GAMEJOLT -> gameJoltFlow(browserUserAgent) - Store.ITCH, Store.XBOX, Store.BATTLENET -> null + Store.ITCH, Store.XBOX, Store.BATTLENET, Store.STEAM -> null } @Volatile var epicFlow: () -> StoreLoginActivity.Flow? = { null } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/Store.kt b/app/src/main/java/com/droiddeck/launcher/stores/Store.kt index b7d0fbce1..04e39c5ef 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/Store.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/Store.kt @@ -7,7 +7,8 @@ enum class Store(val id: String, val label: String, val shortLabel: String) { XBOX("xbox", "Xbox", "Xbox"), ITCH("itch", "Itch.io", "Itch.io"), GAMEJOLT("gamejolt", "Game Jolt", "Game Jolt"), - BATTLENET("battlenet", "Battle.net", "Battle.net"); + BATTLENET("battlenet", "Battle.net", "Battle.net"), + STEAM("steamstore", "Steam", "Steam"); val folder: String get() = if (this == ITCH) "itch" else shortLabel diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt index 5de9b5e1a..f407a4fb0 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt @@ -90,7 +90,7 @@ object StoreAccounts { fun signedInAs(context: Context, store: Store): String? { val json = read(context, store) ?: return if (isUnavailable(store)) store.label else null if (store == Store.XBOX) return json.optString("username").takeIf { it.isNotBlank() } - if (store == Store.BATTLENET) return json.optString("display_name").takeIf { it.isNotBlank() } + if (store == Store.BATTLENET || store == Store.STEAM) return json.optString("display_name").takeIf { it.isNotBlank() } if (json.optString("access_token", "").isEmpty()) return null return json.optString("display_name", "").ifEmpty { json.optString("username", "") }.ifEmpty { store.label } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreInstallRoot.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreInstallRoot.kt index b3c3fc079..c68437c38 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreInstallRoot.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreInstallRoot.kt @@ -226,7 +226,7 @@ object StoreInstallRoot { fun storeDir(root: File, store: Store): File = File(root, store.folder) fun gameFolders(context: Context): List = roots(context).flatMap { root -> - Store.entries.flatMap { store -> + Store.entries.filter { it != Store.STEAM }.flatMap { store -> storeDir(root, store).listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() } ?: emptyList() } } @@ -246,7 +246,7 @@ object StoreInstallRoot { fun isFinished(folder: File): Boolean = StoreGameSidecar.read(folder)?.isInstalled == true fun unfinished(context: Context): List = roots(context).flatMap { root -> - Store.entries.filter { it != Store.BATTLENET }.flatMap { store -> + Store.entries.filter { it != Store.BATTLENET && it != Store.STEAM }.flatMap { store -> storeDir(root, store).listFiles { f -> f.isDirectory }.orEmpty().mapNotNull { folder -> val sidecar = StoreGameSidecar.read(folder) when { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt index 545c981e5..c5635905a 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt @@ -55,7 +55,7 @@ object StoreSizes { Store.EPIC -> EpicPrefs.get(app).edit().putLong("size_${item.id}", it).apply() Store.AMAZON -> AmazonPrefs.get(app).edit().putLong("size_${item.id}", it).apply() Store.ITCH, Store.GAMEJOLT -> {} - Store.GOG, Store.XBOX, Store.BATTLENET -> {} + Store.GOG, Store.XBOX, Store.BATTLENET, Store.STEAM -> {} } } }, pool).exceptionally { error -> @@ -114,5 +114,6 @@ object StoreSizes { Store.GOG, Store.XBOX, Store.BATTLENET -> 0L Store.ITCH -> com.droiddeck.launcher.stores.itch.ItchLibrary.size(context, item) Store.GAMEJOLT -> com.droiddeck.launcher.stores.gamejolt.GameJoltBuilds.size(context, item) + Store.STEAM -> com.droiddeck.launcher.stores.steam.SteamStore.plannedBytes(context, item) } } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt index e7a9383f3..1592dab08 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt @@ -85,6 +85,8 @@ object StoresState { do { seen = refreshRequests.get() runCatching { com.droiddeck.launcher.stores.battlenet.BattleNetClient.syncAccount(app) } + runCatching { com.droiddeck.launcher.stores.steam.SteamStore.syncAccount(app) } + runCatching { com.droiddeck.launcher.stores.steam.SteamStore.scanInstalled(app) } val found = Store.entries.mapNotNull { store -> StoreAccounts.displayName(app, store)?.let { store to it } } val onDisk = StoreInstallRoot.gameFolders(app).mapNotNull { folder -> StoreGameSidecar.read(folder)?.takeIf { it.isInstalled || it.state == StoreGameSidecar.STATE_UPDATING }?.let { InstalledStoreGame(it, folder) } @@ -238,6 +240,7 @@ object StoresState { fun requestInstall(context: Context, item: CatalogItem) { askForNotifications(context) + if (item.store == Store.STEAM) { com.droiddeck.launcher.stores.steam.SteamStore.requestInstall(context, item); return } if (item.store == Store.ITCH && item.extra["uploadId"].isNullOrEmpty()) { itchPicking = item; return } if (item.store == Store.GAMEJOLT && item.extra["buildId"].isNullOrEmpty()) { gameJoltPicking = item; return } if (isUnfinished(item)) { install(context, item); return } @@ -256,6 +259,7 @@ object StoresState { fun install(context: Context, item: CatalogItem, root: java.io.File? = null, language: String? = null) { val app = context.applicationContext + if (item.store == Store.STEAM) { com.droiddeck.launcher.stores.steam.SteamStore.restore(app, item); return } val targetRoot = root ?: StoreInstallRoot.defaultTarget(app)?.root ?: StoreInstallRoot.installRoot(app) if (item.store == Store.BATTLENET && !com.droiddeck.launcher.stores.battlenet.BattleNetInstall.headless(item)) { backends[item.store]?.install(app, item, targetRoot) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamClient.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamClient.kt new file mode 100644 index 000000000..886761c41 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamClient.kt @@ -0,0 +1,121 @@ +package com.droiddeck.launcher.stores.steam + +import android.content.Context +import android.os.Environment +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.AddedGames +import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.runtime.LinuxRuntime +import com.droiddeck.launcher.session.GameStorage +import com.droiddeck.launcher.session.SecondaryLibrary +import com.droiddeck.launcher.session.SessionPhase +import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SessionService +import com.droiddeck.launcher.session.SessionState +import com.droiddeck.launcher.session.SteamLibraries +import com.droiddeck.launcher.stores.StoreInstallRoot +import org.json.JSONArray +import org.json.JSONObject +import java.io.File + +/** The active Steam client's folders as the app sees them. Reads storage; call off the main thread. */ +internal object SteamClient { + const val X86_64 = "x86_64" + + class Target( + val library: SteamLibraryFolders.Library, val engineHost: File, val label: String, + val freeBytes: Long, val removable: Boolean, val folder: Boolean, + ) + + fun activeArch(context: Context): String = SessionPrefs.activeSteamClientArch(context) + + private fun guestHome(arch: String) = if (arch == X86_64) "/root/.droiddeck-x64" else "/root" + + fun guestRoot(arch: String) = "${guestHome(arch)}/.local/share/Steam" + + private fun aliases(arch: String) = listOf(guestRoot(arch), "${guestHome(arch)}/.steam/steam", "${guestHome(arch)}/.steam/root") + + fun root(context: Context, arch: String = activeArch(context)): File = SessionPrefs.steamRoot(context, arch) + + fun registry(context: Context, arch: String = activeArch(context)): File = + File(LinuxRuntime.rootDir(context), guestHome(arch).removePrefix("/") + "/.steam/registry.vdf") + + fun loginUsers(context: Context, arch: String = activeArch(context)): File = File(root(context, arch), "config/loginusers.vdf") + + fun language(context: Context): String = + runCatching { SteamLibraryFolders.language(registry(context).readText()) }.getOrNull() ?: "english" + + fun mounts(context: Context): List { + val out = ArrayList() + GameStorage.effective(context)?.let { card -> SecondaryLibrary.CARD_GUESTS.forEach { out += SteamLibraryFolders.Mount(it, File(card.path)) } } + SteamLibraries.list(context).forEach { out += SteamLibraryFolders.Mount(it.guest, it.host) } + AddedGames.roots(context).forEach { out += SteamLibraryFolders.Mount(it.guest, it.host) } + StoreInstallRoot.externalRoots(context).forEach { (host, guest) -> out += SteamLibraryFolders.Mount(guest, host) } + out += SteamLibraryFolders.Mount("/root/Storage", Environment.getExternalStorageDirectory()) + return out + } + + /** Every library the client lists in libraryfolders.vdf that maps to a folder of the app. */ + fun libraries(context: Context, arch: String = activeArch(context)): List { + val root = root(context, arch) + val text = runCatching { File(root, "steamapps/libraryfolders.vdf").readText() }.getOrNull().orEmpty() + return SteamLibraryFolders.resolve( + SteamLibraryFolders.parse(text), guestRoot(arch), aliases(arch), root, mounts(context), LinuxRuntime.rootDir(context), + ) + } + + private fun canonical(file: File): String = runCatching { file.canonicalPath }.getOrDefault(file.absolutePath) + + /** The card and added libraries are written through the raw card view when Android allows it, as the session binds them. */ + private fun engineView(context: Context): (File) -> File { + val bases = listOfNotNull(GameStorage.effective(context)?.let { File(it.path) }) + SteamLibraries.list(context).map { it.host } + val seen = HashMap() + return { host -> + val path = host.absolutePath + val base = bases.filter { path == it.absolutePath || path.startsWith(it.absolutePath + "/") }.maxByOrNull { it.absolutePath.length } + if (base == null) host else { + val content = seen.getOrPut(base.absolutePath) { SecondaryLibrary.contentPath(base) } + if (content.absolutePath == base.absolutePath) host + else path.removePrefix(base.absolutePath).trimStart('/').let { if (it.isEmpty()) content else File(content, it) } + } + } + } + + class EngineLibraries(val libraries: List>) { + val json: String get() = JSONArray().apply { + for ((library, host) in libraries) put(JSONObject().put("host", host.absolutePath).put("guest", library.guest)) + }.toString() + + fun hostOf(library: SteamLibraryFolders.Library): File = + libraries.firstOrNull { it.first.guest == library.guest }?.second ?: library.host + } + + fun engineLibraries(context: Context): EngineLibraries { + val view = engineView(context) + return EngineLibraries(libraries(context).filter { it.host.isDirectory }.map { it to view(it.host) }) + } + + fun targets(context: Context): List { + val arch = activeArch(context) + val card = GameStorage.effective(context)?.let { canonical(File(it.path)) } + val known = Library.steamLibraries(context, arch).associate { (host, label) -> + canonical(host) to if (label == "internal") context.getString(R.string.games_internal) else label + } + val engine = engineLibraries(context) + return engine.libraries.mapNotNull { (library, host) -> + if (!library.host.isDirectory || !library.host.canWrite()) return@mapNotNull null + val path = canonical(library.host) + val onCard = card != null && (path == card || path.startsWith("$card/")) + val label = library.label.ifBlank { + if (library.main) context.getString(R.string.stores_target_internal) else known[path] ?: File(library.guest).name + } + Target(library, host, label, StoreInstallRoot.availableBytes(host), removable = onCard, folder = !library.main && !onCard) + } + } + + /** True while a session that can run the Steam client is up or starting. */ + fun clientMayRun(): Boolean { + val up = SessionState.running || (SessionState.phase != SessionPhase.IDLE && SessionState.phase != SessionPhase.FAILED) + return up && SessionState.mode != SessionService.MODE_RUN + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamEngine.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamEngine.kt new file mode 100644 index 000000000..ea7a94498 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamEngine.kt @@ -0,0 +1,91 @@ +package com.droiddeck.launcher.stores.steam + +import android.content.Context +import android.os.SystemClock +import android.util.Log +import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.stores.StoresNative +import org.json.JSONArray +import org.json.JSONObject + +/** Blocking calls into the Rust engine; they reach the network, so never on the main thread. */ +internal object SteamEngine { + private const val TAG = "SteamEngine" + const val MISSING = "engine_missing" + const val MISSING_TEXT = "Steam: the store engine is not available" + + private const val RETRY_MS = 60_000L + + private val lock = Any() + @Volatile private var signedIn = false + private var failed: JSONObject? = null + private var failedAt = 0L + + fun failure(error: String): JSONObject = JSONObject().put("ok", false).put("error", error) + + private fun call(op: String, block: () -> String): JSONObject { + if (!StoresNative.ensureLoaded()) return failure(MISSING) + val text = try { + block() + } catch (e: UnsatisfiedLinkError) { + Log.w(TAG, "$op: not in this engine build") + return failure(MISSING) + } catch (t: Throwable) { + Log.w(TAG, "$op: ${t.javaClass.simpleName}") + return failure(t.javaClass.simpleName) + } + return runCatching { JSONObject(text) }.getOrElse { failure("$op: unreadable answer") } + } + + fun signIn(context: Context): JSONObject { + synchronized(lock) { + if (signedIn) return JSONObject().put("ok", true) + failed?.takeIf { SystemClock.elapsedRealtime() - failedAt < RETRY_MS }?.let { return it } + val roots = JSONArray() + .put(SessionPrefs.steamRoot(context, "arm64").absolutePath) + .put(SessionPrefs.steamRoot(context, SteamClient.X86_64).absolutePath) + val registry = SteamClient.registry(context).absolutePath + val answer = call("signIn") { SteamNative.nativeSignIn(roots.toString(), registry, "") } + signedIn = answer.optBoolean("ok") + failed = if (signedIn) null else answer + failedAt = SystemClock.elapsedRealtime() + if (!signedIn) Log.w(TAG, "sign-in: ${answer.optString("error")}") + return answer + } + } + + fun forget() { + synchronized(lock) { + failed = null + if (!signedIn) return + signedIn = false + try { + SteamNative.nativeSignOut() + } catch (t: Throwable) { + Log.w(TAG, "sign-out: ${t.javaClass.simpleName}") + } + } + } + + private fun signedCall(context: Context, op: String, block: () -> String): JSONObject { + synchronized(lock) { + val signIn = signIn(context) + if (!signIn.optBoolean("ok")) return signIn + val answer = call(op, block) + val error = answer.optString("error").lowercase() + if (!answer.optBoolean("ok") && listOf("logon", "sign", "session", "connect").any { it in error }) signedIn = false + return answer + } + } + + fun library(context: Context): JSONObject = signedCall(context, "library") { SteamNative.nativeLibrary() } + + fun plan(context: Context, appId: Int, language: String): JSONObject = + signedCall(context, "plan") { SteamNative.nativePlan(appId, language) } + + fun uninstall(appId: Int, steamRoot: String, host: String, guest: String, roots: String): JSONObject { + synchronized(lock) { + return call("uninstall") { SteamNative.nativeUninstall(appId, steamRoot, host, guest, roots) } + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamInstallJob.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamInstallJob.kt new file mode 100644 index 000000000..38ebbf51d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamInstallJob.kt @@ -0,0 +1,145 @@ +package com.droiddeck.launcher.stores.steam + +import android.content.Context +import com.droiddeck.launcher.R +import com.droiddeck.launcher.stores.download.DownloadQueue +import com.droiddeck.launcher.stores.download.DownloadStage +import com.droiddeck.launcher.stores.download.StoreDownloadTier +import org.json.JSONObject +import java.io.File +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicReference + +/** Called by the engine on its own threads. */ +interface SteamInstallListener { + fun onProgress(doneBytes: Long, totalBytes: Long, phase: String?) + fun onComplete(ok: Boolean, result: String?) +} + +internal class SteamInstallJob( + private val app: Context, + private val appId: Int, + private val libraryGuest: String, +) : DownloadQueue.DownloadJob { + private val cancelled = AtomicBoolean(false) + private val started = AtomicBoolean(false) + @Volatile private var discard = false + @Volatile private var installDir: String? = null + @Volatile private var libraryHost: File? = null + + override fun run(handle: DownloadQueue.JobHandle): String? { + started.set(true) + try { + return install(handle) + } finally { + if (discard) SteamStore.discardPartial(app, appId, libraryGuest, libraryHost, installDir) + } + } + + private fun install(handle: DownloadQueue.JobHandle): String? { + handle.stage(DownloadStage.MANIFEST) + if (SteamClient.clientMayRun()) throw IllegalStateException(app.getString(R.string.steam_store_close_steam)) + val engine = SteamClient.engineLibraries(app) + val target = engine.libraries.firstOrNull { it.first.guest == libraryGuest } + ?: throw IllegalStateException(app.getString(R.string.game_sync_err_steam_library)) + libraryHost = target.second + val signIn = SteamEngine.signIn(app) + if (!signIn.optBoolean("ok")) { + SteamStore.signInFailed(app, signIn.optString("error")) + throw IllegalStateException(SteamStore.errorText(app, signIn)) + } + val language = SteamClient.language(app) + val (plan, planned) = SteamStore.plan(app, appId, language) + if (plan == null) throw IllegalStateException(SteamStore.errorText(app, planned)) + installDir = plan.installDir + if (plan.installBytes > 0) handle.diskSize(plan.installBytes) + if (cancelled.get()) return null + + val tier = StoreDownloadTier.current(app) + val journal = File(app.filesDir, "${SteamStore.JOURNAL}/$appId").apply { mkdirs() } + handle.log("steam: $appId tier=${tier.id} window=${tier.networkWindow} process_workers=${tier.processWorkers}") + val done = CountDownLatch(1) + val succeeded = AtomicBoolean(false) + val answer = AtomicReference("") + val listener = object : SteamInstallListener { + private var stage: DownloadStage? = null + private var shown = -1L + + override fun onProgress(doneBytes: Long, totalBytes: Long, phase: String?) { + synchronized(this) { + val now = SteamLibraryFolders.stageOf(phase.orEmpty()) + if (now != stage) { + stage = now + shown = -1L + } + if (doneBytes < shown) return + shown = doneBytes + if (now == DownloadStage.DOWNLOAD) handle.progress(doneBytes, totalBytes) + else { + handle.stage(now) + if (totalBytes > 0) handle.stageProgress(doneBytes, totalBytes, bytes = true) + } + } + } + + override fun onComplete(ok: Boolean, result: String?) { + answer.set(result.orEmpty()) + succeeded.set(ok) + done.countDown() + } + } + val native = try { + SteamNative.nativeStart( + appId, language, SteamClient.root(app).absolutePath, target.second.absolutePath, libraryGuest, engine.json, + journal.absolutePath, "", tier.networkWindow.coerceIn(1, 128), tier.processWorkers, listener, + ) + } catch (e: UnsatisfiedLinkError) { + throw IllegalStateException(SteamEngine.MISSING_TEXT) + } + if (native == 0L && done.count > 0L) throw IllegalStateException(SteamStore.errorText(app, parse(answer.get()))) + if (native != 0L) { + try { + var forwarded = false + while (true) { + val finished = try { + done.await(CANCEL_POLL_MS, TimeUnit.MILLISECONDS) + } catch (e: InterruptedException) { + cancelled.set(true) + false + } + if (finished) break + if (!forwarded && cancelled.get()) { + runCatching { SteamNative.nativeCancel(native) } + forwarded = true + } + } + } finally { + runCatching { SteamNative.nativeRelease(native) } + } + } + val result = parse(answer.get()) + if (succeeded.get() && result.optBoolean("ok", true)) { + journal.deleteRecursively() + SteamStore.scanInstalled(app) + return File(target.first.host, "steamapps/common/${plan.installDir}").path + } + if (cancelled.get() || result.optString("error") == "cancelled") return null + throw IllegalStateException(SteamStore.errorText(app, result)) + } + + private fun parse(text: String): JSONObject = + runCatching { JSONObject(text) }.getOrElse { SteamEngine.failure(text.ifBlank { "install failed" }) } + + override fun cancel(deleteFiles: Boolean) { + cancelled.set(true) + if (!deleteFiles) return + discard = true + if (!started.get()) SteamStore.discardPartial(app, appId, libraryGuest, null, null) + } + + private companion object { + const val CANCEL_POLL_MS = 250L + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamLibraryFolders.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamLibraryFolders.kt new file mode 100644 index 000000000..5db160dbf --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamLibraryFolders.kt @@ -0,0 +1,150 @@ +package com.droiddeck.launcher.stores.steam + +import com.droiddeck.launcher.storage.SteamStorage +import com.droiddeck.launcher.stores.download.DownloadStage +import java.io.File + +internal object SteamLibraryFolders { + data class Folder(val path: String, val label: String) + + class Mount(guest: String, val host: File) { + val guest: String = guest.trimEnd('/') + } + + data class Library(val guest: String, val host: File, val label: String, val main: Boolean) + + data class Installed(val appId: Int, val name: String, val installDir: String?, val library: Library, val sizeOnDisk: Long) + + /** Guest folders that exist only as binds of the session; without their bind they are empty mount points in the rootfs. */ + val BIND_ONLY = listOf("/mnt", "/media", "/storage", "/sdcard", "/root/Storage", "/root/ROMs", "/root/Games") + + private val TOKEN = Regex("\"((?:\\\\.|[^\"\\\\])*)\"|[{}]|//[^\n]*") + private val ACF = Regex("appmanifest_\\d+\\.acf") + private val SIZE_ON_DISK = Regex("^\\s*\"SizeOnDisk\"\\s*\"(\\d+)\"", setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE)) + + private fun walk(text: String, pair: (blocks: List, key: String, value: String) -> Unit, closed: (blocks: List) -> Unit = {}) { + val blocks = ArrayList() + var key: String? = null + for (m in TOKEN.findAll(text)) { + val token = m.value + when { + token.startsWith("//") -> {} + token == "{" -> { blocks.add(key.orEmpty()); key = null } + token == "}" -> { if (blocks.isNotEmpty()) { closed(blocks); blocks.removeAt(blocks.lastIndex) }; key = null } + key == null -> key = unescape(m.groupValues[1]) + else -> { pair(blocks, key, unescape(m.groupValues[1])); key = null } + } + } + } + + private fun unescape(s: String): String { + if ('\\' !in s) return s + val out = StringBuilder(s.length) + var i = 0 + while (i < s.length) { + if (s[i] == '\\' && i + 1 < s.length) { out.append(s[i + 1]); i += 2 } else { out.append(s[i]); i++ } + } + return out.toString() + } + + private fun inRoot(blocks: List) = blocks.firstOrNull()?.equals("libraryfolders", ignoreCase = true) == true + + fun parse(text: String): List { + val out = ArrayList() + var path: String? = null + var label = "" + walk(text, pair = { blocks, key, value -> + if (!inRoot(blocks)) return@walk + if (blocks.size == 1 && key.isNotEmpty() && key.all(Char::isDigit)) out += Folder(value, "") + if (blocks.size == 2) when (key.lowercase()) { + "path" -> path = value + "label" -> label = value + } + }, closed = { blocks -> + if (blocks.size == 2 && inRoot(blocks)) path?.let { out += Folder(it, label) } + if (blocks.size == 2) { path = null; label = "" } + }) + return out + } + + fun normalize(path: String): String? { + val p = path.trim().replace(Regex("/+"), "/").trimEnd('/') + if (!p.startsWith("/") || p.split('/').any { it == ".." || it == "." }) return null + return p + } + + private fun under(path: String, prefix: String) = path == prefix || path.startsWith("$prefix/") + + fun hostFor(guest: String, mounts: List, rootfs: File): File? { + val path = normalize(guest) ?: return null + mounts.filter { it.guest.isNotEmpty() && under(path, it.guest) }.maxByOrNull { it.guest.length }?.let { m -> + val rest = path.removePrefix(m.guest).trimStart('/') + return if (rest.isEmpty()) m.host else File(m.host, rest) + } + if (BIND_ONLY.any { under(path, it) } || !under(path, "/root")) return null + return File(rootfs, path.removePrefix("/")) + } + + fun resolve(folders: List, mainGuest: String, aliases: Collection, mainHost: File, mounts: List, rootfs: File): List { + val mains = (aliases + mainGuest).mapNotNull(::normalize).toSet() + val listed = if (folders.any { normalize(it.path) in mains }) folders else listOf(Folder(mainGuest, "")) + folders + val out = ArrayList() + for (f in listed) { + val guest = normalize(f.path) ?: continue + val main = guest in mains + val host = if (main) mainHost else hostFor(guest, mounts, rootfs) ?: continue + if (out.any { it.host.path == host.path || (main && it.main) }) continue + out += Library(guest, host, f.label.trim(), main) + } + return out.sortedByDescending { it.main } + } + + fun installed(libraries: List, read: (File) -> String? = { runCatching { it.readText() }.getOrNull() }): Map { + val out = LinkedHashMap() + for (library in libraries) { + val apps = File(library.host, "steamapps") + val names = apps.list() ?: continue + for (name in names.sorted()) { + if (!ACF.matches(name)) continue + val file = File(apps, name) + val text = read(file) ?: continue + val manifest = SteamStorage.parseManifest(file, text) ?: continue + if (!manifest.installed || SteamStorage.isTool(manifest) || manifest.appId in out) continue + val size = SIZE_ON_DISK.find(text)?.groupValues?.get(1)?.toLongOrNull() ?: 0L + out[manifest.appId] = Installed(manifest.appId, manifest.name, manifest.installDir, library, size) + } + } + return out + } + + /** The account the client signs in with by itself: remembered, the most recent one first. */ + fun savedAccount(loginUsers: String): String? { + val users = LinkedHashMap>() + walk(loginUsers, pair = { blocks, key, value -> + if (blocks.size == 2 && blocks[0].equals("users", ignoreCase = true)) users.getOrPut(blocks[1]) { HashMap() }[key.lowercase()] = value + }) + val remembered = users.values.filter { it["rememberpassword"] == "1" } + val user = remembered.firstOrNull { it["mostrecent"] == "1" } + ?: remembered.maxByOrNull { it["timestamp"]?.toLongOrNull() ?: 0L } + ?: return null + return user["personaname"]?.takeIf { it.isNotBlank() } ?: user["accountname"]?.takeIf { it.isNotBlank() } + } + + fun language(registry: String): String? { + var found: String? = null + walk(registry, pair = { blocks, key, value -> + if (found == null && key.equals("language", ignoreCase = true) && blocks.lastOrNull().equals("Steam", ignoreCase = true) && value.isNotBlank()) found = value + }) + return found + } + + fun stageOf(phase: String): DownloadStage { + val p = phase.lowercase() + return when { + "verif" in p || "validat" in p -> DownloadStage.VERIFY + listOf("install", "regist", "final", "commit", "acf", "apply").any { it in p } -> DownloadStage.INSTALL + listOf("manifest", "plan", "prepar", "check", "scan", "clean", "alloc", "connect", "logon", "login", "sign").any { it in p } -> DownloadStage.MANIFEST + else -> DownloadStage.DOWNLOAD + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamNative.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamNative.kt new file mode 100644 index 000000000..bce35d450 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamNative.kt @@ -0,0 +1,12 @@ +package com.droiddeck.launcher.stores.steam + +object SteamNative { + @JvmStatic external fun nativeSignIn(steamRootsJson: String, registryVdfPath: String, caBundlePath: String): String + @JvmStatic external fun nativeSignOut() + @JvmStatic external fun nativeLibrary(): String + @JvmStatic external fun nativePlan(appId: Int, language: String): String + @JvmStatic external fun nativeStart(appId: Int, language: String, steamRoot: String, gameLibraryHost: String, gameLibraryGuest: String, libraryRootsJson: String, journalDir: String, caBundlePath: String, maxWorkers: Int, processWorkers: Int, listener: Any): Long + @JvmStatic external fun nativeCancel(handle: Long) + @JvmStatic external fun nativeRelease(handle: Long) + @JvmStatic external fun nativeUninstall(appId: Int, steamRoot: String, gameLibraryHost: String, gameLibraryGuest: String, libraryRootsJson: String): String +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamStore.kt b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamStore.kt new file mode 100644 index 000000000..9263f7235 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/steam/SteamStore.kt @@ -0,0 +1,346 @@ +package com.droiddeck.launcher.stores.steam + +import android.content.Context +import android.content.Intent +import android.net.Uri +import android.util.Log +import android.widget.Toast +import androidx.annotation.StringRes +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import com.droiddeck.launcher.R +import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.session.SessionService +import com.droiddeck.launcher.storage.SteamStorage +import com.droiddeck.launcher.stores.CatalogItem +import com.droiddeck.launcher.stores.InstalledStoreGame +import com.droiddeck.launcher.stores.Store +import com.droiddeck.launcher.stores.StoreAccounts +import com.droiddeck.launcher.stores.StoreBackend +import com.droiddeck.launcher.stores.StoreInstallRoot +import com.droiddeck.launcher.stores.StoreInstalls +import com.droiddeck.launcher.stores.StoreShelves +import com.droiddeck.launcher.stores.StoreSizes +import com.droiddeck.launcher.stores.StoresState +import com.droiddeck.launcher.stores.download.DownloadEntry +import com.droiddeck.launcher.stores.download.DownloadQueue +import com.droiddeck.launcher.stores.download.DownloadState +import com.droiddeck.launcher.stores.download.SavedQueue +import com.droiddeck.launcher.stores.formatBytes +import org.json.JSONArray +import org.json.JSONObject +import java.io.File +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.Executors + +/** Games land in the active client's own libraries, registered as the client does, and only while no session can run the client. */ +internal object SteamStore { + private const val TAG = "SteamStore" + private const val PREFS = "steam-store" + internal const val JOURNAL = "steam-store/journal" + private const val CDN = "https://cdn.cloudflare.steamstatic.com/steam/apps/" + private const val LIBRARY = "library" + private const val LIBRARY_LABEL = "libraryLabel" + private val SIGNED_OUT = setOf("no_saved_login", "remember_me_off", "decrypt_failed") + + var installed by mutableStateOf>(emptyMap()) + private set + + var picking by mutableStateOf(null) + + class Plan(val installDir: String, val downloadBytes: Long, val installBytes: Long, val buildId: String) { + companion object { + fun of(json: JSONObject): Plan? { + if (!json.optBoolean("ok")) return null + val dir = json.optString("installDir").takeIf { SteamStore.validDir(it) } ?: return null + return Plan(dir, json.optLong("downloadBytes"), json.optLong("installBytes"), json.optString("buildId")) + } + } + } + + private val plans = ConcurrentHashMap() + private val work = Executors.newSingleThreadExecutor { r -> Thread(r, "steam-store") } + @Volatile private var rejectedThisRun: String? = null + + fun key(appId: Int): String = "${Store.STEAM.id}:$appId" + + private fun validDir(dir: String) = dir.isNotBlank() && dir != "." && dir != ".." && '/' !in dir && '\\' !in dir + + private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + private fun toast(context: Context, @StringRes text: Int) { + val app = context.applicationContext + StoresState.post { Toast.makeText(app, text, Toast.LENGTH_LONG).show() } + } + + internal fun isSignInError(error: String) = error in SIGNED_OUT || error.startsWith("logon_failed") + + internal fun errorText(context: Context, answer: JSONObject): String { + val error = answer.optString("error") + return when { + error == SteamEngine.MISSING -> SteamEngine.MISSING_TEXT + isSignInError(error) -> context.getString(R.string.stores_login_title, Store.STEAM.label) + error.isBlank() -> "Steam: install failed" + else -> error + } + } + + private fun fingerprint(context: Context): String { + val users = SteamClient.loginUsers(context) + val registry = SteamClient.registry(context) + return "${SteamClient.activeArch(context)}:${users.lastModified()}:${users.length()}:${registry.lastModified()}:${registry.length()}" + } + + private fun savedAccount(context: Context): String? { + val print = fingerprint(context) + if (print == rejectedThisRun || print == prefs(context).getString("rejected", null)) return null + return runCatching { SteamLibraryFolders.savedAccount(SteamClient.loginUsers(context).readText()) }.getOrNull() + } + + /** Mirrors the client's saved sign-in into the store account; reads storage. */ + fun syncAccount(context: Context): Boolean { + val name = savedAccount(context) + if (name == StoreAccounts.signedInAs(context, Store.STEAM)) return false + if (name == null) StoreAccounts.clear(context, Store.STEAM) + else StoreAccounts.write(context, Store.STEAM, JSONObject().put("display_name", name)) + SteamEngine.forget() + StoresState.post { + StoresState.library.remove(Store.STEAM) + StoresState.problems.remove(Store.STEAM) + } + Log.i(TAG, if (name == null) "no saved Steam sign-in" else "Steam sign-in found") + return true + } + + internal fun signInFailed(context: Context, error: String) { + if (error == SteamEngine.MISSING) return + val print = fingerprint(context) + rejectedThisRun = print + if (error in SIGNED_OUT) prefs(context).edit().putString("rejected", print).apply() + StoreAccounts.clear(context, Store.STEAM) + StoresState.logLine("Steam: the saved sign-in was not accepted ($error)") + StoresState.post { + StoresState.accounts.remove(Store.STEAM) + StoresState.library.remove(Store.STEAM) + } + } + + fun poll(context: Context) { + val app = context.applicationContext + work.execute { + val changed = runCatching { syncAccount(app) }.getOrDefault(false) + runCatching { scanInstalled(app) } + if (changed) StoresState.notifyLibraryChanged(app) + } + } + + private class Read(val modified: Long, val length: Long, val text: String) + private val manifests = ConcurrentHashMap() + + private fun readManifest(file: File): String? { + val modified = file.lastModified() + val length = file.length() + manifests[file.path]?.takeIf { it.modified == modified && it.length == length }?.let { return it.text } + val text = runCatching { file.readText() }.getOrNull() ?: return null + manifests[file.path] = Read(modified, length, text) + return text + } + + /** Owned games count as installed when an appmanifest with StateFlags 4 is in one of the active client's libraries. */ + fun scanInstalled(context: Context) { + val found = SteamLibraryFolders.installed(SteamClient.libraries(context), ::readManifest) + StoresState.post { + if (found != installed) installed = found + for ((id, game) in found) if (game.sizeOnDisk > 0 && StoreSizes.onDisk[key(id)] != game.sizeOnDisk) StoreSizes.onDisk[key(id)] = game.sizeOnDisk + } + } + + fun downloading(): Boolean = StoresState.latestDownloads.any { + it.store == Store.STEAM && (it.state == DownloadState.RUNNING || it.state == DownloadState.QUEUED) + } + + /** A Steam store download holds every session that could start the Steam client. */ + fun blocksSession(intent: Intent?): Boolean { + val mode = intent?.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM + return mode != SessionService.MODE_RUN && downloading() + } + + internal fun syncLibrary(context: Context, force: Boolean) { + val app = context.applicationContext + if (force) plans.clear() + work.execute { + val answer = SteamEngine.library(app) + if (!answer.optBoolean("ok")) { + val error = answer.optString("error") + if (isSignInError(error)) signInFailed(app, error) + else StoresState.post { + StoresState.problems[Store.STEAM] = errorText(app, answer) + StoresState.library[Store.STEAM] = emptyList() + } + return@execute + } + val art = runCatching { Library.steamLibraryArt(app).toMap() }.getOrDefault(emptyMap()) + val items = items(answer.optJSONArray("games"), art) + runCatching { scanInstalled(app) } + StoresState.logLine("Steam: library has ${items.size} games") + StoresState.post { + StoresState.problems.remove(Store.STEAM) + StoresState.library[Store.STEAM] = items + } + } + } + + private fun items(games: JSONArray?, art: Map): List { + val out = ArrayList() + for (i in 0 until (games?.length() ?: 0)) { + val game = games?.optJSONObject(i) ?: continue + val id = game.optInt("appId").takeIf { it > 0 } ?: continue + val type = game.optString("type").lowercase() + if (type.isNotEmpty() && type != "game") continue + val name = game.optString("name").takeIf { it.isNotBlank() } ?: continue + out += CatalogItem( + Store.STEAM, id.toString(), name, + imageUrl = "$CDN$id/header.jpg", + tallImageUrl = art[id]?.let { Uri.fromFile(it).toString() } ?: "$CDN$id/library_600x900.jpg", + isFree = game.optBoolean("free"), + storeUrl = "https://store.steampowered.com/app/$id/", + owned = true, + ) + } + return out.distinctBy { it.id }.sortedBy { it.title.lowercase() } + } + + internal fun shelves(context: Context): StoreShelves { + val art = runCatching { Library.steamLibraryArt(context) }.getOrDefault(emptyList()).map { Uri.fromFile(it.second).toString() } + return StoreShelves(art = art) + } + + /** Reaches the network; call off the main thread. */ + internal fun plan(context: Context, appId: Int, language: String = SteamClient.language(context)): Pair { + plans[appId]?.let { return it to JSONObject().put("ok", true) } + val answer = SteamEngine.plan(context, appId, language) + val plan = Plan.of(answer) + val error = answer.optString("error") + if (plan != null) plans[appId] = plan + else if (isSignInError(error)) signInFailed(context, error) + return plan to answer + } + + internal fun plannedBytes(context: Context, item: CatalogItem): Long = + item.id.toIntOrNull()?.let { plan(context, it).first?.installBytes } ?: 0L + + fun requestInstall(context: Context, item: CatalogItem) { + if (SteamClient.clientMayRun()) { + toast(context, R.string.steam_store_close_steam) + return + } + picking = item + } + + fun install(context: Context, item: CatalogItem, target: SteamClient.Target) { + val app = context.applicationContext + val appId = item.id.toIntOrNull() ?: return + if (SteamClient.clientMayRun()) { + toast(app, R.string.steam_store_close_steam) + return + } + val plan = plans[appId] + val needed = plan?.installBytes ?: 0L + val tagged = item.copy(extra = item.extra + mapOf(LIBRARY to target.library.guest, LIBRARY_LABEL to target.label)) + val entry = DownloadEntry( + Store.STEAM, item.id, item.title, cover = item.imageUrl, + bytesTotal = plan?.downloadBytes ?: 0L, location = target.label, + ) + SavedQueue.remember(app, tagged, target.library.host) + if (StoreInstallRoot.insufficientSpace(needed, target.freeBytes)) { + val error = app.getString(R.string.stores_storage_insufficient, formatBytes(needed), formatBytes(target.freeBytes)) + DownloadQueue.recordFailed(app, entry, error) { requestInstall(app, item) } + return + } + DownloadQueue.enqueue(app, entry) { SteamInstallJob(app, appId, target.library.guest) } + } + + internal fun restore(context: Context, item: CatalogItem) { + val app = context.applicationContext + val appId = item.id.toIntOrNull() ?: return + val guest = item.extra[LIBRARY] ?: return + SavedQueue.remember(app, item, null) + val entry = DownloadEntry(Store.STEAM, item.id, item.title, cover = item.imageUrl, location = item.extra[LIBRARY_LABEL].orEmpty()) + DownloadQueue.enqueue(app, entry) { SteamInstallJob(app, appId, guest) } + } + + fun uninstall(context: Context, appId: Int, onDone: () -> Unit = {}) { + val app = context.applicationContext + if (SteamClient.clientMayRun()) { + toast(app, R.string.steam_store_close_steam) + return + } + val key = key(appId) + if (key in StoresState.uninstalling) return + StoresState.uninstalling[key] = 0f + Thread({ + val answer = runCatching { + val game = SteamLibraryFolders.installed(SteamClient.libraries(app))[appId] + if (game == null) JSONObject().put("ok", true) + else { + val engine = SteamClient.engineLibraries(app) + SteamEngine.uninstall(appId, SteamClient.root(app).absolutePath, engine.hostOf(game.library).absolutePath, game.library.guest, engine.json) + } + }.getOrElse { SteamEngine.failure(it.javaClass.simpleName) } + val ok = answer.optBoolean("ok") + StoresState.logLine(if (ok) "Steam: uninstalled $appId" else "Steam: uninstall of $appId failed: ${answer.optString("error")}") + runCatching { scanInstalled(app) } + StoresState.post { + StoresState.uninstalling.remove(key) + if (ok) StoreSizes.onDisk.remove(key) + else Toast.makeText(app, errorText(app, answer), Toast.LENGTH_LONG).show() + onDone() + } + }, "steam-uninstall").start() + } + + /** Removes what a cancelled download left; a finished install stays. */ + internal fun discardPartial(context: Context, appId: Int, guest: String, host: File?, installDir: String?) { + File(context.filesDir, "$JOURNAL/$appId").deleteRecursively() + val library = host ?: runCatching { + SteamClient.engineLibraries(context).libraries.firstOrNull { it.first.guest == guest }?.second + }.getOrNull() ?: return + val apps = File(library, "steamapps") + val acf = File(apps, "appmanifest_$appId.acf") + val manifest = acf.takeIf { it.isFile }?.let { f -> runCatching { SteamStorage.parseManifest(f, f.readText()) }.getOrNull() } + if (manifest?.installed == true) return + val dir = (installDir ?: manifest?.installDir ?: plans[appId]?.installDir)?.takeIf { validDir(it) } + if (dir != null) StoreInstalls.deleteTree(File(apps, "common/$dir")) + StoreInstalls.deleteTree(File(apps, "downloading/$appId")) + if (manifest != null) acf.delete() + StoresState.logLine("Steam: removed the unfinished download of $appId") + } +} + +internal object SteamBackend : StoreBackend { + override val store: Store = Store.STEAM + + override fun signIn(context: Context) { + StoresState.logLine("Steam: sign in from the Steam client") + } + + override fun signOut(context: Context) = SteamEngine.forget() + + override fun syncLibrary(context: Context, force: Boolean) = SteamStore.syncLibrary(context, force) + + override fun loadShelves(context: Context, force: Boolean) { + val app = context.applicationContext + Thread({ + val shelves = SteamStore.shelves(app) + StoresState.post { StoresState.shelves[store] = shelves } + }, "steam-shelves").start() + } + + override fun search(context: Context, query: String): List = + StoresState.library[store].orEmpty().filter { it.title.contains(query, ignoreCase = true) } + + override fun install(context: Context, item: CatalogItem, root: File) = SteamStore.restore(context, item) + + override fun uninstall(context: Context, game: InstalledStoreGame) {} +} 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 f4900797a..2aca96d06 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -727,6 +727,7 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com com.droiddeck.launcher.stores.StoresState.pendingInstall?.let { item -> StoreTheme(item.store) { InstallWhere(item) } } com.droiddeck.launcher.stores.StoresState.itchPicking?.let { item -> StoreTheme(item.store) { ItchBuildPicker(item) { com.droiddeck.launcher.stores.StoresState.itchPicking = null } } } com.droiddeck.launcher.stores.StoresState.gameJoltPicking?.let { item -> StoreTheme(item.store) { GameJoltBuildPicker(item) { com.droiddeck.launcher.stores.StoresState.gameJoltPicking = null } } } + com.droiddeck.launcher.stores.steam.SteamStore.picking?.let { item -> StoreTheme(item.store) { SteamInstallWhereDialog(item) { com.droiddeck.launcher.stores.steam.SteamStore.picking = null } } } StepsLayer(screenAt) appToChooseDisplay?.let { app -> 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 390295f69..8cbb25375 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt @@ -103,6 +103,7 @@ import com.droiddeck.launcher.stores.StoreSizes import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.gamejolt.GameJoltApi import com.droiddeck.launcher.stores.battlenet.BattleNetInstall +import com.droiddeck.launcher.stores.steam.SteamStore import com.droiddeck.launcher.stores.download.DownloadQueue import com.droiddeck.launcher.stores.download.DownloadState import com.droiddeck.launcher.stores.formatBytes @@ -122,6 +123,7 @@ import androidx.compose.runtime.getValue internal class GameRef(val appId: Int?, val store: Store?, val storeId: String?) { fun game(games: List): Library.SteamGame? = when { appId != null -> games.firstOrNull { it.appId == appId } + store == Store.STEAM && storeId != null -> games.firstOrNull { Library.fromSteamClient(it) && it.appId.toString() == storeId } store != null && storeId != null -> games.firstOrNull { it.source == store.id && it.storeId == storeId } else -> null } @@ -225,7 +227,7 @@ internal fun GameDetail( Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { if (installed != null && installed.sidecar.store == Store.ITCH) ItchCheckButton(installed) if (installed != null && installed.sidecar.store == Store.GAMEJOLT) GameJoltCheckButton(installed) - RemoveButton(title, game, installed, a) + if (store == Store.STEAM) SteamRemoveButton(title, id?.toIntOrNull(), a) else RemoveButton(title, game, installed, a) } } } @@ -717,6 +719,43 @@ private fun RemoveButton(title: String, game: Library.SteamGame?, installed: Ins ) } +@Composable +private fun SteamRemoveButton(title: String, appId: Int?, a: FrontEndActions) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val game = appId?.let { SteamStore.installed[it] } ?: return + val key = SteamStore.key(game.appId) + if (StoresState.uninstalling[key] != null) { + val uninstalling = stringResource(R.string.stores_uninstalling) + Box(contentAlignment = Alignment.Center, modifier = Modifier.size(40.dp).glass(CircleShape).semantics { contentDescription = uninstalling }) { + CircularProgressIndicator(strokeWidth = 2.dp, color = colors.error, modifier = Modifier.size(20.dp)) + } + return + } + val heading = stringResource(R.string.stores_uninstall_title, title) + val body = if (game.sizeOnDisk > 0) stringResource(R.string.stores_uninstall_body_size, formatBytes(game.sizeOnDisk)) else stringResource(R.string.games_uninstall_body) + val keep = stringResource(R.string.stores_notification_keep) + val remove = stringResource(R.string.stores_uninstall) + val busy = StoresState.download(key)?.isActive == true + val placed = remember { arrayOfNulls(1) } + Box(Modifier.onGloballyPositioned { placed[0] = it }) { + IconAction(Icons.Outlined.Delete, remove, "game:remove", danger = true, enabled = !busy, frosted = true) { + val at = placed[0]?.takeIf { it.isAttached }?.boundsInRoot() ?: return@IconAction + var confirmed = false + Steps.ask(StepAsk(anchor = at, side = StepSide.Left, accent = colors.error, items = 3, pillCorner = 12.dp, maxWidth = 340.dp, + onDismiss = { if (confirmed) SteamStore.uninstall(ctx, game.appId) { StoresState.refresh(ctx); a.onLibraryChanged() } }, + handle = { Icon(Icons.Outlined.Delete, null, tint = colors.error, modifier = Modifier.size(18.dp)) }) { + StepTitle(heading) + Text(body, fontSize = 13.sp, lineHeight = 18.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp)) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End), modifier = Modifier.fillMaxWidth().stepItem(2)) { + StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() } + StepChoice(remove, danger = true, enabled = open) { confirmed = true; Steps.fold() } + } + }) + } + } +} + @Composable private fun InstallButton(label: String, modifier: Modifier = Modifier, onInstall: () -> Unit) { val placed = remember { arrayOfNulls(1) } 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 6550a2fd0..586cf292a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/LibraryPage.kt @@ -136,7 +136,7 @@ internal fun libraryEntries( out += LibraryEntry(GameRef.key(g), g.source, g.name, g, item, installed = g.library != Library.XBOX_CLOUD || storeKey in installedStore) } - for (store in Store.entries) for (item in owned[store].orEmpty()) { + for (store in Store.entries) if (store != Store.STEAM) for (item in owned[store].orEmpty()) { if (!claimed.add(item.key)) continue out += LibraryEntry(GameRef.key(item), store.id, item.title, null, item, installed = item.key in installedStore) } @@ -215,7 +215,7 @@ internal fun LibraryPage(s: FrontEndState, a: FrontEndActions, selected: String, LaunchedEffect(Unit) { StoresState.refresh(ctx) } remember { LibraryDisplay.load(ctx) } val stores = s.gameStoresEnabled && !s.shortcutPicker - val signedIn = Store.entries.filter { StoresState.isSignedIn(it) } + val signedIn = Store.entries.filter { it != Store.STEAM && 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() 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 1d2aef9d6..e20590238 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt @@ -33,14 +33,14 @@ internal fun sourceColours(source: String): SourceColours = when (source) { Store.ITCH.id -> SourceColours(Color(0xFF3A1A1E), Color(0xFFFFB3B3), Color(0xFFFF5C5C)) Store.GAMEJOLT.id -> SourceColours(Color(0xFF232E00), Color(0xFFE3FF66), Color(0xFFCCFF00)) Store.BATTLENET.id -> SourceColours(Color(0xFF0A2440), Color(0xFF9DD1FF), Color(0xFF148EFF)) - Library.SOURCE_STEAM -> SourceColours(Color(0xFF16293D), Color(0xFF7CC4FF), Color(0xFF1A9FFF)) + Library.SOURCE_STEAM, Store.STEAM.id -> SourceColours(Color(0xFF16293D), Color(0xFF7CC4FF), Color(0xFF1A9FFF)) FLATHUB -> SourceColours(Color(0xFF0B2E2B), Color(0xFF9FE3DD), FlathubTeal) else -> SourceColours(Color(0xFF1A1D22), Color(0xFF9AA3AF), Color(0xFF9AA3AF)) } @Composable internal fun sourceLabel(source: String): String = when (source) { - Library.SOURCE_STEAM -> stringResource(R.string.source_steam) + Library.SOURCE_STEAM, Store.STEAM.id -> stringResource(R.string.source_steam) Store.GOG.id -> Store.GOG.label Store.EPIC.id -> Store.EPIC.label Store.AMAZON.id -> Store.AMAZON.label diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt index c5dd008ed..ea7483e53 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt @@ -27,6 +27,7 @@ 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 @@ -46,7 +47,10 @@ import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.StoreInstallRoot import com.droiddeck.launcher.stores.StoreLanguage +import com.droiddeck.launcher.stores.StoreSizes import com.droiddeck.launcher.stores.StoresState +import com.droiddeck.launcher.stores.steam.SteamClient +import com.droiddeck.launcher.stores.steam.SteamStore import com.droiddeck.launcher.stores.formatBytes import com.droiddeck.launcher.stores.gog.GogDownloadManager import kotlinx.coroutines.Dispatchers @@ -133,6 +137,61 @@ internal fun InstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { } } +@Composable +internal fun SteamInstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { + val ctx = LocalContext.current + val colors = MaterialTheme.colorScheme + val shown = rememberShown(onDismiss) + val close = { shown.targetState = false } + val targets by produceState?>(null, item.key) { + value = withContext(Dispatchers.IO) { runCatching { SteamClient.targets(ctx) }.getOrDefault(emptyList()) } + } + val needed by produceState(StoreSizes.size(item), item.key) { + val bytes = withContext(Dispatchers.IO) { runCatching { SteamStore.plannedBytes(ctx, item) }.getOrDefault(0L) } + if (bytes > 0L) value = bytes + } + val list = targets + val focus = remember(list?.size) { List(list?.size ?: 0) { FocusRequester() } } + LaunchedEffect(focus) { if (focus.isNotEmpty()) focusWithinFrames({ false }) { focus[0] } } + AppDialog(shown, close, "steamInstallWhere", wide = false, maxWidth = 440.dp) { + Rise(0) { + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { + Text( + stringResource(R.string.stores_install_title, item.title), fontSize = 15.sp, color = colors.onBackground, + maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f), + ) + Text( + stringResource(R.string.common_cancel), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurfaceVariant, + modifier = Modifier.clip(Shape12).focusGlide().clickable(role = Role.Button, onClick = close).controllerConfirm(onClick = close).padding(horizontal = 10.dp, vertical = 6.dp), + ) + } + } + Rise(1) { + when { + list == null -> androidx.compose.material3.LinearProgressIndicator(Modifier.fillMaxWidth().height(3.dp)) + list.isEmpty() -> Note(stringResource(R.string.game_sync_err_steam_library)) + else -> Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth()) { + list.forEachIndexed { i, t -> + val isLow = StoreInstallRoot.insufficientSpace(needed, t.freeBytes) + val freeText = when { + t.freeBytes < 0L -> stringResource(R.string.stores_target_free_unknown) + isLow -> stringResource(R.string.stores_storage_low, formatBytes(t.freeBytes), formatBytes(needed)) + else -> stringResource(R.string.stores_target_free, formatBytes(t.freeBytes)) + } + TargetRow( + label = t.label, free = freeText, removable = t.removable, folder = t.folder, focus = focus[i], + modifier = Modifier.fillMaxWidth(), warning = isLow, + ) { + SteamStore.install(ctx, item, t) + close() + } + } + } + } + } + } +} + @Composable private fun TargetRow(label: String, free: String, removable: Boolean, folder: Boolean, focus: FocusRequester, modifier: Modifier, warning: Boolean = false, onPick: () -> Unit) { val colors = MaterialTheme.colorScheme diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt index c5f31f5d3..672786832 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt @@ -216,6 +216,12 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier delay(5_000) } } + if (chip == Store.STEAM.id) { + while (true) { + if (lifecycle.currentState.isAtLeast(androidx.lifecycle.Lifecycle.State.RESUMED)) com.droiddeck.launcher.stores.steam.SteamStore.poll(ctx) + delay(5_000) + } + } if (chip == Store.EPIC.id) { EpicClient.ensure(ctx) while (true) { @@ -382,7 +388,7 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier !k.accountsLoaded -> Box(Modifier.fillMaxWidth().padding(top = 16.dp)) { androidx.compose.material3.LinearProgressIndicator(Modifier.fillMaxWidth().height(3.dp)) } - !k.signedIn -> Box(Modifier.fillMaxWidth().verticalScroll(scroll).padding(top = 4.dp, bottom = 16.dp)) { SignInCard(st, viewportH - 20.dp) } + !k.signedIn -> Box(Modifier.fillMaxWidth().verticalScroll(scroll).padding(top = 4.dp, bottom = 16.dp)) { SignInCard(st, viewportH - 20.dp, onSignIn = if (st == Store.STEAM) a.onPlay else null) } else -> Storefront(st, query, s, a, grids.getOrPut(k) { LazyGridState() }, clearSearchFocus = openGame != null, onQuery = { query = it }, onOpen = { open(it) }) } } @@ -736,7 +742,7 @@ internal fun CountPill(count: Int) { @Composable -private fun SignInCard(store: Store, height: Dp) { +private fun SignInCard(store: Store, height: Dp, onSignIn: (() -> Unit)? = null) { val ctx = LocalContext.current val colors = MaterialTheme.colorScheme val pal = LocalPalette.current @@ -785,21 +791,23 @@ private fun SignInCard(store: Store, height: Dp) { ) } Spacer(Modifier.height(6.dp)) - Rise(3) { SignInButton(store, large = true) } + Rise(3) { SignInButton(store, large = true, onSignIn = onSignIn) } } } } @Composable -private fun SignInButton(store: Store, large: Boolean = false) { +private fun SignInButton(store: Store, large: Boolean = false, onSignIn: (() -> Unit)? = null) { val ctx = LocalContext.current val colors = MaterialTheme.colorScheme val placed = remember { arrayOfNulls(1) } var askKey by remember { mutableStateOf(false) } if (askKey) ItchKeyDialog { askKey = false } Box(Modifier.onGloballyPositioned { placed[0] = it }) { - PrimaryButton(stringResource(R.string.stores_signin), main = true, large = large, icon = if (large) Icons.AutoMirrored.Filled.Login else null) { - if (store == Store.ITCH) askKey = true + val label = if (onSignIn != null) stringResource(R.string.stores_login_title, store.label) else stringResource(R.string.stores_signin) + PrimaryButton(label, main = true, large = large, icon = if (large) Icons.AutoMirrored.Filled.Login else null) { + if (onSignIn != null) onSignIn() + else if (store == Store.ITCH) askKey = true else { val at = placed[0]?.takeIf { it.isAttached }?.boundsInRoot() if (at == null || Motion.scale == 0f || StoresMotion.signIn != null) StoresState.signIn(ctx, store) @@ -822,7 +830,11 @@ private fun Storefront( val library = StoresState.library[store] ?: emptyList() val shelves = StoresState.shelves[store] val found = StoresState.found[store] ?: emptyList() - val installedKeys = remember(StoresState.installed) { StoresState.installed.filter { it.sidecar.store == store }.map { it.sidecar.id }.toSet() } + val steamInstalled = if (store == Store.STEAM) com.droiddeck.launcher.stores.steam.SteamStore.installed else emptyMap() + val installedKeys = remember(StoresState.installed, steamInstalled) { + if (store == Store.STEAM) steamInstalled.keys.mapTo(HashSet()) { it.toString() } + else StoresState.installed.filter { it.sidecar.store == store }.map { it.sidecar.id }.toSet() + } val q = query.trim().lowercase() val foundKeys = remember(found) { found.map { it.key }.toSet() } fun shown(i: CatalogItem) = s.storesShowMature || !i.mature || i.accessible @@ -832,9 +844,11 @@ private fun Storefront( LaunchedEffect(gameJolt, s.storesShowMature) { if (gameJolt) GameJoltBrowseState.sync(ctx, s.storesShowMature) } val browsing = q.isEmpty() && ((store == Store.ITCH && ItchBrowseState.active) || gameJolt) val browseItems = if (!browsing) emptyList() else if (gameJolt) GameJoltBrowseState.items else ItchBrowseState.items - val catalog = store == Store.BATTLENET && q.isEmpty() + val steam = store == Store.STEAM + val catalog = (store == Store.BATTLENET || steam) && q.isEmpty() val visible = remember(found, library, shelves, q, s.storesShowMature, browsing, browseItems, catalog) { - if (catalog) shelf(shelves?.trending) ?: emptyList() + if (catalog && steam) library.filter(::shown) + else if (catalog) shelf(shelves?.trending) ?: emptyList() else if (browsing) { val owned = library.associateBy { it.id } browseItems.map { owned[it.id] ?: it }.filter(::shown) @@ -847,7 +861,8 @@ private fun Storefront( browsing && gameJolt && GameJoltBrowseState.failed -> R.string.stores_gamejolt_browse_failed browsing && !gameJolt && ItchBrowseState.loading -> R.string.stores_shelves_loading browsing && !gameJolt && ItchBrowseState.failed -> R.string.stores_itch_browse_failed - catalog && shelves == null -> R.string.stores_shelves_loading + catalog && steam && !StoresState.library.containsKey(store) -> R.string.stores_shelves_loading + catalog && !steam && shelves == null -> R.string.stores_shelves_loading else -> R.string.stores_nothing_matches }) var firstPlaced = false @@ -863,7 +878,7 @@ private fun Storefront( val barLine = StoresState.status[store]?.takeIf { bareTab && syncCount(it) != null } val itchBar = store == Store.ITCH && q.isEmpty() val gameJoltBar = gameJolt && q.isEmpty() - val headerItems = 2 + (if (barLine != null) 1 else 0) + (if (StoresState.problems[store] != null) 1 else 0) + (if (itchBar || gameJoltBar) 1 else 0) + (if (catalog) 1 else 0) + val headerItems = 2 + (if (barLine != null) 1 else 0) + (if (StoresState.problems[store] != null) 1 else 0) + (if (itchBar || gameJoltBar) 1 else 0) + (if (catalog && !steam) 1 else 0) val card: @Composable (CatalogItem) -> Unit = { item -> val first = if (searching) item.key == visible.firstOrNull()?.key else !firstPlaced firstPlaced = true @@ -913,7 +928,7 @@ private fun Storefront( StoresState.problems[store]?.let { line -> item(key = "problem", span = { GridItemSpan(maxLineSpan) }) { Rise(3) { Box(Modifier.padding(bottom = 8.dp)) { Note(line) } } } } if (itchBar) item(key = "itch-browse-bar", span = { GridItemSpan(maxLineSpan) }) { ItchBrowseBar() } if (gameJoltBar) item(key = "gamejolt-browse-bar", span = { GridItemSpan(maxLineSpan) }) { GameJoltBrowseBar(s.storesShowMature) } - if (catalog) item(key = "catalog-label", span = { GridItemSpan(maxLineSpan) }) { + if (catalog && !steam) item(key = "catalog-label", span = { GridItemSpan(maxLineSpan) }) { Box(Modifier.padding(top = 10.dp)) { SectionLabel(stringResource(R.string.bnet_store)) } } if (searching) { @@ -959,7 +974,7 @@ private fun ProfileStrip(store: Store, owned: Int, loaded: Boolean, s: FrontEndS ) } Actions { - SmallTextButton(stringResource(R.string.stores_owned_in_library), key = "owned-in-library") { + if (store != Store.STEAM) SmallTextButton(stringResource(R.string.stores_owned_in_library), key = "owned-in-library") { LibraryView.showOwned(ctx, store) show("games") } @@ -967,7 +982,7 @@ private fun ProfileStrip(store: Store, owned: Int, loaded: Boolean, s: FrontEndS if (store == Store.XBOX) SmallTextButton(stringResource(R.string.stores_xbox_cloud_settings), key = "xbox-cloud-settings") { ctx.startActivity(android.content.Intent(ctx, com.droiddeck.launcher.stores.xbox.XboxCloudSettingsActivity::class.java)) } - SignOutButton(store, name) + if (store != Store.STEAM) SignOutButton(store, name) } } if (store == Store.EPIC) EpicLauncherRow(s, a) @@ -1157,6 +1172,7 @@ internal fun storePalette(base: Palette, store: Store?): Palette { Store.ITCH -> Color(0xFFFF5C5C) to Color(0xFFD93B3B) Store.GAMEJOLT -> Color(0xFFCCFF00) to Color(0xFFA3CC00) Store.BATTLENET -> Color(0xFF148EFF) to Color(0xFF0B6BD3) + Store.STEAM -> Color(0xFF1A9FFF) to Color(0xFF0F6FC0) null -> return base } val on = if (accent.luminance() > 0.18f) Color(0xFF0B0B0D) else Color.White diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index e547dae0c..c99407d0d 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -3850,4 +3850,6 @@ جارٍ الاستماع… الكتابة بالصوت غير متاحة على هذا الجهاز. يلزم الوصول إلى الميكروفون للكتابة بالصوت. + أغلق Steam أولاً + أوقف تنزيل Steam مؤقتًا أولاً 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 810abb261..d8b4986ec 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -3706,4 +3706,6 @@ Escuchando… El dictado por voz no está disponible en este dispositivo. Se necesita acceso al micrófono para el dictado por voz. + Cierra Steam primero + Pausa primero la descarga de Steam diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index 09fe1c160..121575945 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -3694,4 +3694,6 @@ Слушане… Гласовото въвеждане не е налично на това устройство. За гласово въвеждане е нужен достъп до микрофона. + Първо затворете Steam + Първо поставете на пауза изтеглянето от Steam diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 3474768ff..2f2bcd395 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -3772,4 +3772,6 @@ Poslouchám… Hlasové psaní není na tomto zařízení k dispozici. Pro hlasové psaní je potřeba přístup k mikrofonu. + Nejprve zavřete Steam + Nejprve pozastavte stahování ze Steamu diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 489005d1e..c5e27cc08 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -3694,4 +3694,6 @@ Lytter… Stemmeindtastning er ikke tilgængelig på denne enhed. Mikrofonadgang er nødvendig for stemmeindtastning. + Luk Steam først + Sæt Steam-downloaden på pause først diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 68e733f1b..22206cb2f 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -3694,4 +3694,6 @@ Hört zu… Spracheingabe ist auf diesem Gerät nicht verfügbar. Für die Spracheingabe wird Mikrofonzugriff benötigt. + Schließe zuerst Steam + Pausiere zuerst den Steam-Download diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 0040421cd..17eb48b20 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -3694,4 +3694,6 @@ Ακρόαση… Η φωνητική πληκτρολόγηση δεν είναι διαθέσιμη σε αυτή τη συσκευή. Απαιτείται πρόσβαση στο μικρόφωνο για φωνητική πληκτρολόγηση. + Κλείστε πρώτα το Steam + Θέστε πρώτα σε παύση τη λήψη του Steam diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index c4e974879..a027e64db 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -3733,4 +3733,6 @@ Escuchando… El dictado por voz no está disponible en este dispositivo. Se necesita acceso al micrófono para el dictado por voz. + Cierra Steam primero + Pausa primero la descarga de Steam diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index f18ba8b90..1a034b56f 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -3694,4 +3694,6 @@ Kuunnellaan… Puhekirjoitus ei ole käytettävissä tällä laitteella. Puhekirjoitus vaatii mikrofonin käyttöoikeuden. + Sulje Steam ensin + Keskeytä Steam-lataus ensin diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index e8b4dcb51..9863bad4c 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -3733,4 +3733,6 @@ Écoute… La saisie vocale n\'est pas disponible sur cet appareil. L\'accès au micro est nécessaire pour la saisie vocale. + Fermez d\'abord Steam + Mettez d\'abord en pause le téléchargement Steam diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 1098f96d2..0d386e51e 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -3694,4 +3694,6 @@ सुन रहा है… इस डिवाइस पर आवाज़ से टाइपिंग उपलब्ध नहीं है। आवाज़ से टाइपिंग के लिए माइक्रोफ़ोन की अनुमति चाहिए। + पहले Steam बंद करें + पहले Steam डाउनलोड रोकें diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index e2e5b6b40..ba467df3d 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -3694,4 +3694,6 @@ Figyelés… A hangalapú gépelés nem érhető el ezen az eszközön. A hangalapú gépeléshez mikrofon-hozzáférés szükséges. + Előbb zárd be a Steamet + Előbb szüneteltesd a Steam-letöltést diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 6279d3c6a..d6a42a186 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -3664,4 +3664,6 @@ Mendengarkan… Ketik dengan suara tidak tersedia di perangkat ini. Akses mikrofon diperlukan untuk mengetik dengan suara. + Tutup Steam terlebih dahulu + Jeda unduhan Steam terlebih dahulu diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 0f0de6a0a..36700af30 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -3733,4 +3733,6 @@ In ascolto… La digitazione vocale non è disponibile su questo dispositivo. Per la digitazione vocale serve l\'accesso al microfono. + Chiudi prima Steam + Metti prima in pausa il download di Steam diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 9d8c67575..bb66054ce 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -3664,4 +3664,6 @@ 聞き取り中… このデバイスでは音声入力を使用できません。 音声入力にはマイクへのアクセスが必要です。 + 先に Steam を閉じてください + 先に Steam のダウンロードを一時停止してください diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index baf68c37b..897f3b0c3 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -3664,4 +3664,6 @@ 듣는 중… 이 기기에서는 음성 입력을 사용할 수 없습니다. 음성 입력을 하려면 마이크 접근 권한이 필요합니다. + 먼저 Steam을 닫으세요 + 먼저 Steam 다운로드를 일시 중지하세요 diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index fef1314c8..b5a06dc03 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -3664,4 +3664,6 @@ Mendengar… Taip dengan suara tidak tersedia pada peranti ini. Akses mikrofon diperlukan untuk menaip dengan suara. + Tutup Steam dahulu + Jeda muat turun Steam dahulu diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index 14f1ce3c8..91cd01097 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -3694,4 +3694,6 @@ Lytter… Taleinntasting er ikke tilgjengelig på denne enheten. Mikrofontilgang trengs for taleinntasting. + Lukk Steam først + Sett Steam-nedlastingen på pause først diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 279a434e7..37cf4fbb0 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -3694,4 +3694,6 @@ Luisteren… Spraakinvoer is niet beschikbaar op dit apparaat. Voor spraakinvoer is toegang tot de microfoon nodig. + Sluit eerst Steam + Pauzeer eerst de Steam-download diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index f7e6920f6..35160ba74 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -3772,4 +3772,6 @@ Słucham… Pisanie głosowe nie jest dostępne na tym urządzeniu. Pisanie głosowe wymaga dostępu do mikrofonu. + Najpierw zamknij Steam + Najpierw wstrzymaj pobieranie ze Steam diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index b3e112cd1..1bea75bc8 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -3733,4 +3733,6 @@ A ouvir… A escrita por voz não está disponível neste dispositivo. É necessário acesso ao microfone para a escrita por voz. + Feche primeiro o Steam + Coloque primeiro em pausa a transferência do Steam diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 26660803f..b80d3b0e8 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -3733,4 +3733,6 @@ Ouvindo… A digitação por voz não está disponível neste dispositivo. É preciso acesso ao microfone para a digitação por voz. + Feche o Steam primeiro + Pause o download do Steam primeiro diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index c19ea386d..0ab83ab05 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -3733,4 +3733,6 @@ Se ascultă… Tastarea vocală nu este disponibilă pe acest dispozitiv. Pentru tastarea vocală este necesar accesul la microfon. + Închide mai întâi Steam + Pune mai întâi pe pauză descărcarea Steam diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index c3192a88d..cab751355 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -3855,4 +3855,6 @@ Слушаю… Голосовой ввод недоступен на этом устройстве. Для голосового ввода нужен доступ к микрофону. + Сначала закройте Steam + Сначала приостановите загрузку Steam diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 85564ecfb..467763a9a 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -3694,4 +3694,6 @@ Lyssnar… Röstinmatning är inte tillgänglig på den här enheten. Mikrofonåtkomst krävs för röstinmatning. + Stäng Steam först + Pausa Steam-nedladdningen först diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index 86ba4d427..a17778e9d 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -3664,4 +3664,6 @@ กำลังฟัง… อุปกรณ์นี้ไม่รองรับการพิมพ์ด้วยเสียง ต้องอนุญาตให้เข้าถึงไมโครโฟนเพื่อพิมพ์ด้วยเสียง + ปิด Steam ก่อน + หยุดการดาวน์โหลด Steam ชั่วคราวก่อน diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 80d9523b7..5ae5b6c70 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -3694,4 +3694,6 @@ Dinleniyor… Sesle yazma bu cihazda kullanılamıyor. Sesle yazma için mikrofon erişimi gerekiyor. + Önce Steam\'i kapatın + Önce Steam indirmesini duraklatın diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 19812c988..5743c7986 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -3772,4 +3772,6 @@ Слухаю… Голосове введення недоступне на цьому пристрої. Для голосового введення потрібен доступ до мікрофона. + Спочатку закрийте Steam + Спочатку призупиніть завантаження Steam diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index 6450ad295..933a5d215 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -3664,4 +3664,6 @@ Đang nghe… Thiết bị này không hỗ trợ nhập bằng giọng nói. Cần quyền truy cập micrô để nhập bằng giọng nói. + Hãy đóng Steam trước + Hãy tạm dừng tải xuống Steam trước diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 3c0bff104..7e22d607e 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -3668,4 +3668,6 @@ 正在聆听… 此设备不支持语音输入。 语音输入需要麦克风权限。 + 请先关闭 Steam + 请先暂停 Steam 下载 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index 04ca81b85..5800e4d87 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -3667,4 +3667,6 @@ 正在聆聽… 此裝置不支援語音輸入。 語音輸入需要咪高峰權限。 + 請先關閉 Steam + 請先暫停 Steam 下載 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 67fbf05d1..303f25f51 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -3667,4 +3667,6 @@ 正在聆聽… 此裝置不支援語音輸入。 語音輸入需要麥克風權限。 + 請先關閉 Steam + 請先暫停 Steam 下載 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 32382c40d..ba92f807e 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -3852,4 +3852,6 @@ Listening… Voice typing is not available on this device. Microphone access is needed for voice typing. + Close Steam first + Pause the Steam download first diff --git a/app/src/test/java/com/droiddeck/launcher/stores/steam/SteamLibraryFoldersTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/steam/SteamLibraryFoldersTest.kt new file mode 100644 index 000000000..3e1b724e1 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/steam/SteamLibraryFoldersTest.kt @@ -0,0 +1,274 @@ +package com.droiddeck.launcher.stores.steam + +import com.droiddeck.launcher.stores.download.DownloadStage +import java.io.File +import java.nio.file.Files +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class SteamLibraryFoldersTest { + private val rootfs = File("/data/user/0/com.droiddeck.launcher/files/rootfs") + private val card = File("/storage/1A2B-3C4D/Android/data/com.droiddeck.launcher/files/steam") + private val lib = File("/storage/1A2B-3C4D/SteamLibrary") + private val games = File("/storage/1A2B-3C4D/Games") + private val armRoot = File(rootfs, "root/.local/share/Steam") + private val x64Root = File(rootfs, "root/.droiddeck-x64/.local/share/Steam") + private val armAliases = listOf("/root/.local/share/Steam", "/root/.steam/steam", "/root/.steam/root") + private val mounts = listOf( + SteamLibraryFolders.Mount("/mnt/droiddeck-sd", card), + SteamLibraryFolders.Mount("/mnt/droiddeck-lib/1", lib), + SteamLibraryFolders.Mount("/root/Games/Card/", games), + SteamLibraryFolders.Mount("/root/Storage", File("/storage/emulated/0")), + ) + + private val vdf = """ + "libraryfolders" + { + "contentstatsid" "-4785" + "0" + { + "path" "/root/.local/share/Steam" + "label" "Internal Storage" + "contentid" "123" + "totalsize" "0" + "apps" + { + "228980" "0" + } + } + "1" + { + "path" "/mnt/droiddeck-sd" + "label" "SD card" + "apps" + { + "291550" "1500000000" + } + } + "2" + { + "path" "/mnt/droiddeck-lib/1" + "label" "Steam \"Lib\"" + } + "3" + { + "path" "/root/Games/Card" + "label" "" + } + "4" + { + "path" "/root/.droiddeck-x64/shared/x86-64" + "label" "x86-64 client games" + } + "5" + { + "path" "/mnt/droiddeck-lib/9" + "label" "Removed" + } + "6" + { + "path" "/root/Games/Gone" + "label" "Gone" + } + } + """.trimIndent() + + @Test fun readsEveryFolderWithItsLabel() { + val folders = SteamLibraryFolders.parse(vdf) + assertEquals( + listOf("/root/.local/share/Steam", "/mnt/droiddeck-sd", "/mnt/droiddeck-lib/1", "/root/Games/Card", + "/root/.droiddeck-x64/shared/x86-64", "/mnt/droiddeck-lib/9", "/root/Games/Gone"), + folders.map { it.path }, + ) + assertEquals("Internal Storage", folders[0].label) + assertEquals("Steam \"Lib\"", folders[2].label) + assertEquals("", folders[3].label) + } + + @Test fun readsTheOldFormatAndEscapedPaths() { + val old = """ + "LibraryFolders" + { + "TimeNextStatsReport" "1700000000" + "ContentStatsID" "-1" + "1" "/mnt/droiddeck-sd" + "2" "/root/odd\\name" + } + """.trimIndent() + assertEquals( + listOf(SteamLibraryFolders.Folder("/mnt/droiddeck-sd", ""), SteamLibraryFolders.Folder("/root/odd\\name", "")), + SteamLibraryFolders.parse(old), + ) + assertTrue(SteamLibraryFolders.parse("").isEmpty()) + } + + @Test fun arm64LibrariesMapFromGuestToHost() { + val libraries = SteamLibraryFolders.resolve( + SteamLibraryFolders.parse(vdf), "/root/.local/share/Steam", armAliases, armRoot, mounts, rootfs, + ) + assertEquals( + listOf(armRoot, card, lib, games, File(rootfs, "root/.droiddeck-x64/shared/x86-64")), + libraries.map { it.host }, + ) + assertEquals(listOf(true, false, false, false, false), libraries.map { it.main }) + assertEquals("/mnt/droiddeck-sd", libraries[1].guest) + assertEquals("SD card", libraries[1].label) + } + + @Test fun x64LibrariesSitInsideTheCardAndAddedLibraries() { + val text = """ + "libraryfolders" + { + "0" { "path" "/root/.droiddeck-x64/.local/share/Steam" "label" "Internal Storage" } + "1" { "path" "/mnt/droiddeck-sd/x86-64" "label" "SD card" } + "2" { "path" "/mnt/droiddeck-lib/1/x86-64/" "label" "Lib" } + "3" { "path" "/root/.droiddeck-x64/shared/arm64" "label" "ARM64 client games" } + } + """.trimIndent() + val libraries = SteamLibraryFolders.resolve( + SteamLibraryFolders.parse(text), "/root/.droiddeck-x64/.local/share/Steam", + listOf("/root/.droiddeck-x64/.local/share/Steam", "/root/.droiddeck-x64/.steam/steam"), x64Root, mounts, rootfs, + ) + assertEquals( + listOf(x64Root, File(card, "x86-64"), File(lib, "x86-64"), File(rootfs, "root/.droiddeck-x64/shared/arm64")), + libraries.map { it.host }, + ) + assertEquals("/mnt/droiddeck-lib/1/x86-64", libraries[2].guest) + } + + @Test fun aGuestPathWithoutItsBindIsNotAnInstallTarget() { + assertNull(SteamLibraryFolders.hostFor("/mnt/droiddeck-sd", emptyList(), rootfs)) + assertNull(SteamLibraryFolders.hostFor("/root/Games/Gone", mounts, rootfs)) + assertNull(SteamLibraryFolders.hostFor("/root/Storage/Steam", emptyList(), rootfs)) + assertNull(SteamLibraryFolders.hostFor("/opt/steam", mounts, rootfs)) + assertNull(SteamLibraryFolders.hostFor("/root/../etc", mounts, rootfs)) + assertNull(SteamLibraryFolders.hostFor("relative/path", mounts, rootfs)) + assertEquals(File("/storage/emulated/0/Steam"), SteamLibraryFolders.hostFor("/root/Storage/Steam", mounts, rootfs)) + assertEquals(File(card, "x86-64"), SteamLibraryFolders.hostFor("/mnt/droiddeck-sd//x86-64/", mounts, rootfs)) + } + + @Test fun aliasesAreTheMainLibraryAndAMissingMainIsAddedFirst() { + val aliased = SteamLibraryFolders.resolve( + listOf(SteamLibraryFolders.Folder("/root/.steam/steam", "Internal Storage"), SteamLibraryFolders.Folder("/mnt/droiddeck-sd", "SD card")), + "/root/.local/share/Steam", armAliases, armRoot, mounts, rootfs, + ) + assertEquals(listOf(armRoot, card), aliased.map { it.host }) + assertEquals("/root/.steam/steam", aliased[0].guest) + + val missing = SteamLibraryFolders.resolve( + listOf(SteamLibraryFolders.Folder("/mnt/droiddeck-sd", "SD card"), SteamLibraryFolders.Folder("/mnt/droiddeck-sd/", "Again")), + "/root/.local/share/Steam", armAliases, armRoot, mounts, rootfs, + ) + assertEquals(listOf(armRoot, card), missing.map { it.host }) + assertEquals("/root/.local/share/Steam", missing[0].guest) + assertEquals("", missing[0].label) + } + + private fun acf(library: File, appId: Int, name: String, flags: Int, dir: String = name, size: Long = 0L) { + val apps = File(library, "steamapps").apply { mkdirs() } + File(apps, "appmanifest_$appId.acf").writeText( + """ + "AppState" + { + "appid" "$appId" + "name" "$name" + "StateFlags" "$flags" + "installdir" "$dir" + "SizeOnDisk" "$size" + } + """.trimIndent(), + ) + } + + @Test fun onlyFullyInstalledGamesCountAsInstalled() { + val base = Files.createTempDirectory("steam-libs").toFile() + try { + val first = SteamLibraryFolders.Library("/root/.local/share/Steam", File(base, "internal"), "Internal Storage", true) + val second = SteamLibraryFolders.Library("/mnt/droiddeck-sd", File(base, "card"), "SD card", false) + val missing = SteamLibraryFolders.Library("/mnt/droiddeck-lib/1", File(base, "gone"), "Gone", false) + acf(first.host, 291550, "Brawlhalla", 4, size = 1_500_000_000L) + acf(first.host, 620, "Portal 2", 1026) + acf(first.host, 1628350, "Steam Linux Runtime 3.0 (sniper)", 4, dir = "SteamLinuxRuntime_sniper") + acf(second.host, 291550, "Brawlhalla copy", 4) + acf(second.host, 413150, "Stardew Valley", 6) + File(second.host, "steamapps/appmanifest_400.acf.tmp").writeText("\"AppState\" { \"appid\" \"400\" \"StateFlags\" \"4\" }") + File(second.host, "steamapps/libraryfolder.vdf").writeText("\"libraryfolder\" { }") + + val found = SteamLibraryFolders.installed(listOf(first, second, missing)) + assertEquals(setOf(291550, 413150), found.keys) + assertEquals("Brawlhalla", found.getValue(291550).name) + assertEquals(first, found.getValue(291550).library) + assertEquals(1_500_000_000L, found.getValue(291550).sizeOnDisk) + assertEquals(second, found.getValue(413150).library) + assertEquals("Stardew Valley", found.getValue(413150).installDir) + } finally { + base.deleteRecursively() + } + } + + @Test fun theClientsRememberedAccountIsTheSavedSignIn() { + val users = """ + "users" + { + "76561190000000001" + { + "AccountName" "old" + "PersonaName" "Old One" + "RememberPassword" "1" + "MostRecent" "0" + "Timestamp" "1600000000" + } + "76561190000000002" + { + "AccountName" "player" + "PersonaName" "Player" + "RememberPassword" "1" + "MostRecent" "1" + "Timestamp" "1700000000" + } + } + """.trimIndent() + assertEquals("Player", SteamLibraryFolders.savedAccount(users)) + assertEquals("Old One", SteamLibraryFolders.savedAccount(users.replace("\"MostRecent\"\t\t\"1\"", "\"MostRecent\"\t\t\"0\"").replace("\"1700000000\"", "\"1500000000\""))) + assertEquals("player", SteamLibraryFolders.savedAccount(users.replace("\"PersonaName\"\t\t\"Player\"", "\"PersonaName\"\t\t\"\"").replace("\"Old One\"", "\"\"").replace("\"1600000000\"", "\"1\""))) + assertNull(SteamLibraryFolders.savedAccount(users.replace("\"RememberPassword\"\t\t\"1\"", "\"RememberPassword\"\t\t\"0\""))) + assertNull(SteamLibraryFolders.savedAccount("")) + } + + @Test fun theClientLanguageComesFromTheRegistry() { + val registry = """ + "Registry" + { + "HKCU" + { + "Software" + { + "Valve" + { + "Steam" + { + "AutoLoginUser" "player" + "language" "german" + } + } + } + } + } + """.trimIndent() + assertEquals("german", SteamLibraryFolders.language(registry)) + assertNull(SteamLibraryFolders.language("\"Registry\" { \"HKCU\" { } }")) + } + + @Test fun enginePhasesShowAsDownloadStages() { + assertEquals(DownloadStage.DOWNLOAD, SteamLibraryFolders.stageOf("download")) + assertEquals(DownloadStage.DOWNLOAD, SteamLibraryFolders.stageOf("Downloading")) + assertEquals(DownloadStage.DOWNLOAD, SteamLibraryFolders.stageOf("")) + assertEquals(DownloadStage.VERIFY, SteamLibraryFolders.stageOf("verify")) + assertEquals(DownloadStage.MANIFEST, SteamLibraryFolders.stageOf("manifests")) + assertEquals(DownloadStage.MANIFEST, SteamLibraryFolders.stageOf("cleanup")) + assertEquals(DownloadStage.INSTALL, SteamLibraryFolders.stageOf("register")) + assertEquals(DownloadStage.INSTALL, SteamLibraryFolders.stageOf("finalize")) + } +}