From 935b70c585bad1fa489c56e660ab08ab9e31e3e4 Mon Sep 17 00:00:00 2001 From: The412Banner Date: Fri, 9 Oct 2026 05:25:59 -0400 Subject: [PATCH] Stores: the EOS overlay is removed; sign-in goes through the browser Device-proven on bf81104: Metalstorm's EOS corrective action fell back to a browser, the hand-off opened it in Android's browser, the user approved, and the game signed in. With the overlay pointer set the game exited while loading on every launch, so the overlay goes: no switch on the Epic card, no download, no OverlayPath. A launch removes a pointer an earlier build wrote, and the app deletes an earlier 656 MB download once; an overlay field in an older sidecar is read past. The work is parked on park/epic-eos-overlay. The browser hand-off, the Epic card's sign-in, offline and Resolve actions, and BL_DEBUG_BROWSER stay. --- .../launcher/stores/StoreGameSidecar.kt | 19 +---- .../launcher/stores/StoreLaunchRequests.kt | 8 +- .../droiddeck/launcher/stores/StoresState.kt | 3 + .../launcher/stores/epic/EpicOverlay.kt | 84 ------------------- .../droiddeck/launcher/ui/FrontEndSetup.kt | 7 +- app/src/main/res/values/strings.xml | 2 - .../launcher/stores/StoreGameSidecarTest.kt | 23 +++-- docs/development/stores.md | 30 ++++++- docs/progress-log.md | 8 ++ .../usr/local/bin/droiddeck-store-launch | 51 +++-------- tools/tests/test_store_launch.py | 40 +++++---- 11 files changed, 85 insertions(+), 190 deletions(-) delete mode 100644 app/src/main/java/com/droiddeck/launcher/stores/epic/EpicOverlay.kt diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreGameSidecar.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreGameSidecar.kt index 509004ba7e..06e901fd73 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreGameSidecar.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreGameSidecar.kt @@ -60,7 +60,7 @@ class StoreGameSidecar( put("title", title) if (exe.isNotEmpty()) put("exe", exe) if (state != STATE_INSTALLED) put("state", state) - if (store == Store.EPIC) put("epic", JSONObject().put("v", EpicOptions.VERSION).put("eos", epic.eos).put("offline", epic.offline).put("overlay", epic.overlay)) + if (store == Store.EPIC) put("epic", JSONObject().put("eos", epic.eos).put("offline", epic.offline)) if (!launcher.isNullOrEmpty()) put("launcher", launcher) if (args.isNotEmpty()) put("args", JSONArray(args)) if (env.isNotEmpty()) put("env", JSONObject(env as Map<*, *>)) @@ -133,12 +133,8 @@ class StoreGameSidecar( hero = o.optString("hero", "").ifEmpty { null }, extra = extra, state = state, - epic = o.optJSONObject("epic")?.let { e -> - // Before v2 the overlay was on by default and written so without anyone choosing - // it; the overlay crashed games, so those read as off. From v2 it is a choice. - val chosen = e.optInt("v", 1) >= EpicOptions.VERSION - EpicOptions(eos = e.optBoolean("eos", true), offline = e.optBoolean("offline", false), overlay = chosen && e.optBoolean("overlay", false)) - } ?: EpicOptions(), + // An "overlay" (or "v") field from an earlier build is read past: there is no overlay. + epic = o.optJSONObject("epic")?.let { e -> EpicOptions(eos = e.optBoolean("eos", true), offline = e.optBoolean("offline", false)) } ?: EpicOptions(), ) } @@ -151,15 +147,8 @@ class StoreGameSidecar( /** * An Epic game's launch choices. [eos]: pass a fresh exchange code (Epic sign-in). [offline]: start * with the Epic identity arguments only, no code - for a game that will not start when sign-in fails. - * [overlay]: point the game's prefix at Epic's EOS overlay - off by default: with it on, a game can - * exit while loading on this stack (Metalstorm did, twice; off, it signs in and runs). */ -data class EpicOptions(val eos: Boolean = true, val offline: Boolean = false, val overlay: Boolean = false) { +data class EpicOptions(val eos: Boolean = true, val offline: Boolean = false) { /** Whether a launch asks for a code at all. */ val wantsCode: Boolean get() = eos && !offline - - companion object { - /** v2: the overlay is off unless chosen (Metalstorm exits while loading with it on). */ - const val VERSION = 2 - } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt index d3244e335d..f29e105298 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt @@ -60,13 +60,7 @@ object StoreLaunchRequests { if (id.isEmpty()) JSONObject().put("ok", false).put("reason", "no-id") else { val code = StoreLaunch.epicCode(app, id) - // The overlay is placed once and shared; the launch writes the prefix's pointer. - val overlay = com.droiddeck.launcher.stores.epic.EpicOverlay.installedVersion(app) - val wanted = StoreInstallRoot.gameFolders(app).firstNotNullOfOrNull { f -> StoreGameSidecar.read(f)?.takeIf { it.store == Store.EPIC && it.id == id } }?.epic?.overlay == true - Log.i(TAG, "epic overlay installed=${overlay ?: "no"} wanted=$wanted prefix=${request.optString("prefix").ifEmpty { "?" }}") - // Fetched only for a game that has the overlay on (656 MB; off by default). - if (overlay == null && wanted) com.droiddeck.launcher.stores.epic.EpicOverlay.ensureAsync(app) - JSONObject().put("ok", true).put("code", code.written).put("reason", code.reason).put("overlay", overlay ?: "") + JSONObject().put("ok", true).put("code", code.written).put("reason", code.reason) } } // A browser a game opens inside the session (an EOS device sign-in, a store page): 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 4d15d2f149..0b6ed682b7 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt @@ -226,6 +226,9 @@ object StoresState { fun init(context: Context) { appContext = context.applicationContext StoreLogFiles.prune(context) + // The EOS overlay an earlier build downloaded (656 MB) is gone with the feature. + val overlay = java.io.File(com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(context), "root/.local/share/droiddeck/epic-overlay") + if (overlay.exists()) Thread({ overlay.deleteRecursively(); Log.i(TAG, "removed the old EOS overlay download") }, "epic-overlay-cleanup").start() } internal fun post(block: () -> Unit) = main.post(block) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicOverlay.kt b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicOverlay.kt deleted file mode 100644 index 986185f77a..0000000000 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicOverlay.kt +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Epic Online Services (EOS) overlay provisioning for DroidDeck. - * - * Credits: the provisioning MECHANISM - download Epic's own overlay component - * ("EpicOnlineServicesOverlay") and point a game's bundled EOS SDK at it through a single HKCU - * registry value - comes from Legendary's legendary/lfs/eos.py, by way of The GameNative Team's - * work (https://github.com/utkarshdalal/GameNative) and Bannerlator's EpicOverlayManager. The Epic - * app identifiers, the registry key and the EOSOVH-Win64-Shipping.dll name are public facts from - * Epic / Legendary. Original implementation. - * - * Reference: https://github.com/derrod/legendary - legendary/lfs/eos.py - * Reference: https://github.com/utkarshdalal/GameNative - * - * Provision only: Epic's signed component is placed once, shared by every prefix, and each Epic - * game's prefix gets the one pointer (written by droiddeck-store-launch before Proton starts, where - * the prefix is known). The game's EOS SDK loads it itself - which is what lets a "corrective - * action" (a consent Epic wants once per product) show in game instead of waiting on a browser. - */ -package com.droiddeck.launcher.stores.epic - -import android.content.Context -import android.util.Log -import com.droiddeck.launcher.runtime.LinuxRuntime -import com.droiddeck.launcher.stores.StoresState -import java.io.File -import java.util.concurrent.atomic.AtomicBoolean - -object EpicOverlay { - private const val TAG = "EpicOverlay" - - // Epic's "EpicOnlineServicesOverlay" app (public, from Legendary). - private const val OVERLAY_APP = "98bc04bc842e4906993fd6d6644ffb8d" - private const val OVERLAY_NAMESPACE = "302e5ede476149b1bc3e4fe6ae45e50e" - private const val OVERLAY_CATALOG_ITEM = "cc15684f44d849e89e9bf4cec0508b68" - const val OVERLAY_DLL = "EOSOVH-Win64-Shipping.dll" - - /** Inside the session: `/root/.local/share/droiddeck/epic-overlay`, which every prefix reaches as Z:. droiddeck-store-launch names the same path. */ - const val GUEST_DIR = "/root/.local/share/droiddeck/epic-overlay" - private const val VERSION_FILE = "droiddeck-version" - - private val busy = AtomicBoolean(false) - - fun dir(context: Context): File = File(LinuxRuntime.rootDir(context), GUEST_DIR.removePrefix("/")) - - /** The installed overlay's build, or null when it is not there. */ - fun installedVersion(context: Context): String? { - val d = dir(context) - if (!File(d, OVERLAY_DLL).let { it.isFile && it.length() > 0 }) return null - return runCatching { File(d, VERSION_FILE).readText().trim() }.getOrNull()?.ifEmpty { null } ?: "unknown" - } - - /** Starts the download in the background when the overlay is missing; nothing when it is there or under way. */ - fun ensureAsync(context: Context) { - val app = context.applicationContext - if (installedVersion(app) != null || !busy.compareAndSet(false, true)) return - Thread({ - try { ensure(app) } finally { busy.set(false) } - }, "epic-overlay").start() - } - - /** Blocking: downloads Epic's overlay component when it is missing. True when it is in place afterwards. */ - fun ensure(context: Context): Boolean { - val app = context.applicationContext - if (installedVersion(app) != null) return true - return try { - val token = EpicCredentialStore.getValidAccessToken(app) ?: return false.also { Log.i(TAG, "overlay: not signed in") } - val manifest = EpicApiClient.getManifestApiJson(token, OVERLAY_NAMESPACE, OVERLAY_CATALOG_ITEM, OVERLAY_APP) - ?: return false.also { Log.w(TAG, "overlay: manifest not fetched") } - val target = dir(app).apply { mkdirs() } - StoresState.logLine("epic: fetching the EOS overlay") - val result = EpicDownloadManager.install(app, manifest, target.path, "", null, AtomicBoolean(false), object : EpicDownloadManager.Callback { - override fun onProgress(message: String, pct: Int) {} - override fun onLog(line: String) { StoresState.logLine(line) } - }) - val ok = result != null && File(target, OVERLAY_DLL).isFile - if (ok) File(target, VERSION_FILE).writeText(result!!.buildVersion.ifEmpty { "unknown" }) - Log.i(TAG, "overlay: " + if (ok) "installed ${result!!.buildVersion}" else "install did not produce $OVERLAY_DLL") - ok - } catch (e: Exception) { - Log.w(TAG, "overlay: ${e.javaClass.simpleName}: ${e.message}") - false - } - } -} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index ce5503becc..3da6c61afe 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -508,7 +508,7 @@ internal fun LaunchSettings(s: FrontEndState, a: FrontEndActions, host: MenuHost /** Epic's account page behind its sign-in: signing in there presents any step the account still owes. */ private const val EPIC_RESOLVE_URL = "https://www.epicgames.com/id/login?redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Faccount%2Fpersonal" -/** The Epic card: sign-in, offline and overlay switches, read from and written to the game's sidecar. */ +/** The Epic card: the sign-in and offline switches, read from and written to the game's sidecar, and Resolve Epic sign-in. */ @Composable private fun EpicLaunchCard(host: MenuHost, folder: java.io.File) { val appContext = androidx.compose.ui.platform.LocalContext.current.applicationContext @@ -517,7 +517,6 @@ private fun EpicLaunchCard(host: MenuHost, folder: java.io.File) { val value = buildList { if (options.offline) add(stringResource(R.string.epic_card_offline)) else if (options.eos) add(stringResource(R.string.epic_card_eos)) - if (options.overlay) add(stringResource(R.string.epic_card_overlay)) }.ifEmpty { listOf(stringResource(R.string.epic_card_none)) }.joinToString(" · ") // Each switch goes straight to the sidecar on disk - both launch paths read it there - and the // card shows what was read back, so a write that did not take is never shown as done. @@ -525,8 +524,7 @@ private fun EpicLaunchCard(host: MenuHost, folder: java.io.File) { Thread({ val written = runCatching { com.droiddeck.launcher.stores.StoreGameSidecar.updateEpic(folder, change) } .onFailure { android.util.Log.w("EpicLaunchCard", "could not write ${folder.name}: ${it.message}") }.getOrNull() - if (written != null) android.util.Log.i("EpicLaunchCard", "epic options ${written.id} eos=${written.epic.eos} offline=${written.epic.offline} overlay=${written.epic.overlay}") - if (written?.epic?.overlay == true) com.droiddeck.launcher.stores.epic.EpicOverlay.ensureAsync(appContext) + if (written != null) android.util.Log.i("EpicLaunchCard", "epic options ${written.id} eos=${written.epic.eos} offline=${written.epic.offline}") else android.util.Log.w("EpicLaunchCard", "epic options not saved for ${folder.name}") com.droiddeck.launcher.stores.StoresState.post { sidecar = written ?: com.droiddeck.launcher.stores.StoreGameSidecar.read(folder) } }, "epic-options").start() @@ -537,7 +535,6 @@ private fun EpicLaunchCard(host: MenuHost, folder: java.io.File) { AnchoredMenu(host.open == "epic", onDismiss = { if (host.open == "epic") host.open = null }, title = stringResource(R.string.epic_card_title)) { first -> MenuItem(stringResource(R.string.epic_eos), checked = options.eos, focusRequester = first) { set { it.copy(eos = !it.eos) } } MenuItem(stringResource(R.string.epic_offline), checked = options.offline) { set { it.copy(offline = !it.offline) } } - MenuItem(stringResource(R.string.epic_overlay), checked = options.overlay) { set { it.copy(overlay = !it.overlay) } } // Epic asks some accounts to accept something once (privacy policy, EULA) before a game may // sign in - EOS's "corrective action". Signing in on Epic's site shows it. MenuItem(stringResource(R.string.epic_resolve), checked = false) { diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 08ae047f7b..c014722c49 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2015,11 +2015,9 @@ Epic EOS Offline - Overlay Off Epic sign-in (EOS) Launch offline - Epic overlay Resolve Epic sign-in installed in your library diff --git a/app/src/test/java/com/droiddeck/launcher/stores/StoreGameSidecarTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/StoreGameSidecarTest.kt index 9217075500..1171bce1a7 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/StoreGameSidecarTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/StoreGameSidecarTest.kt @@ -47,31 +47,28 @@ class StoreGameSidecarTest { @Test fun epicLaunchChoicesRoundTripAndDefaultOn() { val plain = StoreGameSidecar.parse(StoreGameSidecar(Store.EPIC, "m", "Metalstorm", "M.exe").toJson().toString())!! - assertEquals(EpicOptions(eos = true, offline = false, overlay = false), plain.epic) + assertEquals(EpicOptions(eos = true, offline = false), plain.epic) assertTrue(plain.epic.wantsCode) - val set = StoreGameSidecar(Store.EPIC, "m", "Metalstorm", "M.exe", epic = EpicOptions(eos = true, offline = true, overlay = false)) + val set = StoreGameSidecar(Store.EPIC, "m", "Metalstorm", "M.exe", epic = EpicOptions(eos = true, offline = true)) val back = StoreGameSidecar.parse(set.toJson().toString())!! - assertEquals(EpicOptions(eos = true, offline = true, overlay = false), back.epic) + assertEquals(EpicOptions(eos = true, offline = true), back.epic) assertFalse(back.epic.wantsCode) - // A sidecar from before the choices existed reads as the defaults: sign-in on, overlay off. + // A sidecar from before the choices existed reads as the defaults. assertEquals(EpicOptions(), StoreGameSidecar.parse("""{"store":"epic","id":"m","title":"M","exe":"M.exe"}""")!!.epic) - // The old default wrote overlay=true without a version: nobody chose it, so it reads as off. - assertFalse(StoreGameSidecar.parse("""{"store":"epic","id":"m","title":"M","exe":"M.exe","epic":{"eos":true,"offline":false,"overlay":true}}""")!!.epic.overlay) - // Chosen from v2 on, it stays. - val on = StoreGameSidecar.parse(StoreGameSidecar(Store.EPIC, "m", "M", "M.exe", epic = EpicOptions(overlay = true)).toJson().toString())!! - assertTrue(on.epic.overlay) + // An earlier build's overlay field is read past. + assertEquals(EpicOptions(), StoreGameSidecar.parse("""{"store":"epic","id":"m","title":"M","exe":"M.exe","epic":{"v":2,"eos":true,"offline":false,"overlay":true}}""")!!.epic) } @Test fun aSwitchOnTheEpicCardChangesTheSidecarOnDisk() { val folder = java.io.File(org.robolectric.RuntimeEnvironment.getApplication().filesDir, "Games/Stores/Epic/Metalstorm").apply { mkdirs() } StoreGameSidecar(Store.EPIC, "m", "Metalstorm", "Metalstorm.exe", launcher = ".droiddeck-launch.bat").write(folder) - val written = StoreGameSidecar.updateEpic(folder) { it.copy(overlay = true) }!! - assertTrue(written.epic.overlay) + val written = StoreGameSidecar.updateEpic(folder) { it.copy(offline = true) }!! + assertTrue(written.epic.offline) // What the Steam-launch helper reads: the file itself. val onDisk = org.json.JSONObject(java.io.File(folder, StoreGameSidecar.FILE_NAME).readText()) - assertTrue(onDisk.getJSONObject("epic").getBoolean("overlay")) - assertEquals(EpicOptions.VERSION, onDisk.getJSONObject("epic").getInt("v")) + assertTrue(onDisk.getJSONObject("epic").getBoolean("offline")) assertTrue(onDisk.getJSONObject("epic").getBoolean("eos")) + assertFalse(onDisk.getJSONObject("epic").has("overlay")) // Everything else in it stays. assertEquals(".droiddeck-launch.bat", StoreGameSidecar.read(folder)!!.launcher) assertEquals(null, StoreGameSidecar.updateEpic(java.io.File(folder, "missing")) { it }) diff --git a/docs/development/stores.md b/docs/development/stores.md index a6013fdbfd..95f7880d60 100644 --- a/docs/development/stores.md +++ b/docs/development/stores.md @@ -88,10 +88,32 @@ A Steam shortcut names an exe and nothing more, and the listing carries no launc game that needs arguments or environment gets `.droiddeck-launch.bat` (`StoreLaunch.launcherText`): `cd` into the exe's folder, `set` each variable, start the exe with the arguments and wait. Proton's `steam.exe` shim hands a `.bat` to Wine's `cmd`. For Epic the script also reads -`.droiddeck-epic-code` when present, deletes it, and appends -`-AUTH_LOGIN=unused -AUTH_PASSWORD= -AUTH_TYPE=exchangecode`; `StoreLaunch.prepare` mints the -code right before a launch from the Stores page or the Games tab (the Steam client's own Play -button gets the offline identity arguments only). +`.droiddeck-epic-code` when present, deletes it, and passes +`-AUTH_LOGIN=unused -AUTH_PASSWORD= -AUTH_TYPE=exchangecode` on the game's command line only; +the variable it read the code into is cleared on that same line, so nothing of it is left in the +game's environment. A launcher from an earlier build is rewritten before the next Epic launch. + +The code is minted for every launch, wherever it starts. The Games tab and Stores call +`StoreLaunch.prepare` before they launch; the compat tool (`droiddeck-proton`, +`droiddeck-proton-wrap`) runs `droiddeck-store-launch` before Proton on every real launch, the Steam +client's Play button included. It finds the store launcher among Steam's arguments, reads the +sidecar beside it, and for an Epic game asks the app through `/stores/req` and `resp` +(`StoreLaunchRequests` → `StoreLaunch.epicCode`), waiting up to 5 s; the app writes the code into +the game's folder itself. Each attempt logs `epic launch id=… code=yes|no reason=…`, never the code. + +An Epic game's launch choices are the Epic card in the Games tab's launch settings - "Epic sign-in +(EOS)" (on) and "Launch offline" (off), stored in the sidecar's `epic` block so both launch paths +read the same thing - and "Resolve Epic sign-in", which opens Epic's account page behind its +sign-in in Android's browser. + +A game's web links reach Android: `droiddeck-store-launch` sets the prefix's +`HKCU\Software\Wine\WineBrowser` `Browsers` to `/usr/local/bin/droiddeck-open-url`, which is also +`xdg-open` first on the game's PATH, and hands http(s) addresses to the app, which opens them in +Android's browser. EOS uses this when a sign-in needs a one-time step ("corrective action"): it +falls back to a browser, the user approves on the phone, and the game signs in. `BL_DEBUG_BROWSER=1` +in droiddeck-env adds `WINEDEBUG=+shell,+winebrowser`. Epic's EOS overlay is not provisioned (with +it games exited while loading); an `OverlayPath` an earlier build wrote is removed at launch. The +parked overlay work is on the branch `park/epic-eos-overlay`. ## Downloads diff --git a/docs/progress-log.md b/docs/progress-log.md index ad538e46a8..e087f4ba52 100644 --- a/docs/progress-log.md +++ b/docs/progress-log.md @@ -144,6 +144,14 @@ without it and Setup says "Stores engine not built"). (`token`, `__token__`, `f_token`, `hdnts`, access/refresh/id tokens, `code=`) and Authorization / Cookie headers are blanked outside URLs too. `StoreLogTest` covers a GOG secure link and an Epic Akamai URL. The engine's own logcat lines (tag `EpicNative` etc.) are written on the native side. +- **Epic sign-in device-proven without the overlay (AYANEO Pocket FIT, `bf81104`, Metalstorm):** EOS's + corrective-action browser flow → `droiddeck xdg-open: https://www.epicgames.com` → Chrome + `epicgames.com/id/authorize?user_code=…` → approved → `[eos] got logged in`, product user id + created, the game in its hangar at 92 fps. The EOS overlay crashed the game on every overlay-on + launch, so it is removed (user decision): no overlay switch, no download, no `OverlayPath`; a + launch removes a pointer an earlier build wrote, and the app deletes an earlier 656 MB download + once. The work is parked on `park/epic-eos-overlay` (at `bf81104`). Kept: the browser hand-off, + the Epic card (sign-in, offline, Resolve Epic sign-in) and `BL_DEBUG_BROWSER`. - **A game launched from the Games tab with no session running sat at "Launching"** (device, 2026-10-09-04-steam, and 2026-10-08-05 before it). The session put `steam://rungameid/` on the client's command line; the client took it seconds before its interface was up (focus went to diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch index 2c5c0d473c..60c59a3da4 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch @@ -18,11 +18,10 @@ here - and the launcher .bat reads and deletes it. No answer within TIMEOUT seco with its offline identity. A code file older than STALE_SECONDS is removed first, so a code left by an earlier launch is never used. -The game's prefix also gets the EOS overlay's pointer, HKCU\Software\Epic Games\EOS "OverlayPath" -(the mechanism from Legendary's lfs/eos.py), naming the one copy the app keeps at OVERLAY_DIR; with -it the game's EOS SDK can show Epic's own sign-in steps in game (a consent Epic asks for once per -product) instead of waiting on a browser. Wine's browser is set to droiddeck-open-url, which hands -web addresses to Android. +The game's prefix gets Wine's browser set to droiddeck-open-url, which hands web addresses to +Android: an EOS sign-in step that falls back to a browser (a consent Epic asks for once per product) +is finished there. An EOS overlay pointer (HKCU\Software\Epic Games\EOS "OverlayPath") an earlier +build wrote is removed - with it the game exited while loading. droiddeck-store-launch """ @@ -38,10 +37,8 @@ SIDECAR = ".droiddeck-store.json" EPIC_CODE = ".droiddeck-epic-code" TIMEOUT = 5.0 STALE_SECONDS = 300 -OVERLAY_DIR = "/root/.local/share/droiddeck/epic-overlay" SERVER_WAIT = 8.0 BROWSER = "/usr/local/bin/droiddeck-open-url" -OVERLAY_DLL = "EOSOVH-Win64-Shipping.dll" EOS_KEY = "[Software\\\\Epic Games\\\\EOS]" BROWSER_KEY = "[Software\\\\Wine\\\\WineBrowser]" @@ -137,20 +134,6 @@ def set_value(reg, key, name, value, now=None): return True -def overlay_version(overlay_dir=OVERLAY_DIR): - """The overlay build the app placed, or None when it is not there.""" - d = Path(overlay_dir) - try: - if not (d / OVERLAY_DLL).is_file(): - return None - except OSError: # unreadable is the same as not there - return None - try: - return (d / "droiddeck-version").read_text().strip() or "unknown" - except OSError: - return "unknown" - - def remove_value(reg, key, name): """Drops every `"name"=` line under `key` in user.reg; True when one was there.""" if not reg.is_file(): @@ -173,10 +156,7 @@ def remove_value(reg, key, name): def options(sidecar): """An Epic game's launch choices from its sidecar, as the Games tab's Epic card sets them.""" e = sidecar.get("epic") if isinstance(sidecar.get("epic"), dict) else {} - # The overlay is off unless chosen (v2 on): the old default wrote overlay=true without a version, - # and with it on a game could exit while loading. The app's EpicOptions reads it the same way. - chosen = isinstance(e.get("v"), int) and e.get("v") >= 2 - return {"eos": e.get("eos", True) is not False, "offline": e.get("offline", False) is True, "overlay": chosen and e.get("overlay") is True} + return {"eos": e.get("eos", True) is not False, "offline": e.get("offline", False) is True} def server_socket(pfx): @@ -219,8 +199,8 @@ def has_value(reg, key, name, value=None): return value is None or last == '"%s"="%s"' % (name, reg_escape(value)) -def provision_prefix(compat_data, overlay_dir=OVERLAY_DIR, overlay=False, wait=SERVER_WAIT): - """The EOS overlay pointer (or its removal, when [overlay] is off) and Wine's browser, in the game's prefix.""" +def provision_prefix(compat_data, wait=SERVER_WAIT): + """Wine's browser set to the hand-off, and an earlier build's EOS overlay pointer removed.""" if not compat_data: return "no-prefix" pfx = Path(compat_data) / "pfx" @@ -232,16 +212,10 @@ def provision_prefix(compat_data, overlay_dir=OVERLAY_DIR, overlay=False, wait=S # winebrowser starts the first entry it can; an absolute path does not depend on the PATH Wine # hands it. set_value(reg, BROWSER_KEY, "Browsers", BROWSER + ",xdg-open") - if not overlay: - remove_value(reg, EOS_KEY, "OverlayPath") - state = "overlay-off" if not has_value(reg, EOS_KEY, "OverlayPath") else "overlay-still-set" - elif overlay_version(overlay_dir) is None: - return "overlay-missing" - else: - target = windows_path(overlay_dir) - set_value(reg, EOS_KEY, "OverlayPath", target) - # Read back, so the log says what the file holds, not what was meant. - state = "overlay-set" if has_value(reg, EOS_KEY, "OverlayPath", target) else "overlay-not-written" + removed = remove_value(reg, EOS_KEY, "OverlayPath") + state = "browser-set" if has_value(reg, BROWSER_KEY, "Browsers", BROWSER + ",xdg-open") else "browser-not-written" + if removed: + state += " old-overlay-removed" return state + (" server-running" if busy else "") @@ -274,8 +248,7 @@ def main(argv): else: got = bool(answer.get("code")) log("epic launch id=%s code=%s reason=%s" % (game, "yes" if got else "no", answer.get("reason", ""))) - done = provision_prefix(compat_data, overlay=choice["overlay"]) - log("epic overlay installed=%s prefix=%s %s" % (overlay_version() or "no", prefix_id or "?", done)) + log("epic prefix=%s %s" % (prefix_id or "?", provision_prefix(compat_data))) return 0 diff --git a/tools/tests/test_store_launch.py b/tools/tests/test_store_launch.py index e83bfbf9f8..e79b286edd 100644 --- a/tools/tests/test_store_launch.py +++ b/tools/tests/test_store_launch.py @@ -119,30 +119,29 @@ class Prefix(unittest.TestCase): (self.compat / 'pfx').mkdir(parents=True) self.reg = self.compat / 'pfx/user.reg' self.reg.write_text('WINE REGISTRY Version 2\n\n[Software\\\\Wine] 1\n"Version"="win10"\n') - self.overlay = root / 'epic-overlay' - self.overlay.mkdir() def tearDown(self): self.tmp.cleanup() - def test_the_overlay_pointer_names_the_shared_copy_through_z(self): - (self.overlay / store.OVERLAY_DLL).write_bytes(b'MZ') - (self.overlay / 'droiddeck-version').write_text('1.0.42') - self.assertEqual('overlay-set', store.provision_prefix(str(self.compat), str(self.overlay), overlay=True)) + def test_wines_browser_is_the_hand_off_by_its_path(self): + self.assertEqual('browser-set', store.provision_prefix(str(self.compat))) text = self.reg.read_text() - self.assertIn('[Software\\\\Epic Games\\\\EOS] ', text) - self.assertIn('"OverlayPath"="Z:' + str(self.overlay).replace('/', '\\\\') + '"', text) + self.assertIn('[Software\\\\Wine\\\\WineBrowser] ', text) self.assertIn('"Browsers"="/usr/local/bin/droiddeck-open-url,xdg-open"', text) # A second launch adds nothing: the last word already says so. - store.provision_prefix(str(self.compat), str(self.overlay), overlay=True) + store.provision_prefix(str(self.compat)) self.assertEqual(text, self.reg.read_text()) - self.assertEqual('1.0.42', store.overlay_version(str(self.overlay))) - def test_no_overlay_yet_or_no_prefix_yet(self): - self.assertEqual('overlay-missing', store.provision_prefix(str(self.compat), str(self.overlay), overlay=True)) - self.assertNotIn('OverlayPath', self.reg.read_text()) - self.assertEqual('prefix-not-created', store.provision_prefix(self.tmp.name + '/compatdata/1', str(self.overlay))) - self.assertEqual('no-prefix', store.provision_prefix('', str(self.overlay))) + def test_an_earlier_builds_overlay_pointer_is_removed(self): + self.reg.write_text(self.reg.read_text() + '\n[Software\\\\Epic Games\\\\EOS] 2\n"OverlayPath"="Z:\\\\x"\n"Other"="kept"\n') + self.assertEqual('browser-set old-overlay-removed', store.provision_prefix(str(self.compat))) + text = self.reg.read_text() + self.assertNotIn('OverlayPath', text) + self.assertIn('"Other"="kept"', text) + + def test_no_prefix_yet(self): + self.assertEqual('prefix-not-created', store.provision_prefix(self.tmp.name + '/compatdata/1')) + self.assertEqual('no-prefix', store.provision_prefix('')) class Choices(unittest.TestCase): @@ -150,11 +149,10 @@ class Choices(unittest.TestCase): with tempfile.TemporaryDirectory() as root: folder = game(root) sidecar = json.loads((folder / '.droiddeck-store.json').read_text()) - self.assertEqual({'eos': True, 'offline': False, 'overlay': False}, store.options(sidecar)) - # The old default (no version) never turns it on; a v2 choice does. - self.assertFalse(store.options({'epic': {'eos': True, 'offline': False, 'overlay': True}})['overlay']) - self.assertTrue(store.options({'epic': {'v': 2, 'overlay': True}})['overlay']) - sidecar['epic'] = {'eos': True, 'offline': True, 'overlay': False} + self.assertEqual({'eos': True, 'offline': False}, store.options(sidecar)) + # An earlier build's overlay field is read past. + self.assertEqual({'eos': True, 'offline': False}, store.options({'epic': {'v': 2, 'overlay': True}})) + sidecar['epic'] = {'eos': True, 'offline': True} (folder / '.droiddeck-store.json').write_text(json.dumps(sidecar)) (folder / '.droiddeck-epic-code').write_text('left over') compat = Path(root) / 'compatdata/1' @@ -168,7 +166,7 @@ class Choices(unittest.TestCase): finally: del os.environ['BL_LAUNCH_DIR'] del os.environ['STEAM_COMPAT_DATA_PATH'] - # Offline: no request was made and no code is left; overlay off: the pointer is gone. + # Offline: no request was made and no code is left; the old overlay pointer is gone. self.assertFalse((Path(root) / 'session/stores/req').exists()) self.assertFalse((folder / '.droiddeck-epic-code').exists()) text = reg.read_text()