Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch
T
The412Banner 97a0f1553f Stores: Epic games get the EOS overlay, and their web links open on Android
Metalstorm's EOS sign-in asked for a one-time consent, could not load an
overlay to show it, and fell back to a browser flow that never finished.
Epic's own overlay component (the mechanism from Legendary's lfs/eos.py;
credits in EpicOverlay.kt) is now downloaded once with the account's
token into the runtime, after an Epic library sync or at the first
launch that finds it missing. At each launch droiddeck-store-launch
writes the one pointer, HKCU Software\Epic Games\EOS OverlayPath, into
the game's prefix, appended to user.reg as the DirectAudio key is, and
the app logs epic overlay installed=<build> prefix=<appid>.

Wine's browser is set to xdg-open, and on a game's PATH a small xdg-open
hands http(s) addresses to the app, which opens them in Android's
browser, so a device-code sign-in can be finished on the phone.
2026-10-08 23:31:34 -04:00

195 lines
7.4 KiB
Python
Executable File

#!/usr/bin/python3
"""Before Proton starts a store game, asks the app for what that store needs at launch.
Run by droiddeck-proton / droiddeck-proton-wrap (steam-compatibility) for every real game launch,
whoever started it: the Games tab, a pinned shortcut, or the Steam client's own Play button. It
looks for the store launcher DroidDeck wrote (.droiddeck-launch.bat) among the arguments; beside it
.droiddeck-store.json says which store and game it is.
For an Epic game the game needs a fresh exchange code to sign in, which only the app can mint. The
request goes through files under $BL_LAUNCH_DIR/stores (the session root, the same path on both
sides):
req/<id>.json {"op": "epic-code", "store": "epic", "id": "<app name>"} (tmp + rename)
resp/<id>.json {"ok": true, "code": true|false, "reason": "..."}
The app writes .droiddeck-epic-code into the game's folder itself - the code never passes through
here - and the launcher .bat reads and deletes it. No answer within TIMEOUT seconds: the game starts
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 pointed at xdg-open, which this
runtime's /usr/local/lib/droiddeck/browser/xdg-open hands to Android.
droiddeck-store-launch <the arguments Steam gave the compat tool>
"""
import json
import os
import sys
import time
from pathlib import Path
LAUNCHER = ".droiddeck-launch.bat"
SIDECAR = ".droiddeck-store.json"
EPIC_CODE = ".droiddeck-epic-code"
TIMEOUT = 5.0
STALE_SECONDS = 300
OVERLAY_DIR = "/root/.local/share/droiddeck/epic-overlay"
OVERLAY_DLL = "EOSOVH-Win64-Shipping.dll"
EOS_KEY = "[Software\\\\Epic Games\\\\EOS]"
BROWSER_KEY = "[Software\\\\Wine\\\\WineBrowser]"
def log(line):
print("droiddeck-store-launch: " + line, file=sys.stderr, flush=True)
def find_store_game(argv):
"""The (folder, sidecar) of the store launcher among [argv], or None when this is not one."""
for raw in argv:
arg = raw.strip().strip('"').strip("'")
if not arg.lower().endswith(LAUNCHER):
continue
folder = Path(arg.replace("\\", "/")).parent
try:
sidecar = json.loads((folder / SIDECAR).read_text())
except (OSError, ValueError):
continue
if not isinstance(sidecar, dict) or not sidecar.get("store") or not sidecar.get("id"):
continue
return folder, sidecar
return None
def drop_stale(folder, now=None):
"""Removes a code file older than STALE_SECONDS; True when one was removed."""
code = folder / EPIC_CODE
try:
if (now if now is not None else time.time()) - code.stat().st_mtime > STALE_SECONDS:
code.unlink()
return True
except OSError:
pass
return False
def ask(channel, request, timeout=TIMEOUT):
"""Writes [request] under channel/req and waits for channel/resp; the answer, or None on timeout."""
req_dir, resp_dir = channel / "req", channel / "resp"
req_dir.mkdir(parents=True, exist_ok=True)
resp_dir.mkdir(parents=True, exist_ok=True)
rid = "%d-%d" % (os.getpid(), int(time.time() * 1000))
tmp = req_dir / (rid + ".json.tmp")
tmp.write_text(json.dumps(request))
os.rename(tmp, req_dir / (rid + ".json"))
answer = resp_dir / (rid + ".json")
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
value = json.loads(answer.read_text())
answer.unlink()
return value
except (OSError, ValueError):
time.sleep(0.05)
# Not answered: the request is withdrawn so a late app does not mint a code nobody reads.
try:
(req_dir / (rid + ".json")).unlink()
except OSError:
pass
return None
def windows_path(unix):
"""A guest path as Wine names it through Z: (the whole filesystem)."""
return "Z:" + unix.replace("/", "\\")
def reg_escape(value):
return value.replace("\\", "\\\\").replace('"', '\\"')
def set_value(reg, key, name, value, now=None):
"""
Appends `key` with `"name"="value"` to a prefix's user.reg unless the last word on it already
says so. Appended rather than edited in place, as DirectAudio's key is: Wine reads later sections
over earlier ones, and nothing of the file is rewritten under a wineserver that might hold it.
False when there is no user.reg yet (Proton creates the prefix after this; the next launch has it).
"""
if not reg.is_file():
return False
line = '"%s"="%s"' % (name, reg_escape(value))
inside, last = False, None
for row in reg.read_text(errors="replace").splitlines():
if row.startswith("["):
inside = row.startswith(key + " ") or row == key
elif inside and row.startswith('"%s"=' % name):
last = row
if last == line:
return True
with open(reg, "a") as out:
out.write("\n%s %d\n%s\n" % (key, int(now if now is not None else time.time()), line))
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)
if not (d / OVERLAY_DLL).is_file():
return None
try:
return (d / "droiddeck-version").read_text().strip() or "unknown"
except OSError:
return "unknown"
def provision_prefix(compat_data, overlay_dir=OVERLAY_DIR):
"""The EOS overlay pointer and Wine's browser, in the game's prefix. Returns what was done."""
if not compat_data:
return "no-prefix"
reg = Path(compat_data) / "pfx" / "user.reg"
if not reg.is_file():
return "prefix-not-created"
set_value(reg, BROWSER_KEY, "Browsers", "xdg-open")
if overlay_version(overlay_dir) is None:
return "overlay-missing"
set_value(reg, EOS_KEY, "OverlayPath", windows_path(overlay_dir))
return "overlay-set"
def main(argv):
found = find_store_game(argv)
if found is None:
return 0
folder, sidecar = found
store, game = str(sidecar.get("store")), str(sidecar.get("id"))
if store != "epic":
return 0
drop_stale(folder)
launch_dir = os.environ.get("BL_LAUNCH_DIR", "")
if not launch_dir:
log("epic launch id=%s code=no reason=no-channel" % game)
return 0
compat_data = os.environ.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
prefix_id = os.path.basename(compat_data) if compat_data else ""
answer = ask(Path(launch_dir) / "stores", {"op": "epic-code", "store": store, "id": game, "prefix": prefix_id})
if answer is None:
log("epic launch id=%s code=no reason=timeout" % game)
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)
log("epic overlay installed=%s prefix=%s %s" % (overlay_version() or "no", prefix_id or "?", done))
return 0
if __name__ == "__main__":
try:
sys.exit(main(sys.argv[1:]))
except Exception as e: # never in the way of the launch
log("skipped: %s" % type(e).__name__)
sys.exit(0)