mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 14:26:00 +00:00
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.
195 lines
7.4 KiB
Python
Executable File
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)
|