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")) + } +}