mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 13:55:58 +00:00
Merge upstream main and close diagnostic publication races
This commit is contained in:
473 files changed
+36063
-3507
No files matched your search
@@ -259,24 +259,91 @@ def focus_snapshot():
|
||||
STEAM_APP_CLASS = re.compile(r"steam_app_(\d+)$")
|
||||
|
||||
|
||||
def tag_game_windows(snap):
|
||||
if os.environ.get("BL_STEAM_CLIENT_ARCH") != "x86_64":
|
||||
return False
|
||||
def process_env(pid, proc=Path("/proc")):
|
||||
try:
|
||||
return dict(entry.split(b"=", 1) for entry in (proc / str(pid) / "environ").read_bytes().split(b"\0") if b"=" in entry)
|
||||
except OSError:
|
||||
return {}
|
||||
|
||||
|
||||
def steam_app_id(env):
|
||||
try:
|
||||
app = int(env.get(b"SteamAppId", b"0"))
|
||||
except ValueError:
|
||||
return None
|
||||
return app if 0 < app < 2**32 else None
|
||||
|
||||
|
||||
def under_reaper(pid, proc=Path("/proc")):
|
||||
for _ in range(64):
|
||||
try:
|
||||
if (proc / str(pid) / "comm").read_text().strip() == "reaper":
|
||||
return True
|
||||
stat = (proc / str(pid) / "stat").read_text()
|
||||
pid = int(stat[stat.rindex(")") + 2:].split()[1])
|
||||
except (OSError, ValueError, IndexError):
|
||||
return False
|
||||
if pid <= 1:
|
||||
return False
|
||||
return False
|
||||
|
||||
|
||||
def sandboxed_apps(proc=Path("/proc")):
|
||||
apps = {}
|
||||
try:
|
||||
pids = [entry for entry in os.listdir(proc) if entry.isdigit()]
|
||||
except OSError:
|
||||
return apps
|
||||
for pid in pids:
|
||||
env = process_env(pid, proc)
|
||||
flatpak, app = env.get(b"FLATPAK_ID"), steam_app_id(env)
|
||||
if flatpak and app:
|
||||
name = flatpak.decode(errors="replace").lower()
|
||||
for key in {name, name.rsplit(".", 1)[-1]}:
|
||||
apps[key] = app if apps.get(key, app) == app else None
|
||||
return apps
|
||||
|
||||
|
||||
def window_steam_app(win, flatpaks, proc=Path("/proc")):
|
||||
match = STEAM_APP_CLASS.match(win.get("class") or "")
|
||||
if match:
|
||||
return match.group(1) if os.environ.get("BL_STEAM_CLIENT_ARCH") == "x86_64" else None
|
||||
pid = win.get("pid")
|
||||
if pid:
|
||||
if under_reaper(pid, proc):
|
||||
return None
|
||||
app = steam_app_id(process_env(pid, proc))
|
||||
if app:
|
||||
return str(app)
|
||||
app = flatpaks().get((win.get("class") or "").lower())
|
||||
return str(app) if app else None
|
||||
|
||||
|
||||
def tag_game_windows(snap, proc=Path("/proc")):
|
||||
tagged = False
|
||||
found = []
|
||||
|
||||
def flatpaks():
|
||||
if not found:
|
||||
found.append(sandboxed_apps(proc))
|
||||
return found[0]
|
||||
|
||||
for display, wins in snap.get("displays", {}).items():
|
||||
if display == os.environ.get("DISPLAY"):
|
||||
continue
|
||||
for win in wins:
|
||||
match = STEAM_APP_CLASS.match(win.get("class") or "")
|
||||
if not match or win.get("appId") or win.get("map") != "viewable" or win.get("overrideRedirect"):
|
||||
if win.get("appId") or win.get("map") != "viewable" or win.get("overrideRedirect") or win.get("inputOnly"):
|
||||
continue
|
||||
app = window_steam_app(win, flatpaks, proc)
|
||||
if not app:
|
||||
continue
|
||||
try:
|
||||
done = subprocess.run(["xprop", "-display", display, "-id", str(win["window"]), "-f", "STEAM_GAME", "32c",
|
||||
"-set", "STEAM_GAME", match.group(1)],
|
||||
"-set", "STEAM_GAME", app],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5).returncode == 0
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
done = False
|
||||
log("game window %s on %s tagged STEAM_GAME=%s: %s" % (win["window"], display, match.group(1), "ok" if done else "failed"))
|
||||
log("game window %s on %s tagged STEAM_GAME=%s: %s" % (win["window"], display, app, "ok" if done else "failed"))
|
||||
tagged = tagged or done
|
||||
return tagged
|
||||
|
||||
|
||||
+965
@@ -0,0 +1,965 @@
|
||||
#!/usr/bin/python3
|
||||
import fcntl
|
||||
import http.client
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import signal
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
HOME = os.environ.get("HOME") or "/root"
|
||||
BIN = "/usr/local/bin"
|
||||
PROTON_RUN = os.path.join(BIN, "droiddeck-proton-run")
|
||||
APP_ID = "2596113170"
|
||||
INSTALLER_URL = "https://downloader.battle.net/download/getInstallerForGame?os=win&gameProgram=BATTLENET_APP&version=Live"
|
||||
CLIENT_DIR = ("Program Files (x86)", "Battle.net")
|
||||
LAUNCHER = "Battle.net Launcher.exe"
|
||||
CLIENT = "Battle.net.exe"
|
||||
CONFIG = ("users", "steamuser", "AppData", "Roaming", "Battle.net", "Battle.net.config")
|
||||
DEFAULT_CONFIG = {"Client": {"HardwareAcceleration": "false", "Streaming": {"StreamingEnabled": "false"}}}
|
||||
LAUNCH_BEHAVIOR = ("GameLaunchWindowBehavior", "2")
|
||||
CLIENT_32_BIT = ("s1",)
|
||||
CACHE = os.path.join(HOME, ".cache", "droiddeck", "battlenet")
|
||||
MENU = "/usr/local/share/applications/droiddeck-battlenet.desktop"
|
||||
WALLPAPER_DIR = ("users", "steamuser", "AppData", "Local", "DroidDeck")
|
||||
DESKTOP_KEY = "[Control Panel\\\\Desktop]"
|
||||
COLORS_KEY = "[Control Panel\\\\Colors]"
|
||||
WALLPAPER_EDGE = (4, 6, 11)
|
||||
WALLPAPER_MAX = (1280, 720)
|
||||
FEX_REQUEST = "battlenet-fex.request"
|
||||
FEX_RESULT = "battlenet-fex.result"
|
||||
FEX_WAIT = 120
|
||||
START_GRACE = 90
|
||||
POLL = 2
|
||||
STOP_WAIT = 5
|
||||
CLOSE_GRACE = 15
|
||||
HANDOFF_WAIT = 120
|
||||
GAME_SETTLE = 20
|
||||
AGENT_GONE = 30
|
||||
AGENT = "agent.exe"
|
||||
CODE = re.compile(r"[A-Za-z0-9_]{1,16}")
|
||||
GAME_UID = re.compile(r"[a-z0-9_]{1,32}")
|
||||
HANDOVER_WAIT = 1800
|
||||
CLIENT_READY = 5
|
||||
READY_SETTLE = 5
|
||||
CLIENT_WAIT = 300
|
||||
GAME_GRACE = 15
|
||||
LAUNCH_WAIT = 15
|
||||
LAUNCH_ASKS = 3
|
||||
CLIENT_PATH = re.compile(r"[a-z]:\\(program files \(x86\)|programdata)\\battle\.net\\")
|
||||
IDLE = {"agent.exe", "conhost.exe", "explorer.exe", "lsass.exe", "plugplay.exe", "rpcss.exe", "services.exe",
|
||||
"start.exe", "steam.exe", "svchost.exe", "tabtip.exe", "winedevice.exe", "wineserver"}
|
||||
NOT_GAME = IDLE | {"rundll32.exe", "wineboot.exe", "winemenubuilder.exe"}
|
||||
MIN_INSTALLER = 1 << 20
|
||||
SETUP = "Battle.net-Setup.exe"
|
||||
REQUEST = "battlenet-request"
|
||||
REQUEST_FILE = re.compile(re.escape(REQUEST) + r"\.\d+")
|
||||
LIBRARY = None
|
||||
WOW_UID = re.compile(r"--uid=wow[a-z0-9_]*", re.I)
|
||||
GAMEPAD_SETTING = re.compile(r"(?im)^\s*SET\s+GamePadEnable\s")
|
||||
GX_API_SETTING = re.compile(r"(?im)^[ \t]*SET[ \t]+gxApi[ \t].*$")
|
||||
GX_API_MARK = ".droiddeck-d3d11"
|
||||
STEAM_CLIENT = {"steam", "steamwebhelper"}
|
||||
LOG = os.path.join(CACHE, "battlenet.log")
|
||||
LOG_LIMIT = 512 << 10
|
||||
|
||||
|
||||
def say(message):
|
||||
line = "droiddeck-battlenet: %s" % message
|
||||
print(line, file=sys.stderr, flush=True)
|
||||
try:
|
||||
os.makedirs(CACHE, exist_ok=True)
|
||||
if os.path.exists(LOG) and os.path.getsize(LOG) > LOG_LIMIT:
|
||||
os.replace(LOG, LOG + ".1")
|
||||
with open(LOG, "a", encoding="utf-8") as f:
|
||||
f.write("%s [%d] %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), os.getpid(), message))
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
def notify(title, body, icon="dialog-information"):
|
||||
if not os.environ.get("DBUS_SESSION_BUS_ADDRESS") or not shutil.which("notify-send"):
|
||||
return
|
||||
try:
|
||||
subprocess.run(["notify-send", "-a", "DroidDeck", "-i", icon, title, body],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5)
|
||||
except (OSError, subprocess.SubprocessError):
|
||||
pass
|
||||
|
||||
|
||||
def steam_root():
|
||||
return os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or os.path.join(HOME, ".local", "share", "Steam")
|
||||
|
||||
|
||||
def prefix(root):
|
||||
return os.path.join(root, "steamapps", "compatdata", APP_ID)
|
||||
|
||||
|
||||
def drive_c(root):
|
||||
return os.path.join(prefix(root), "pfx", "drive_c")
|
||||
|
||||
|
||||
def client_dir(root):
|
||||
return os.path.join(drive_c(root), *CLIENT_DIR)
|
||||
|
||||
|
||||
def launcher(root):
|
||||
return os.path.join(client_dir(root), LAUNCHER)
|
||||
|
||||
|
||||
def installed(root):
|
||||
return os.path.isfile(launcher(root))
|
||||
|
||||
|
||||
def install_path(library):
|
||||
return "Z:" + library.rstrip("/")
|
||||
|
||||
|
||||
def write_config(root, library=None):
|
||||
path = os.path.join(drive_c(root), *CONFIG)
|
||||
key, value = LAUNCH_BEHAVIOR
|
||||
try:
|
||||
with open(path, encoding="utf-8-sig") as f:
|
||||
config = json.load(f)
|
||||
except FileNotFoundError:
|
||||
config = None
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
first = config is None
|
||||
if first:
|
||||
config = json.loads(json.dumps(DEFAULT_CONFIG))
|
||||
elif not (isinstance(config, dict) and isinstance(config.setdefault("Client", {}), dict)):
|
||||
return None
|
||||
client = config["Client"]
|
||||
changes = []
|
||||
if client.get(key) != value:
|
||||
client[key] = value
|
||||
changes.append("launch")
|
||||
if client.get("HardwareAcceleration") != "false":
|
||||
client["HardwareAcceleration"] = "false"
|
||||
changes.append("acceleration")
|
||||
if library and isinstance(client.setdefault("Install", {}), dict) \
|
||||
and str(client["Install"].get("DefaultInstallPath", "")).rstrip("/\\") != install_path(library):
|
||||
client["Install"]["DefaultInstallPath"] = install_path(library)
|
||||
changes.append("library")
|
||||
games = config.setdefault("Games", {})
|
||||
for uid in CLIENT_32_BIT if isinstance(games, dict) else ():
|
||||
game = games.setdefault(uid, {})
|
||||
if isinstance(game, dict) and game.get("Run64BitSet") != "true":
|
||||
game.update(Run64Bit="false", Run64BitSet="true")
|
||||
changes.append("32-bit")
|
||||
if not changes:
|
||||
return None
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
json.dump(config, f, indent=4)
|
||||
os.replace(path + ".tmp", path)
|
||||
return "first" if first else " ".join(changes)
|
||||
|
||||
|
||||
def wallpaper_bmp(width, height):
|
||||
scale = min(width / 1920.0, height / 1080.0)
|
||||
ox, oy = (width - 1920 * scale) / 2, (height - 1080 * scale) / 2
|
||||
stops = ((0.0, (20, 33, 58)), (0.5, (10, 17, 32)), (1.0, WALLPAPER_EDGE))
|
||||
glow = (26, 159, 255)
|
||||
logo_px = scale * 1.6
|
||||
|
||||
def background(u, v):
|
||||
t = min(math.hypot(u - 960, v - 540) / 1150, 1.0)
|
||||
(t0, c0), (t1, c1) = (stops[0], stops[1]) if t <= 0.5 else (stops[1], stops[2])
|
||||
f = (t - t0) / (t1 - t0)
|
||||
color = [c0[i] + (c1[i] - c0[i]) * f for i in range(3)]
|
||||
d = math.hypot(u - 947.21, v - 540) / 420
|
||||
if d < 1:
|
||||
a = 0.22 * (1 - d)
|
||||
color = [color[i] * (1 - a) + glow[i] * a for i in range(3)]
|
||||
return color
|
||||
|
||||
def box(x, y, x0, y0, x1, y1):
|
||||
dx, dy = max(x0 - x, x - x1), max(y0 - y, y - y1)
|
||||
return math.hypot(max(dx, 0), max(dy, 0)) + min(max(dx, dy), 0)
|
||||
|
||||
def white(x, y):
|
||||
half = max(math.hypot(x - 63.97, y - 111.86) - 111.86, 63.97 - x)
|
||||
shape = min(box(x, y, -31.98, 0, 63.97, 223.72), half)
|
||||
hole = min(math.hypot(x - 63.98, y - 111.86) - 71.81,
|
||||
box(x, y, 56.055, -1, 71.885, 45), box(x, y, 56.055, 178.72, 71.885, 225))
|
||||
return max(shape, -hole)
|
||||
|
||||
rows = []
|
||||
pad = b"\0" * ((4 - width * 3 % 4) % 4)
|
||||
for y in range(height - 1, -1, -1):
|
||||
v = (y + 0.5 - oy) / scale
|
||||
ly = (v - 361.02) / 1.6
|
||||
row = bytearray()
|
||||
for x in range(width):
|
||||
u = (x + 0.5 - ox) / scale
|
||||
color = background(u, v)
|
||||
lx = (u - 844.84) / 1.6
|
||||
if -40 < lx < 185 and -8 < ly < 232:
|
||||
for sd, ink in ((white(lx, ly), (255, 255, 255)), (math.hypot(lx - 63.98, ly - 111.86) - 55.98, glow)):
|
||||
cover = min(max(0.5 - sd * logo_px, 0.0), 1.0)
|
||||
if cover:
|
||||
color = [color[i] * (1 - cover) + ink[i] * cover for i in range(3)]
|
||||
row += bytes((int(color[2] + 0.5), int(color[1] + 0.5), int(color[0] + 0.5)))
|
||||
rows.append(bytes(row) + pad)
|
||||
pixels = b"".join(rows)
|
||||
header = b"BM" + (54 + len(pixels)).to_bytes(4, "little") + b"\0\0\0\0" + (54).to_bytes(4, "little")
|
||||
info = (40).to_bytes(4, "little") + width.to_bytes(4, "little") + height.to_bytes(4, "little") + \
|
||||
(1).to_bytes(2, "little") + (24).to_bytes(2, "little") + b"\0" * 4 + len(pixels).to_bytes(4, "little") + \
|
||||
(2835).to_bytes(4, "little") * 2 + b"\0" * 8
|
||||
return header + info + pixels
|
||||
|
||||
|
||||
def reg_value(reg, key, name, value):
|
||||
line = '"%s"="%s"' % (name, value.replace("\\", "\\\\").replace('"', '\\"'))
|
||||
try:
|
||||
with open(reg, encoding="utf-8", errors="replace") as f:
|
||||
rows = f.read().splitlines()
|
||||
except OSError:
|
||||
return False
|
||||
inside, last = False, None
|
||||
for row in rows:
|
||||
if row.startswith("["):
|
||||
inside = row.startswith(key + " ") or row == key
|
||||
elif inside and row.startswith('"%s"=' % name):
|
||||
last = row
|
||||
if last != line:
|
||||
with open(reg, "a", encoding="utf-8") as out:
|
||||
out.write("\n%s %d\n%s\n" % (key, int(time.time()), line))
|
||||
return True
|
||||
|
||||
|
||||
def desktop_size():
|
||||
width, height = os.environ.get("BL_WIDTH", ""), os.environ.get("BL_HEIGHT", "")
|
||||
if width.isdigit() and height.isdigit() and 0 < int(width) <= 7680 and 0 < int(height) <= 4320:
|
||||
return int(width), int(height)
|
||||
return 1280, 720
|
||||
|
||||
|
||||
def wallpaper(root):
|
||||
width, height = desktop_size()
|
||||
shrink = min(1.0, WALLPAPER_MAX[0] / width, WALLPAPER_MAX[1] / height)
|
||||
width, height = max(1, round(width * shrink)), max(1, round(height * shrink))
|
||||
name = "wallpaper-%dx%d.bmp" % (width, height)
|
||||
folder = os.path.join(drive_c(root), *WALLPAPER_DIR)
|
||||
path = os.path.join(folder, name)
|
||||
reg = os.path.join(prefix(root), "pfx", "user.reg")
|
||||
if not os.path.isfile(reg):
|
||||
return False
|
||||
if not os.path.isfile(path):
|
||||
os.makedirs(folder, exist_ok=True)
|
||||
with open(path + ".tmp", "wb") as f:
|
||||
f.write(wallpaper_bmp(width, height))
|
||||
os.replace(path + ".tmp", path)
|
||||
say("drew DroidDeck's wallpaper for Battle.net's %dx%d desktop" % (width, height))
|
||||
windows = "C:\\" + "\\".join(WALLPAPER_DIR + (name,))
|
||||
reg_value(reg, DESKTOP_KEY, "Wallpaper", windows)
|
||||
reg_value(reg, DESKTOP_KEY, "TileWallpaper", "0")
|
||||
reg_value(reg, DESKTOP_KEY, "WallpaperStyle", "2" if shrink < 1 else "0")
|
||||
reg_value(reg, COLORS_KEY, "Background", "%d %d %d" % WALLPAPER_EDGE)
|
||||
return True
|
||||
|
||||
|
||||
def windows_path(root, path):
|
||||
found = re.match(r"(?i)^([cz]):[\\/](.*)$", path.strip())
|
||||
if not found:
|
||||
return None
|
||||
parts = [part for part in re.split(r"[\\/]+", found.group(2)) if part]
|
||||
if not parts or ".." in parts:
|
||||
return None
|
||||
return os.path.join(drive_c(root) if found.group(1).lower() == "c" else "/", *parts)
|
||||
|
||||
|
||||
def wow_folders(root):
|
||||
try:
|
||||
with open(os.path.join(prefix(root), "pfx", "system.reg"), encoding="utf-8", errors="replace") as f:
|
||||
rows = f.read().splitlines()
|
||||
except OSError:
|
||||
return []
|
||||
folders, location, wow = [], None, False
|
||||
for row in rows + ["["]:
|
||||
if row.startswith("["):
|
||||
if wow and location:
|
||||
folders.append(location)
|
||||
location, wow = None, False
|
||||
elif row.startswith('"InstallLocation"='):
|
||||
location = windows_path(root, row.split("=", 1)[1].strip().strip('"').replace("\\\\", "\\"))
|
||||
elif row.startswith('"UninstallString"=') and WOW_UID.search(row):
|
||||
wow = True
|
||||
return [folder for folder in dict.fromkeys(folders) if os.path.isdir(folder)]
|
||||
|
||||
|
||||
def wow_settings(root):
|
||||
changed = []
|
||||
for folder in wow_folders(root):
|
||||
try:
|
||||
flavors = sorted(name for name in os.listdir(folder) if len(name) > 2 and name.startswith("_") and name.endswith("_"))
|
||||
except OSError:
|
||||
continue
|
||||
for name in flavors:
|
||||
if not os.path.isdir(os.path.join(folder, name)):
|
||||
continue
|
||||
wtf = os.path.join(folder, name, "WTF")
|
||||
path = os.path.join(wtf, "Config.wtf")
|
||||
mark = os.path.join(wtf, GX_API_MARK)
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
text = f.read()
|
||||
except FileNotFoundError:
|
||||
text = ""
|
||||
except OSError:
|
||||
continue
|
||||
updated, notes = text, []
|
||||
if not GAMEPAD_SETTING.search(updated):
|
||||
updated += ("\n" if updated and not updated.endswith("\n") else "") + 'SET GamePadEnable "1"\n'
|
||||
notes.append("controller support on")
|
||||
first = not os.path.exists(mark)
|
||||
if first:
|
||||
before = updated
|
||||
updated, found = GX_API_SETTING.subn('SET gxApi "D3D11"', updated)
|
||||
if not found:
|
||||
updated += ("\n" if updated and not updated.endswith("\n") else "") + 'SET gxApi "D3D11"\n'
|
||||
if updated != before:
|
||||
notes.append("DirectX 11")
|
||||
if updated == text and not first:
|
||||
continue
|
||||
try:
|
||||
os.makedirs(wtf, exist_ok=True)
|
||||
if updated != text:
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write(updated)
|
||||
os.replace(path + ".tmp", path)
|
||||
if first:
|
||||
with open(mark, "w", encoding="utf-8"):
|
||||
pass
|
||||
except OSError as error:
|
||||
say("World of Warcraft's settings not written in %s: %s" % (path, error))
|
||||
continue
|
||||
if notes:
|
||||
changed.append(path)
|
||||
say("World of Warcraft's settings in %s: %s" % (path, ", ".join(notes)))
|
||||
return changed
|
||||
|
||||
|
||||
def steam_running(proc="/proc"):
|
||||
try:
|
||||
pids = [p for p in os.listdir(proc) if p.isdigit()]
|
||||
except OSError:
|
||||
return False
|
||||
for pid in pids:
|
||||
try:
|
||||
with open(os.path.join(proc, pid, "cmdline"), "rb") as f:
|
||||
argv = [os.path.basename(a.decode("utf-8", "replace")) for a in f.read().split(b"\0")[:2] if a]
|
||||
except OSError:
|
||||
continue
|
||||
if argv[:1] and argv[0] in ("FEX", "FEXInterpreter"):
|
||||
argv = argv[1:]
|
||||
if argv[:1] and argv[0] in STEAM_CLIENT:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def proton_env():
|
||||
env = dict(os.environ)
|
||||
if not steam_running():
|
||||
env.setdefault("PROTON_SPOOF_STEAMINPUT_VIDPID", "1")
|
||||
return env
|
||||
|
||||
|
||||
def configure(root, library=None):
|
||||
if library:
|
||||
try:
|
||||
os.makedirs(library, exist_ok=True)
|
||||
except OSError as error:
|
||||
say("%s not made: %s" % (library, error))
|
||||
try:
|
||||
change = write_config(root, library)
|
||||
except OSError as error:
|
||||
say("Battle.net's config not written: %s" % error)
|
||||
return
|
||||
try:
|
||||
wallpaper(root)
|
||||
except OSError as error:
|
||||
say("Battle.net's desktop wallpaper not set: %s" % error)
|
||||
wow_settings(root)
|
||||
if change == "first":
|
||||
say("wrote Battle.net's first config: hardware acceleration off, streaming off, closing itself as it launches a game, "
|
||||
"StarCraft on its 32-bit client")
|
||||
elif change:
|
||||
if "launch" in change:
|
||||
say("Battle.net's config: closing itself as it launches a game")
|
||||
if "library" in change:
|
||||
say("Battle.net's config: games install to %s" % library)
|
||||
if "acceleration" in change:
|
||||
say("Battle.net's config: browser hardware acceleration off")
|
||||
if "32-bit" in change:
|
||||
say("Battle.net's config: StarCraft starts its 32-bit client")
|
||||
|
||||
|
||||
def write_menu(path=MENU):
|
||||
body = ("[Desktop Entry]\nType=Application\nName=Battle.net\nComment=Blizzard's games and launcher\n"
|
||||
"Exec=%s\nIcon=applications-games\nTerminal=false\nCategories=Network;\n"
|
||||
% os.path.join(BIN, "droiddeck-battlenet"))
|
||||
try:
|
||||
with open(path, encoding="utf-8") as f:
|
||||
if f.read() == body:
|
||||
return
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write(body)
|
||||
os.replace(path + ".tmp", path)
|
||||
except OSError as error:
|
||||
say("menu entry not written: %s" % error)
|
||||
|
||||
|
||||
def ask_fex(launch_dir, wait=FEX_WAIT):
|
||||
if not launch_dir or not os.path.isdir(launch_dir):
|
||||
say("not inside a DroidDeck session; FEX stays as Components has it")
|
||||
return None
|
||||
result = os.path.join(launch_dir, FEX_RESULT)
|
||||
request = os.path.join(launch_dir, FEX_REQUEST)
|
||||
try:
|
||||
os.unlink(result)
|
||||
except OSError:
|
||||
pass
|
||||
with open(request + ".tmp", "w", encoding="utf-8") as f:
|
||||
f.write("appid=%s\n" % APP_ID)
|
||||
os.replace(request + ".tmp", request)
|
||||
deadline = time.monotonic() + wait
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
with open(result, encoding="utf-8") as f:
|
||||
answer = f.read().strip()
|
||||
except OSError:
|
||||
time.sleep(0.5)
|
||||
continue
|
||||
os.unlink(result)
|
||||
return answer
|
||||
return None
|
||||
|
||||
|
||||
def wine_processes(pfx, proc="/proc"):
|
||||
want = os.path.realpath(pfx).rstrip("/")
|
||||
found = []
|
||||
try:
|
||||
pids = [p for p in os.listdir(proc) if p.isdigit()]
|
||||
except OSError:
|
||||
return found
|
||||
for pid in pids:
|
||||
try:
|
||||
with open(os.path.join(proc, pid, "environ"), "rb") as f:
|
||||
env = f.read().split(b"\0")
|
||||
with open(os.path.join(proc, pid, "cmdline"), "rb") as f:
|
||||
argv = [a.decode("utf-8", "replace") for a in f.read().split(b"\0") if a]
|
||||
except OSError:
|
||||
continue
|
||||
for item in env:
|
||||
if item.startswith(b"WINEPREFIX="):
|
||||
value = item[len(b"WINEPREFIX="):].decode("utf-8", "replace")
|
||||
if os.path.realpath(value).rstrip("/") == want:
|
||||
found.append((int(pid), argv))
|
||||
break
|
||||
return found
|
||||
|
||||
|
||||
def program(argv):
|
||||
return re.split(r"[\\/]", argv[0])[-1].lower() if argv else ""
|
||||
|
||||
|
||||
def is_client(argv):
|
||||
return program(argv) == CLIENT.lower()
|
||||
|
||||
|
||||
def idle(processes):
|
||||
return all(program(argv) in IDLE for _, argv in processes)
|
||||
|
||||
|
||||
def running(pfx):
|
||||
return any(is_client(argv) for _, argv in wine_processes(pfx))
|
||||
|
||||
|
||||
def is_battlenet(argv):
|
||||
return bool(argv) and bool(CLIENT_PATH.match(argv[0].replace("/", "\\").lower()))
|
||||
|
||||
|
||||
def is_game(argv):
|
||||
if not argv or program(argv) in NOT_GAME or not re.match(r"[A-Za-z]:[\\/]", argv[0]):
|
||||
return False
|
||||
return not is_battlenet(argv)
|
||||
|
||||
|
||||
def launched(argv):
|
||||
return is_game(argv) and "-uid" in (arg.lower() for arg in argv[1:])
|
||||
|
||||
|
||||
def shares_sign_in(argv):
|
||||
return "-sso" in (arg.lower() for arg in argv[1:])
|
||||
|
||||
|
||||
def agent_up(processes):
|
||||
return any(is_client(argv) for _, argv in processes) and any(program(argv) == AGENT for _, argv in processes)
|
||||
|
||||
|
||||
class Tidy:
|
||||
|
||||
def __init__(self, settle=None, gone=None):
|
||||
self.settle = GAME_SETTLE if settle is None else settle
|
||||
self.gone = AGENT_GONE if gone is None else gone
|
||||
self.game_since = None
|
||||
self.closed_for_game = False
|
||||
self.agent_seen = False
|
||||
self.agent_lost = None
|
||||
|
||||
def __call__(self, processes, now):
|
||||
own = [(pid, argv) for pid, argv in processes if is_battlenet(argv)]
|
||||
games = [argv for _, argv in processes if launched(argv)]
|
||||
if games:
|
||||
self.game_since = self.game_since if self.game_since is not None else now
|
||||
if own and not self.closed_for_game and now - self.game_since >= self.settle:
|
||||
self.closed_for_game, self.agent_seen, self.agent_lost = True, False, None
|
||||
if any(is_client(argv) for _, argv in own) and any(shares_sign_in(argv) for argv in games):
|
||||
say("Battle.net stayed open beside a game signing in with its token: left open")
|
||||
return False
|
||||
say("the game is up: closing what is left of Battle.net (%d process(es)) to leave it their memory" % len(own))
|
||||
stop(own)
|
||||
return True
|
||||
return False
|
||||
self.game_since, self.closed_for_game = None, False
|
||||
if not any(is_client(argv) for _, argv in processes):
|
||||
self.agent_seen, self.agent_lost = False, None
|
||||
elif agent_up(processes):
|
||||
self.agent_seen, self.agent_lost = True, None
|
||||
elif self.agent_seen:
|
||||
self.agent_lost = self.agent_lost if self.agent_lost is not None else now
|
||||
if now - self.agent_lost >= self.gone:
|
||||
say("Battle.net has outlived its Agent: closing it (%d process(es))" % len(own))
|
||||
stop(own)
|
||||
notify("Battle.net was closed", "It had lost Blizzard's update service. Open it again to reconnect.",
|
||||
"dialog-warning")
|
||||
self.agent_seen, self.agent_lost = False, None
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def proton_options():
|
||||
if os.environ.get("BL_DESKTOP") == "1":
|
||||
return ["--window"]
|
||||
width, height = os.environ.get("BL_WIDTH", ""), os.environ.get("BL_HEIGHT", "")
|
||||
options = ["--desktop", "%sx%s" % (width, height)] if width.isdigit() and height.isdigit() else []
|
||||
game = os.environ.get("SteamGameId", "")
|
||||
return options + (["--game-id", game] if game.isdigit() and game != "0" else [])
|
||||
|
||||
|
||||
def stop(processes, wait=STOP_WAIT):
|
||||
pids = [pid for pid, _ in processes]
|
||||
for sig in (signal.SIGTERM, signal.SIGKILL):
|
||||
for pid in pids:
|
||||
try:
|
||||
os.kill(pid, sig)
|
||||
except OSError:
|
||||
pass
|
||||
deadline = time.monotonic() + wait
|
||||
while time.monotonic() < deadline:
|
||||
pids = [pid for pid in pids if os.path.exists("/proc/%d" % pid)]
|
||||
if not pids:
|
||||
return
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def queued_requests(launch_dir):
|
||||
try:
|
||||
names = os.listdir(launch_dir)
|
||||
except OSError:
|
||||
return []
|
||||
return sorted(name for name in names if REQUEST_FILE.fullmatch(name))
|
||||
|
||||
|
||||
def serve_requests(pfx, processes=None, launch_dir=None):
|
||||
launch_dir = launch_dir or os.environ.get("BL_LAUNCH_DIR")
|
||||
names = queued_requests(launch_dir) if launch_dir else []
|
||||
if not names or not agent_up(wine_processes(pfx) if processes is None else processes):
|
||||
return False
|
||||
client = os.path.join(pfx, "drive_c", *CLIENT_DIR, CLIENT)
|
||||
served = False
|
||||
for name in names:
|
||||
path = os.path.join(launch_dir, name)
|
||||
try:
|
||||
with open(path, encoding="utf-8") as f:
|
||||
args = [line for line in f.read().splitlines() if line]
|
||||
os.unlink(path)
|
||||
except OSError:
|
||||
continue
|
||||
if len(args) == 2 and args[0] == "install-game" and GAME_UID.fullmatch(args[1]):
|
||||
spawn(client, "run", ["--install", "--game=%s" % args[1]])
|
||||
elif len(args) == 2 and args[0] == "launch" and CODE.fullmatch(args[1]):
|
||||
spawn(client, "run", ["--exec=launch %s" % args[1]])
|
||||
else:
|
||||
say("not a request: %s" % " ".join(args))
|
||||
continue
|
||||
say("the app asked for %s" % " ".join(args))
|
||||
served = True
|
||||
return served
|
||||
|
||||
|
||||
def wait_while_open(pfx, grace, poll=None):
|
||||
deadline = time.monotonic() + grace
|
||||
seen = False
|
||||
while True:
|
||||
serve_requests(pfx)
|
||||
if running(pfx):
|
||||
seen = True
|
||||
elif seen or time.monotonic() >= deadline:
|
||||
return seen
|
||||
time.sleep(POLL if poll is None else poll)
|
||||
|
||||
|
||||
def proton(exe, args=(), verb=None, watch=None, poll=None, close_grace=None, tidy=None):
|
||||
cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID] + (["--verb", verb] if verb else []) + [exe] + list(args)
|
||||
say(" ".join(cmd))
|
||||
try:
|
||||
process = subprocess.Popen(cmd, env=proton_env())
|
||||
except OSError as error:
|
||||
say("%s: %s" % (PROTON_RUN, error))
|
||||
return 127, False
|
||||
seen = False
|
||||
closed_at = None
|
||||
grace = CLOSE_GRACE if close_grace is None else close_grace
|
||||
tidy = Tidy() if tidy is None else tidy
|
||||
while True:
|
||||
try:
|
||||
status = process.wait(timeout=POLL if poll is None else poll)
|
||||
return status, seen
|
||||
except subprocess.TimeoutExpired:
|
||||
pass
|
||||
if watch is None:
|
||||
continue
|
||||
processes = wine_processes(watch)
|
||||
serve_requests(watch, processes)
|
||||
now = time.monotonic()
|
||||
if tidy(processes, now):
|
||||
seen = True
|
||||
processes = wine_processes(watch)
|
||||
if any(is_client(argv) for _, argv in processes):
|
||||
seen, closed_at = True, None
|
||||
elif seen and idle(processes):
|
||||
closed_at = closed_at if closed_at is not None else now
|
||||
if now - closed_at >= grace:
|
||||
say("Battle.net closed; stopping %d process(es) it left in its prefix" % len(processes))
|
||||
stop(processes)
|
||||
closed_at = None
|
||||
else:
|
||||
closed_at = None
|
||||
|
||||
|
||||
def setup_ready(path):
|
||||
try:
|
||||
with open(path, "rb") as f:
|
||||
return f.read(2) == b"MZ" and os.path.getsize(path) >= MIN_INSTALLER
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
|
||||
def download(url=INSTALLER_URL, folder=CACHE):
|
||||
os.makedirs(folder, exist_ok=True)
|
||||
dest = os.path.join(folder, SETUP)
|
||||
if setup_ready(dest):
|
||||
return dest
|
||||
part = dest + ".part"
|
||||
try:
|
||||
try:
|
||||
request = urllib.request.Request(url, headers={"User-Agent": "DroidDeck"})
|
||||
with urllib.request.urlopen(request, timeout=60) as response, open(part, "wb") as f:
|
||||
shutil.copyfileobj(response, f)
|
||||
length = response.headers.get("Content-Length", "")
|
||||
if length.isdigit() and f.tell() != int(length):
|
||||
raise OSError("the download ended early")
|
||||
except (OSError, http.client.HTTPException) as error:
|
||||
if not shutil.which("curl"):
|
||||
raise
|
||||
say("download through Python failed (%s); trying curl" % error)
|
||||
if subprocess.call(["curl", "-fsSL", "--max-time", "300", "-o", part, url]) != 0:
|
||||
raise OSError("curl could not download it")
|
||||
if not setup_ready(part):
|
||||
raise OSError("not a Windows program")
|
||||
os.replace(part, dest)
|
||||
except (OSError, http.client.HTTPException) as error:
|
||||
say("installer download failed: %s" % error)
|
||||
try:
|
||||
os.unlink(part)
|
||||
except OSError:
|
||||
pass
|
||||
return dest if os.path.isfile(dest) else None
|
||||
|
||||
|
||||
def install(root, pfx, verb=None):
|
||||
setup = download()
|
||||
if setup is None:
|
||||
notify("Battle.net could not be downloaded", "Check the connection and try again.", "dialog-error")
|
||||
return False, False
|
||||
configure(root, LIBRARY)
|
||||
notify("Installing Battle.net", "Blizzard's installer opens in a window. It can take a few minutes.")
|
||||
_, seen = proton(setup, verb=verb, watch=pfx)
|
||||
return installed(root), seen
|
||||
|
||||
|
||||
def acquire(folder=CACHE):
|
||||
os.makedirs(folder, exist_ok=True)
|
||||
handle = open(os.path.join(folder, "battlenet.lock"), "w")
|
||||
try:
|
||||
fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except OSError:
|
||||
handle.close()
|
||||
return None
|
||||
return handle
|
||||
|
||||
|
||||
def status(root):
|
||||
pfx = os.path.join(prefix(root), "pfx")
|
||||
return {"appid": int(APP_ID), "prefix": prefix(root), "installed": installed(root),
|
||||
"launcher": launcher(root), "running": running(pfx)}
|
||||
|
||||
|
||||
def spawn(program, verb, args=()):
|
||||
cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID, "--verb", verb, program] + list(args)
|
||||
say(" ".join(cmd))
|
||||
try:
|
||||
os.makedirs(CACHE, exist_ok=True)
|
||||
with open(os.path.join(CACHE, "spawned.log"), "ab") as log:
|
||||
child = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True, env=proton_env())
|
||||
threading.Thread(target=child.wait, daemon=True).start()
|
||||
except OSError as error:
|
||||
say("%s: %s" % (PROTON_RUN, error))
|
||||
return 127
|
||||
return 0
|
||||
|
||||
|
||||
def show(root, wait=None, poll=None, args=()):
|
||||
pfx = os.path.join(prefix(root), "pfx")
|
||||
client = os.path.join(client_dir(root), CLIENT)
|
||||
deadline = time.monotonic() + (HANDOFF_WAIT if wait is None else wait)
|
||||
while True:
|
||||
processes = wine_processes(pfx)
|
||||
if any(is_client(argv) for _, argv in processes) and os.path.isfile(client) \
|
||||
and (agent_up(processes) or time.monotonic() >= deadline):
|
||||
spawn(client, "run", args)
|
||||
return None
|
||||
lock = acquire()
|
||||
if lock is not None:
|
||||
say("the other start has ended; opening Battle.net")
|
||||
return lock
|
||||
if time.monotonic() >= deadline:
|
||||
say("the other start neither opened Battle.net nor ended")
|
||||
notify("Battle.net is busy", "Another start is still running; try again in a moment.", "dialog-warning")
|
||||
return None
|
||||
time.sleep(POLL if poll is None else poll)
|
||||
|
||||
|
||||
def stop_leftovers(pfx):
|
||||
processes = wine_processes(pfx)
|
||||
if not processes:
|
||||
return True
|
||||
if not idle(processes):
|
||||
say("the prefix is in use (%s); Battle.net starts beside it" % ", ".join(sorted({program(a) for _, a in processes} - IDLE)))
|
||||
return False
|
||||
say("stopping %d process(es) a closed Battle.net left in its prefix" % len(processes))
|
||||
stop(processes)
|
||||
return True
|
||||
|
||||
|
||||
def open_client(root, reinstall=False):
|
||||
pfx = os.path.join(prefix(root), "pfx")
|
||||
write_menu()
|
||||
answer = ask_fex(os.environ.get("BL_LAUNCH_DIR"))
|
||||
say("FEX: %s" % (answer or "no answer from the app; Components' choice stays"))
|
||||
if running(pfx):
|
||||
say("Battle.net is already running in its prefix; waiting for it to close")
|
||||
wait_while_open(pfx, grace=0)
|
||||
return 0
|
||||
verb = None if stop_leftovers(pfx) else "run"
|
||||
if reinstall or not installed(root):
|
||||
done, seen = install(root, pfx, verb)
|
||||
if not done:
|
||||
notify("Battle.net did not install", "The session's desktop.log says why.", "dialog-error")
|
||||
return 1
|
||||
if wait_while_open(pfx, grace=0 if seen else START_GRACE) or seen:
|
||||
return 0
|
||||
verb = None if stop_leftovers(pfx) else "run"
|
||||
configure(root, LIBRARY)
|
||||
status_code, seen = proton(launcher(root), verb=verb, watch=pfx)
|
||||
say("Proton returned %d; Battle.net %s" % (status_code, "ran" if seen else "has not been seen yet"))
|
||||
if not (wait_while_open(pfx, grace=0 if seen else START_GRACE) or seen):
|
||||
say("Battle.net did not start (the launcher exited with %d)" % status_code)
|
||||
notify("Battle.net did not start", "The session's desktop.log says why.", "dialog-error")
|
||||
return status_code or 1
|
||||
say("Battle.net closed")
|
||||
return 0
|
||||
|
||||
|
||||
def start(exe, verb=None):
|
||||
cmd = [PROTON_RUN] + proton_options() + ["--prefix", APP_ID] + (["--verb", verb] if verb else []) + [exe]
|
||||
say(" ".join(cmd))
|
||||
try:
|
||||
return subprocess.Popen(cmd, env=proton_env())
|
||||
except OSError as error:
|
||||
say("%s: %s" % (PROTON_RUN, error))
|
||||
return None
|
||||
|
||||
|
||||
def wait_ready(pfx, wait=None, poll=None, settle=None):
|
||||
deadline = time.monotonic() + (CLIENT_WAIT if wait is None else wait)
|
||||
while True:
|
||||
count = sum(1 for _, argv in wine_processes(pfx) if is_client(argv))
|
||||
if count >= CLIENT_READY:
|
||||
time.sleep(READY_SETTLE if settle is None else settle)
|
||||
return True
|
||||
if time.monotonic() >= deadline:
|
||||
return count > 0
|
||||
time.sleep(POLL if poll is None else poll)
|
||||
|
||||
|
||||
def follow(pfx, poll=None, grace=None, tidy=None, ask=None):
|
||||
seen, gone_at = False, None
|
||||
asked, asks = None, 1
|
||||
grace = GAME_GRACE if grace is None else grace
|
||||
tidy = Tidy() if tidy is None else tidy
|
||||
while True:
|
||||
processes = wine_processes(pfx)
|
||||
serve_requests(pfx, processes)
|
||||
now = time.monotonic()
|
||||
if tidy(processes, now):
|
||||
processes = wine_processes(pfx)
|
||||
games = sorted({program(argv) for _, argv in processes if is_game(argv)})
|
||||
if games:
|
||||
if not seen:
|
||||
say("game running: %s" % ", ".join(games))
|
||||
seen, gone_at = True, None
|
||||
elif seen or not any(is_client(argv) for _, argv in processes):
|
||||
gone_at = gone_at if gone_at is not None else now
|
||||
if now - gone_at >= grace:
|
||||
say("the game has exited" if seen else "Battle.net closed before a game started")
|
||||
return seen
|
||||
else:
|
||||
gone_at = None
|
||||
asked = now if asked is None else asked
|
||||
if ask is not None and asks < LAUNCH_ASKS and now - asked >= LAUNCH_WAIT:
|
||||
say("Battle.net has not started the game yet; asking again")
|
||||
ask()
|
||||
asked, asks = now, asks + 1
|
||||
time.sleep(POLL if poll is None else poll)
|
||||
|
||||
|
||||
def launch(root, code):
|
||||
pfx = os.path.join(prefix(root), "pfx")
|
||||
client = os.path.join(client_dir(root), CLIENT)
|
||||
if not installed(root) or not os.path.isfile(client):
|
||||
say("Battle.net is not installed; %s is not launched" % code)
|
||||
notify("Battle.net is not installed", "Install it from its tile on DroidDeck's Desktop tab.", "dialog-error")
|
||||
return 1
|
||||
lock = acquire()
|
||||
try:
|
||||
own = None
|
||||
if lock is not None and not running(pfx):
|
||||
answer = ask_fex(os.environ.get("BL_LAUNCH_DIR"))
|
||||
say("FEX: %s" % (answer or "no answer from the app; Components' choice stays"))
|
||||
verb = None if stop_leftovers(pfx) else "run"
|
||||
configure(root, LIBRARY)
|
||||
own = start(launcher(root), verb)
|
||||
if own is None:
|
||||
return 127
|
||||
if not wait_ready(pfx):
|
||||
say("Battle.net did not open; %s is not launched" % code)
|
||||
notify("Battle.net did not start", "The session's desktop.log says why.", "dialog-error")
|
||||
return 1
|
||||
if code.lower().startswith("wow"):
|
||||
wow_settings(root)
|
||||
say("launching %s" % code)
|
||||
spawn(client, "run", ["--exec=launch %s" % code])
|
||||
played = follow(pfx, ask=lambda: spawn(client, "run", ["--exec=launch %s" % code]))
|
||||
if own is not None:
|
||||
leftovers = wine_processes(pfx)
|
||||
say("stopping what the Battle.net opened for %s left: %d process(es)" % (code, len(leftovers)))
|
||||
stop(leftovers)
|
||||
try:
|
||||
own.wait(timeout=STOP_WAIT * 4)
|
||||
except subprocess.TimeoutExpired:
|
||||
say("its Proton is still ending")
|
||||
return 0 if played else 1
|
||||
finally:
|
||||
if lock is not None:
|
||||
lock.close()
|
||||
|
||||
|
||||
def hand_over(root, args, wait=None):
|
||||
if not wait_ready(os.path.join(prefix(root), "pfx"), wait=HANDOVER_WAIT if wait is None else wait):
|
||||
say("Battle.net did not come up; %s not asked for" % " ".join(args))
|
||||
return False
|
||||
spawn(os.path.join(client_dir(root), CLIENT), "run", args)
|
||||
return True
|
||||
|
||||
|
||||
def install_game(root, uid):
|
||||
args = ["--install", "--game=%s" % uid]
|
||||
if installed(root) and agent_up(wine_processes(os.path.join(prefix(root), "pfx"))):
|
||||
say("asking the open Battle.net to install %s" % uid)
|
||||
spawn(os.path.join(client_dir(root), CLIENT), "run", args)
|
||||
return 0
|
||||
lock = acquire()
|
||||
if lock is None:
|
||||
say("another start holds the lock")
|
||||
lock = show(root, args=args)
|
||||
if lock is None:
|
||||
return 0
|
||||
threading.Thread(target=hand_over, args=(root, args), daemon=True).start()
|
||||
with lock:
|
||||
return open_client(root)
|
||||
|
||||
|
||||
def main(argv):
|
||||
global LIBRARY
|
||||
argv = list(argv)
|
||||
if len(argv) >= 2 and argv[0] == "--library":
|
||||
if not argv[1].startswith("/") or "\n" in argv[1]:
|
||||
say("%s is not a folder" % argv[1])
|
||||
return 2
|
||||
LIBRARY = os.path.normpath(argv[1])
|
||||
argv = argv[2:]
|
||||
action = argv[0] if argv else "open"
|
||||
launching = action == "launch" and len(argv) == 2 and CODE.fullmatch(argv[1])
|
||||
getting = action == "install-game" and len(argv) == 2 and GAME_UID.fullmatch(argv[1])
|
||||
if not (launching or getting) and (action not in ("open", "install", "status") or len(argv) > 1):
|
||||
say("usage: droiddeck-battlenet [--library DIR] [open | install | status | launch CODE | install-game ID]")
|
||||
return 2
|
||||
root = steam_root()
|
||||
if action == "status":
|
||||
print(json.dumps(status(root)))
|
||||
return 0
|
||||
os.environ["BL_BATTLENET"] = "1"
|
||||
if launching:
|
||||
say("launch %s" % argv[1])
|
||||
return launch(root, argv[1])
|
||||
if getting:
|
||||
say("install-game %s" % argv[1])
|
||||
return install_game(root, argv[1])
|
||||
say("%s (%s)" % (action, "from the menu" if not sys.stderr.isatty() else "from a terminal"))
|
||||
lock = acquire()
|
||||
if lock is None:
|
||||
say("another start holds the lock")
|
||||
lock = show(root)
|
||||
if lock is None:
|
||||
return 0
|
||||
with lock:
|
||||
return open_client(root, reinstall=action == "install")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -8,7 +8,7 @@ X64 = os.environ.get("BL_STEAM_CLIENT_ARCH") == "x86_64"
|
||||
CLIENT_HOME = (os.environ.get("BL_X64_HOME") or os.path.join(HOME, ".droiddeck-x64")) if X64 else HOME
|
||||
STEAM_ROOT = sys.argv[1] if len(sys.argv) > 1 else os.path.join(CLIENT_HOME, ".local/share/Steam")
|
||||
LIBRARIES = ((STEAM_ROOT, "Steam Games"), ("/mnt/droiddeck-sd/x86-64" if X64 else "/mnt/droiddeck-sd", "SD Games"))
|
||||
NOT_GAMES = {228980, 1070560, 1391110, 1493710, 1628350, 3127680, 4183110, 4185400, 4427310, 4628740}
|
||||
NOT_GAMES = {228980, 1070560, 1161040, 1391110, 1493710, 1628350, 1826330, 3127680, 4183110, 4185400, 4427310, 4628740}
|
||||
APPS_DIR = os.path.join(HOME, ".local/share/applications")
|
||||
PREFIX = "droiddeck-game-"
|
||||
NAME = re.compile(r'^\s*"name"\s*"([^"]*)"', re.M)
|
||||
|
||||
@@ -589,7 +589,8 @@ def guest_environment(fex, env):
|
||||
result["FEX_THUNKHOSTLIBS"] = fex["host_thunks"]
|
||||
result["FEX_THUNKGUESTLIBS"] = fex["guest_thunks"]
|
||||
result["FEX_THUNKCONFIG"] = os.path.join(CONFIG_DIR, "ThunksConfig.json")
|
||||
preload = [part for part in split_paths(result.get("LD_PRELOAD")) if os.path.exists(part) and not is_arm(part)]
|
||||
preload = [part for part in split_paths(result.get("LD_PRELOAD"))
|
||||
if "/" not in part or (os.path.exists(part) and not is_arm(part))]
|
||||
library_path = [part for part in (result.get("LD_LIBRARY_PATH") or "").split(":")
|
||||
if part and "arm64" not in part and "aarch64" not in part]
|
||||
for name, parts in (("LD_PRELOAD", preload), ("LD_LIBRARY_PATH", library_path)):
|
||||
@@ -671,15 +672,26 @@ def launch(command, env, mode, decide=None):
|
||||
return os.execve(fex["bin"], [fex["bin"], program] + command[1:], guest)
|
||||
|
||||
|
||||
def game_environment(env):
|
||||
def game_environment(env, command):
|
||||
try:
|
||||
game_env = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-env"))
|
||||
env = game_env["game_gpu"](env)
|
||||
app = game_env["game_id"](env) or env.get("SteamAppId") or env.get("SteamGameId")
|
||||
if not app:
|
||||
return env
|
||||
with open(GAME_ENVIRONMENT, encoding="utf-8") as source:
|
||||
return game_env["apply_config"](env, json.load(source), str(app))
|
||||
fixes = {}
|
||||
game = game_env["Game"](resolve(command[0], env), command[1:])
|
||||
for check in game_env["FIXES"]:
|
||||
found = check(game)
|
||||
if found and found[0]:
|
||||
fixes.update(found[0])
|
||||
say(found[2])
|
||||
try:
|
||||
with open(GAME_ENVIRONMENT, encoding="utf-8") as source:
|
||||
config = json.load(source)
|
||||
except FileNotFoundError:
|
||||
config = {"version": 1}
|
||||
return game_env["apply_config"](env, config, str(app), fixes)
|
||||
except FileNotFoundError:
|
||||
return env
|
||||
except Exception as error:
|
||||
@@ -810,7 +822,7 @@ def main(argv):
|
||||
return 0
|
||||
if not command:
|
||||
return 2
|
||||
return launch(command, game_environment(dict(os.environ)), os.environ.get("DROIDDECK_FEX", "auto"))
|
||||
return launch(command, game_environment(dict(os.environ), command), os.environ.get("DROIDDECK_FEX", "auto"))
|
||||
if action == "run":
|
||||
try:
|
||||
mode, decide, command = parse_run(args)
|
||||
|
||||
@@ -3,6 +3,7 @@ set -u
|
||||
export LANG=C.UTF-8
|
||||
step() { echo "== STEP $*"; }
|
||||
fail() { echo "== FAIL $*"; exit 1; }
|
||||
[ "$(id -u)" = 0 ] || fail "needs root: install Flatpak from the launcher's Store, which runs this as root"
|
||||
|
||||
PACKAGES="flatpak ostree appstream libxmlb libmalcontent libfyaml accountsservice composefs xdg-dbus-proxy"
|
||||
while read -r pkg probe; do
|
||||
@@ -48,10 +49,13 @@ if [ ! -f /etc/pacman.d/gnupg/pubring.gpg ] && [ ! -f /etc/pacman.d/gnupg/pubrin
|
||||
fi
|
||||
|
||||
step "Reading the package lists"
|
||||
pacman --config "$CONF" --dbpath "$WORK/db" --noconfirm -Sy >/dev/null 2>&1 \
|
||||
|| pacman --config "$CONF" --dbpath "$WORK/db" --noconfirm -Sy 2>&1 | tail -3 \
|
||||
|| fail "could not reach the Arch Linux ARM mirrors"
|
||||
[ -f "$WORK/db/sync/extra.db" ] || fail "could not reach the Arch Linux ARM mirrors"
|
||||
sync_log=$(pacman --config "$CONF" --dbpath "$WORK/db" --noconfirm -Sy 2>&1) \
|
||||
|| sync_log=$(pacman --config "$CONF" --dbpath "$WORK/db" --noconfirm -Sy 2>&1)
|
||||
if [ ! -f "$WORK/db/sync/extra.db" ]; then
|
||||
printf '%s\n' "$sync_log" | tail -3
|
||||
reason=$(printf '%s\n' "$sync_log" | grep -m1 -i '^error' | cut -c1-160)
|
||||
fail "could not reach the Arch Linux ARM mirrors${reason:+ ($reason)}"
|
||||
fi
|
||||
|
||||
step "Downloading Flatpak"
|
||||
out=$(pacman --config "$CONF" --dbpath "$WORK/db" --cachedir "$WORK/pkg" --noconfirm -Sw -dd $PACKAGES 2>&1)
|
||||
|
||||
@@ -6,6 +6,7 @@ import re
|
||||
import runpy
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
GAME_TU_DEBUG = "DROIDDECK_GAME_TU_DEBUG"
|
||||
@@ -87,6 +88,12 @@ def dotnet_memory_ordering(game):
|
||||
return DOTNET_FEX, [], ".NET runtime: FEX with full TSO and without multiblock"
|
||||
|
||||
|
||||
@fix
|
||||
def unity_memory_ordering(game):
|
||||
if {"unityplayer.so", "gameassembly.so", "unityplayer.dll"} & game.files:
|
||||
return {"FEX_TSOENABLED": "1"}, [], "Unity: FEX with TSO"
|
||||
|
||||
|
||||
@fix
|
||||
def godot_vulkan(game):
|
||||
if is_godot(game) and not game.has_arg("--rendering-driver"):
|
||||
@@ -114,6 +121,35 @@ def arkham_city_x87(game):
|
||||
return {"FEX_X87REDUCEDPRECISION": "0"}, [], "Batman: Arkham City: FEX with full x87 precision"
|
||||
|
||||
|
||||
|
||||
@fix
|
||||
def protonfixes_off(game):
|
||||
if game.stem in ("blackops3", "darksoulsremastered"):
|
||||
return {"PROTONFIXES_DISABLE": "1"}, [], "umu-protonfixes off (its ALSA audio and VC++ installer steps fail here)"
|
||||
|
||||
|
||||
@fix
|
||||
def caravan_sandwitch_feature_level(game):
|
||||
if "caravansandwitch.exe" in game.files or game.stem == "caravansandwitch-win64-shipping":
|
||||
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "Caravan SandWitch: D3D12 feature level 12_1 (12_2 hands it mesh shader pipelines vkd3d-proton cannot build)"
|
||||
|
||||
|
||||
@fix
|
||||
def robocop_rogue_city_feature_level(game):
|
||||
"""vkd3d-proton turns mesh shaders off on Adreno, but 12_2 still advertises them, and UE5 then builds mesh
|
||||
pipelines with no pipeline layout that crash Turnip on launch."""
|
||||
if "robocop.exe" in game.files or game.stem == "robocop-win64-shipping":
|
||||
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "RoboCop: Rogue City: D3D12 feature level 12_1"
|
||||
|
||||
|
||||
@fix
|
||||
def cyberpunk_feature_level(game):
|
||||
if game.stem == "cyberpunk2077" or (
|
||||
game.stem == "redprelauncher"
|
||||
and os.path.isfile(os.path.join(os.path.dirname(game.exe), "bin", "x64", "Cyberpunk2077.exe"))
|
||||
):
|
||||
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "Cyberpunk 2077: D3D12 feature level 12_1"
|
||||
|
||||
def skip_red_launcher(command):
|
||||
"""Cyberpunk 2077's prelauncher opens REDlauncher, a Qt WebEngine window that hands over to the
|
||||
game half a minute later and then stays up beside it, well over a core busy for as long as the
|
||||
@@ -127,6 +163,61 @@ def skip_red_launcher(command):
|
||||
return command
|
||||
|
||||
|
||||
UBISOFT_LAUNCHER = "drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher"
|
||||
UBISOFT_SETTINGS = "drive_c/users/steamuser/AppData/Local/Ubisoft Game Launcher/settings.yaml"
|
||||
|
||||
|
||||
def overlay_off(text):
|
||||
lines = text.splitlines()
|
||||
try:
|
||||
start = next(i for i, line in enumerate(lines) if re.fullmatch(r"overlay:\s*(#.*)?", line))
|
||||
except StopIteration:
|
||||
if lines and not lines[-1].strip():
|
||||
lines.pop()
|
||||
return "\n".join(lines + ["overlay:", " enabled: false", " warning_enabled: false"]) + "\n"
|
||||
end = start + 1
|
||||
for index in range(start + 1, len(lines)):
|
||||
if lines[index].strip() and not lines[index].startswith(" "):
|
||||
break
|
||||
if lines[index].strip():
|
||||
end = index + 1
|
||||
block = lines[start + 1:end]
|
||||
for key in ("enabled", "warning_enabled"):
|
||||
entry = " %s: false" % key
|
||||
found = [i for i, line in enumerate(block) if line.split(":", 1)[0] == " " + key]
|
||||
if found:
|
||||
block[found[0]] = entry
|
||||
else:
|
||||
block.append(entry)
|
||||
return "\n".join(lines[:start + 1] + block + lines[end:]) + "\n"
|
||||
|
||||
|
||||
def ubisoft_overlay_off(env):
|
||||
prefix = Path(env.get("STEAM_COMPAT_DATA_PATH", "/nonexistent")) / "pfx"
|
||||
if not (prefix / UBISOFT_LAUNCHER).is_dir():
|
||||
return
|
||||
settings = prefix / UBISOFT_SETTINGS
|
||||
try:
|
||||
text = settings.read_text(encoding="utf-8") if settings.exists() else ""
|
||||
updated = overlay_off(text)
|
||||
if updated == text:
|
||||
return
|
||||
settings.parent.mkdir(parents=True, exist_ok=True)
|
||||
handle, staged = tempfile.mkstemp(prefix=".settings-", dir=settings.parent)
|
||||
try:
|
||||
with os.fdopen(handle, "w", encoding="utf-8") as target:
|
||||
target.write(updated)
|
||||
if settings.exists():
|
||||
os.chmod(staged, settings.stat().st_mode & 0o7777)
|
||||
os.replace(staged, settings)
|
||||
except BaseException:
|
||||
os.unlink(staged)
|
||||
raise
|
||||
print("droiddeck-game-env: Ubisoft Connect overlay turned off", file=sys.stderr)
|
||||
except (OSError, UnicodeDecodeError) as error:
|
||||
print("droiddeck-game-env: Ubisoft Connect overlay left as is (%s)" % error, file=sys.stderr)
|
||||
|
||||
|
||||
def offline_without_anticheat(command, env):
|
||||
"""Start the configured game executable when the player opts into launching without EAC."""
|
||||
if (env.get("DROIDDECK_ANTICHEAT_OFFLINE") != "1" or len(command) <= 2
|
||||
@@ -196,6 +287,58 @@ def game_gpu(env):
|
||||
return result
|
||||
|
||||
|
||||
def vram_cap(env):
|
||||
"""Puts the session's VRAM cap ahead of the game's own DXVK settings, so a game profile can still raise it."""
|
||||
value = env.get("BL_VRAM_MB", "")
|
||||
if not re.fullmatch(r"[1-9][0-9]{0,6}", value):
|
||||
return env
|
||||
result = env.copy()
|
||||
cap = "dxgi.maxDeviceMemory = %d" % int(value)
|
||||
own = result.get("DXVK_CONFIG", "").strip().strip(";").strip()
|
||||
result["DXVK_CONFIG"] = cap + "; " + own if own else cap
|
||||
return result
|
||||
|
||||
|
||||
def parse_cores(text):
|
||||
"""CPU numbers from a list such as "0-3,6"; None when the text is not one."""
|
||||
cores = set()
|
||||
for part in text.replace(" ", "").split(","):
|
||||
match = re.fullmatch(r"(\d{1,3})(?:-(\d{1,3}))?", part)
|
||||
if not match:
|
||||
return None
|
||||
first, last = int(match.group(1)), int(match.group(2) or match.group(1))
|
||||
if last < first:
|
||||
return None
|
||||
cores.update(range(first, last + 1))
|
||||
return cores or None
|
||||
|
||||
|
||||
def online_cores():
|
||||
try:
|
||||
with open("/sys/devices/system/cpu/online") as f:
|
||||
cores = parse_cores(f.read().strip())
|
||||
except OSError:
|
||||
cores = None
|
||||
return cores or os.sched_getaffinity(0) | set(range(os.cpu_count() or 0))
|
||||
|
||||
|
||||
def game_cores(env):
|
||||
"""Pins the game to the cores its profile names, in place of the session's game cores."""
|
||||
text = env.get("DROIDDECK_GAME_CORES", "").strip()
|
||||
if not text:
|
||||
return
|
||||
cores = parse_cores(text)
|
||||
chosen = cores & online_cores() if cores else None
|
||||
if not chosen:
|
||||
print("droiddeck-game-env: ignoring game cores %r" % text, file=sys.stderr)
|
||||
return
|
||||
try:
|
||||
os.sched_setaffinity(0, chosen)
|
||||
print("droiddeck-game-env: game cores %s" % ",".join(map(str, sorted(chosen))), file=sys.stderr)
|
||||
except OSError as error:
|
||||
print("droiddeck-game-env: could not use game cores %r (%s)" % (text, error), file=sys.stderr)
|
||||
|
||||
|
||||
def apply_config(env, config, app_id, fixes=None):
|
||||
if config.get("version") != 1:
|
||||
raise ValueError("unsupported environment configuration")
|
||||
@@ -497,6 +640,7 @@ def main():
|
||||
fixes = {}
|
||||
if waiting:
|
||||
command = skip_red_launcher(command)
|
||||
ubisoft_overlay_off(env)
|
||||
fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], [])
|
||||
for note in notes:
|
||||
print("droiddeck-game-env: " + note, file=sys.stderr)
|
||||
@@ -528,7 +672,9 @@ def main():
|
||||
command = offline_without_anticheat(command, env)
|
||||
if mic_enabled == "0":
|
||||
env["BANNER_AUDIO_DIRECT_MIC"] = "0"
|
||||
env = vram_cap(env)
|
||||
env = force_ssbs(command, env)
|
||||
game_cores(env)
|
||||
try:
|
||||
xbox = runpy.run_path(str(Path(__file__).with_name("droiddeck-xbox")))
|
||||
except Exception as error:
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/python3
|
||||
"""Runs a Windows program with the Proton the Steam client has chosen for it.
|
||||
|
||||
droiddeck-proton-run [--window] PROGRAM [ARGS...]
|
||||
droiddeck-proton-run [--window] [--prefix ID] [--verb run] [--game-id ID] [--desktop WxH] PROGRAM [ARGS...]
|
||||
droiddeck-proton-run --app ID [--dir FOLDER] [--options TEXT] [PROGRAM [ARGS...]]
|
||||
|
||||
The program belongs to an installed Steam game when it sits in one's folder, to a prefix when it
|
||||
@@ -10,10 +10,15 @@ its own, under the id the client gives a new shortcut. That title's CompatToolMa
|
||||
config.vdf picks the tool, else the client's default for all other titles ("0"). The tool is
|
||||
started as the client starts it - its toolmanifest's command line, the waitforexitandrun verb and
|
||||
the STEAM_COMPAT_* environment - so its wrapper applies the game's settings, components and audio.
|
||||
--window keeps the program in the desktop's own window, drawn with WineD3D.
|
||||
--window keeps the program in the desktop's own window, drawn with WineD3D on the desktop's software
|
||||
GL (llvmpipe): KWin there composites in software, and the session's zink finds no device.
|
||||
--prefix ID puts the program in compatdata/ID whatever it is. --verb run starts it beside what already
|
||||
runs in the prefix, which waitforexitandrun would wait for; the wrapper's launch-time steps are skipped.
|
||||
--game-id ID keeps the id of the launch it runs for: gamescope shows the windows that carry the id Steam launched.
|
||||
--app starts one game without the Steam client (its Start without Steam): a Steam game's default
|
||||
Windows launch option from appinfo.vdf when no program is given, else the program in that
|
||||
shortcut's own prefix, started in --dir with the shortcut's launch options (--options).
|
||||
shortcut's own prefix, started in --dir with the shortcut's launch options (--options). Without
|
||||
--options it takes the launch options set in the client's Properties for that game or shortcut.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
@@ -30,7 +35,10 @@ BIN_DIR = os.path.dirname(os.path.abspath(__file__))
|
||||
STATE = os.path.join(HOME, ".local", "share", "droiddeck-compat", "state.json")
|
||||
EXTRA_LIBRARIES = ("/mnt/droiddeck", "/mnt/droiddeck-sd")
|
||||
SYSTEM_TOOLS = ("/usr/share/steam/compatibilitytools.d", "/usr/local/share/steam/compatibilitytools.d")
|
||||
DESKTOP_GL = {"LIBGL_ALWAYS_SOFTWARE": "1", "GALLIUM_DRIVER": "llvmpipe"}
|
||||
NOT_DESKTOP_GL = ("MESA_LOADER_DRIVER_OVERRIDE", "LIBGL_KOPPER_DRI2")
|
||||
VERB = "waitforexitandrun"
|
||||
VERBS = (VERB, "run")
|
||||
SHORTCUT_BIT = 0x80000000
|
||||
STEAM_APP_LIMIT = 2 ** 31
|
||||
|
||||
@@ -185,9 +193,9 @@ def steam_game(program, libs):
|
||||
def prefix_of(program):
|
||||
for folder, below in ancestors(program):
|
||||
parent = os.path.dirname(folder)
|
||||
if below == "pfx" and os.path.basename(parent) == "compatdata" and os.path.basename(folder).isdigit():
|
||||
if below == "pfx" and os.path.basename(parent) == "compatdata" and re.fullmatch(r"-?[0-9]+", os.path.basename(folder)):
|
||||
library = os.path.dirname(os.path.dirname(parent))
|
||||
return Target(os.path.basename(folder), folder, os.path.dirname(program), library, "prefix")
|
||||
return Target(str(int(os.path.basename(folder)) % 2 ** 32), folder, os.path.dirname(program), library, "prefix")
|
||||
return None
|
||||
|
||||
|
||||
@@ -230,10 +238,68 @@ def shortcut_entries(root):
|
||||
return entries
|
||||
|
||||
|
||||
def prefix_folder(root, appid):
|
||||
"""The prefix folder the client made for [appid], under either spelling of the id."""
|
||||
folder = os.path.join(root, "steamapps", "compatdata")
|
||||
try:
|
||||
names = sorted(os.listdir(folder))
|
||||
except OSError:
|
||||
names = []
|
||||
candidates = []
|
||||
for name in names:
|
||||
if not re.fullmatch(r"-?[0-9]+", name):
|
||||
continue
|
||||
try:
|
||||
matches = int(name) % 2 ** 32 == appid % 2 ** 32
|
||||
except ValueError:
|
||||
continue
|
||||
match = os.path.join(folder, name)
|
||||
if matches and os.path.isdir(match):
|
||||
candidates.append((os.path.isdir(os.path.join(match, "pfx")),
|
||||
name == str(appid % 2 ** 32), name, match))
|
||||
if candidates:
|
||||
return min(candidates, key=lambda item: (not item[0], not item[1], item[2]))[3]
|
||||
return os.path.join(folder, str(appid % 2 ** 32))
|
||||
|
||||
|
||||
def vdf_string(token):
|
||||
return re.sub(r'\\(.)', r'\1', token[1:-1]) if token.startswith('"') else ""
|
||||
|
||||
|
||||
def steam_options(app, root):
|
||||
"""The launch options the client keeps for a game (localconfig.vdf) or a shortcut (shortcuts.vdf)."""
|
||||
try:
|
||||
tool = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-steam-shortcuts"))
|
||||
account = tool["account_dir"](root)
|
||||
if not account:
|
||||
return ""
|
||||
if int(app) >= STEAM_APP_LIMIT:
|
||||
with open(os.path.join(account, "config", "shortcuts.vdf"), "rb") as f:
|
||||
shortcuts = tool["parse"](f.read()).get("shortcuts", {})
|
||||
for value in shortcuts.values():
|
||||
if isinstance(value, dict) and (value.get("appid", value.get("AppId")) or 0) & 0xFFFFFFFF == int(app):
|
||||
options = value.get("LaunchOptions", value.get("launchoptions", ""))
|
||||
return options if isinstance(options, str) else ""
|
||||
return ""
|
||||
tokens = compat()["tokenize"](read_text(os.path.join(account, "config", "localconfig.vdf")) or "")
|
||||
start = compat()["find_block"](tokens, ["UserLocalConfigStore", "Software", "Valve", "Steam", "apps", app])
|
||||
if start is None:
|
||||
return ""
|
||||
end, depth = compat()["block_end"](tokens, start), 0
|
||||
for i in range(start + 1, end):
|
||||
if tokens[i] in ("{", "}"):
|
||||
depth += 1 if tokens[i] == "{" else -1
|
||||
elif depth == 0 and tokens[i].lower() == '"launchoptions"' and i + 1 < end:
|
||||
return vdf_string(tokens[i + 1])
|
||||
except (OSError, ValueError, IndexError, KeyError, TypeError, AttributeError, struct.error):
|
||||
pass
|
||||
return ""
|
||||
|
||||
|
||||
def shortcut(program, root):
|
||||
for appid, exe, start in shortcut_entries(root):
|
||||
if same_file(program, exe):
|
||||
return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)),
|
||||
return Target(appid, prefix_folder(root, appid),
|
||||
os.path.dirname(program), root, "shortcut", start if os.path.isdir(start) else None)
|
||||
return None
|
||||
|
||||
@@ -250,10 +316,19 @@ def locate(program, root):
|
||||
if found:
|
||||
return found
|
||||
appid = own_id(program)
|
||||
return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)),
|
||||
return Target(appid, prefix_folder(root, appid),
|
||||
os.path.dirname(program), root, "own")
|
||||
|
||||
|
||||
def fixed(program, root, appid):
|
||||
return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)),
|
||||
os.path.dirname(program), root, "fixed")
|
||||
|
||||
|
||||
def prefix_id(value):
|
||||
return value if value.isdigit() and not value.startswith("0") and int(value) <= 0xFFFFFFFF else None
|
||||
|
||||
|
||||
def split_words(text):
|
||||
try:
|
||||
return shlex.split(text or "")
|
||||
@@ -325,7 +400,8 @@ def steam_launch(appid, root):
|
||||
|
||||
|
||||
def shortcut_target(appid, program, start, root):
|
||||
return Target(appid, os.path.join(root, "steamapps", "compatdata", str(appid)), os.path.dirname(program), root,
|
||||
appid = int(appid) % 2 ** 32
|
||||
return Target(str(appid), prefix_folder(root, appid), os.path.dirname(program), root,
|
||||
"shortcut", start if start and os.path.isdir(start) else None)
|
||||
|
||||
|
||||
@@ -337,7 +413,7 @@ def steam_launches(target, program, root):
|
||||
return os.path.relpath(program, target.install).replace(os.sep, "/").lower() in entry.get("launch", ())
|
||||
|
||||
|
||||
def environment(env, target, tool_folder, root, window=False):
|
||||
def environment(env, target, tool_folder, root, window=False, game_id=None):
|
||||
env = dict(env)
|
||||
steamapps = [os.path.join(lib, "steamapps") for lib in libraries(root)]
|
||||
env.update({
|
||||
@@ -355,28 +431,52 @@ def environment(env, target, tool_folder, root, window=False):
|
||||
else:
|
||||
game = str(number << 32 | 0x02000000)
|
||||
env.update(SteamAppId="0", STEAM_COMPAT_APP_ID="0", SteamGameId=game, SteamOverlayGameId=game)
|
||||
if game_id:
|
||||
env.update(SteamGameId=game_id, SteamOverlayGameId=game_id)
|
||||
if window:
|
||||
env.setdefault("PROTON_USE_WINED3D", "1")
|
||||
env.update(DESKTOP_GL)
|
||||
for name in NOT_DESKTOP_GL:
|
||||
env.pop(name, None)
|
||||
return env
|
||||
|
||||
|
||||
def windows_path(path):
|
||||
def windows_path(path, compatdata=None):
|
||||
if compatdata:
|
||||
drive = os.path.join(compatdata, "pfx", "drive_c")
|
||||
inside = os.path.relpath(path, drive)
|
||||
if inside != "." and not inside.startswith(".."):
|
||||
return "C:\\" + inside.replace("/", "\\")
|
||||
return "Z:" + path.replace("/", "\\")
|
||||
|
||||
|
||||
def arguments(program, args):
|
||||
def arguments(program, args, desktop=None, compatdata=None):
|
||||
if program.lower().endswith(".msi"):
|
||||
return ["msiexec", "/i", windows_path(program)] + args
|
||||
if desktop:
|
||||
return ["explorer.exe", "/desktop=droiddeck,%s" % desktop, windows_path(program, compatdata)] + args
|
||||
return [program] + args
|
||||
|
||||
|
||||
def main(argv):
|
||||
window = False
|
||||
app, start, options = None, None, ""
|
||||
prefix = None
|
||||
verb = VERB
|
||||
game_id = None
|
||||
desktop = None
|
||||
app, start, options = None, None, None
|
||||
while argv and argv[0].startswith("--"):
|
||||
option = argv.pop(0)
|
||||
if option == "--window":
|
||||
window = True
|
||||
elif option == "--prefix" and argv and prefix_id(argv[0]):
|
||||
prefix = argv.pop(0)
|
||||
elif option == "--verb" and argv and argv[0] in VERBS:
|
||||
verb = argv.pop(0)
|
||||
elif option == "--game-id" and argv and argv[0].isdigit() and argv[0] != "0":
|
||||
game_id = argv.pop(0)
|
||||
elif option == "--desktop" and argv and re.fullmatch(r"[1-9][0-9]{2,4}x[1-9][0-9]{2,4}", argv[0]):
|
||||
desktop = argv.pop(0)
|
||||
elif option in ("--app", "--dir", "--options") and argv:
|
||||
value = argv.pop(0)
|
||||
if option == "--app":
|
||||
@@ -394,9 +494,11 @@ def main(argv):
|
||||
say("%s is not an app id" % app)
|
||||
return 2
|
||||
if not argv and app is None:
|
||||
say("usage: droiddeck-proton-run [--window] PROGRAM [ARGS...]")
|
||||
say("usage: droiddeck-proton-run [--window] [--prefix ID] [--verb run] [--game-id ID] [--desktop WxH] PROGRAM [ARGS...]")
|
||||
return 2
|
||||
root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or STEAM_ROOT
|
||||
if options is None:
|
||||
options = steam_options(app, root) if app is not None else ""
|
||||
extra, args = split_options(options)
|
||||
if not argv:
|
||||
if int(app) >= STEAM_APP_LIMIT:
|
||||
@@ -416,6 +518,8 @@ def main(argv):
|
||||
args = args + argv[1:]
|
||||
if app is not None and int(app) >= STEAM_APP_LIMIT:
|
||||
target = shortcut_target(app, program, start, root)
|
||||
elif prefix:
|
||||
target = fixed(program, root, prefix)
|
||||
else:
|
||||
target = locate(program, root)
|
||||
available = tools(root)
|
||||
@@ -425,7 +529,7 @@ def main(argv):
|
||||
return 69
|
||||
folder, command = available[name]
|
||||
os.makedirs(target.compatdata, exist_ok=True)
|
||||
env = environment(os.environ, target, folder, root, window)
|
||||
env = environment(os.environ, target, folder, root, window, game_id)
|
||||
env.update(extra)
|
||||
say("%s with %s (%s), %s prefix %s%s" % (program, name, why, target.kind, target.compatdata,
|
||||
", without the Steam client" if app is not None else ""))
|
||||
@@ -434,7 +538,7 @@ def main(argv):
|
||||
except OSError:
|
||||
os.chdir(os.path.dirname(program))
|
||||
entry = os.path.join(folder, command)
|
||||
os.execve(entry, [entry, VERB] + arguments(program, args), env)
|
||||
os.execve(entry, [entry, verb] + arguments(program, args, desktop, target.compatdata), env)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -24,7 +24,7 @@ read_scripts() { xargs -0 -r awk -v want="${1:-redists}" '
|
||||
proc[depth] = 1
|
||||
program = tolower(part[4])
|
||||
sub(/.*[\\\/]/, "", program)
|
||||
if (program ~ /vulkan/) vulkan[depth] = 1
|
||||
if (program ~ /vulkan|uplay|ubisoft/) vulkan[depth] = 1
|
||||
next
|
||||
}
|
||||
if (n == 3) pending = part[2]
|
||||
@@ -243,7 +243,7 @@ for system in "${regs[@]}"; do
|
||||
had=()
|
||||
for line in "${kept[@]}"; do had[$line]=1; done
|
||||
printf '%s\n' "${other[@]}" "${kept[@]}" >"$seeded"
|
||||
echo "== took Vulkan runtime markers out of $reg"
|
||||
echo "== took Vulkan runtime and Ubisoft Connect markers out of $reg"
|
||||
fi
|
||||
if [ ${#had[@]} -gt 0 ] && { [ -z "$id" ] || [ "$id" != "$prev" ]; }; then
|
||||
declare -A held=()
|
||||
|
||||
@@ -86,12 +86,6 @@ run_gamescope() (
|
||||
|
||||
collect_steam_logs() {
|
||||
[ -n "${BL_DEBUG_DIR:-}" ] || return 0
|
||||
local steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam
|
||||
[ "${steam_x64:-0}" = 1 ] && steam_root=${BL_X64_HOME:-$HOME/.droiddeck-x64}/.local/share/Steam
|
||||
mkdir -p "$BL_DEBUG_DIR/steam" 2>/dev/null || return 0
|
||||
[ -d "$steam_root/logs" ] && find "$steam_root/logs" -maxdepth 1 -type f -size -8192k \
|
||||
-exec cp {} "$BL_DEBUG_DIR/steam/" \; 2>/dev/null
|
||||
[ "${steam_x64:-0}" = 0 ] && [ -f "$HOME/.steam/steam/logs/steamwebhelper.log" ] && cp "$HOME/.steam/steam/logs/steamwebhelper.log" "$BL_DEBUG_DIR/steam/" 2>/dev/null
|
||||
local sync_store=$HOME/.local/share/droiddeck-esync sync_file
|
||||
if [ -d "$sync_store" ] && mkdir -p "$BL_DEBUG_DIR/droiddeck-esync" 2>/dev/null; then
|
||||
for sync_file in launches.log tools.tsv wanted.tsv prefixes.json; do
|
||||
@@ -102,7 +96,6 @@ collect_steam_logs() {
|
||||
if [ -d "$fex_state" ] && mkdir -p "$BL_DEBUG_DIR/droiddeck-fex" 2>/dev/null; then
|
||||
cp "$fex_state/status.json" "$fex_state/config/Config.json" "$BL_DEBUG_DIR/droiddeck-fex/" 2>/dev/null
|
||||
fi
|
||||
echo "== steam logs copied to $BL_DEBUG_DIR/steam"
|
||||
}
|
||||
trap 'collect_steam_logs 2>/dev/null || true' TERM INT HUP
|
||||
if [ -n "${BL_VK_DRIVER:-}" ]; then
|
||||
@@ -218,20 +211,31 @@ if [ -z "${BL_INSIDE:-}" ]; then
|
||||
width=${BL_WIDTH:-1280}
|
||||
height=${BL_HEIGHT:-720}
|
||||
nested=$width
|
||||
nested_h=$height
|
||||
if [ "${BL_FOLLOW_OUTPUT:-0}" = 1 ]; then
|
||||
echo "== gamescope: the output follows the screen (${width}x${height} to start)"
|
||||
elif [ "$mode" = steam ] && [ "${BL_GAMESCOPE_STRETCH_16X9:-0}" = 1 ]; then
|
||||
wide=$(( (height * 16 + 4) / 9 / 2 * 2 ))
|
||||
tall=$(( (width * 9 + 8) / 16 / 2 * 2 ))
|
||||
if [ "$wide" -gt "$width" ]; then
|
||||
nested=$wide
|
||||
echo "== gamescope: games at ${nested}x${height} stretched to the ${width}x${height} output"
|
||||
elif [ "$tall" -gt "$height" ]; then
|
||||
nested_h=$tall
|
||||
fi
|
||||
if [ "$nested" != "$width" ] || [ "$nested_h" != "$height" ]; then
|
||||
echo "== gamescope: games at ${nested}x${nested_h} stretched to the ${width}x${height} output"
|
||||
fi
|
||||
fi
|
||||
if [ "$mode" = steam ]; then
|
||||
# Off unless Performance asks for it. Compositing the cursor here adds a second
|
||||
# plane on the phone's compositor; a controller-driven cursor is the reason to turn it on.
|
||||
if [ "$mode" = steam ] && [ "${BL_CURSOR_COMPOSITE:-0}" = 1 ]; then
|
||||
export gamescope_cursor_composite=2
|
||||
fi
|
||||
args=(--backend wayland --expose-wayland -f -W "$width" -H "$height" -w "$nested" -h "$height")
|
||||
[ "$nested" != "$width" ] && args+=(-S stretch) && export BL_STRETCHED=1
|
||||
args=(--backend wayland --expose-wayland -f -W "$width" -H "$height" -w "$nested" -h "$nested_h")
|
||||
if [ "$nested" != "$width" ] || [ "$nested_h" != "$height" ]; then
|
||||
args+=(-S stretch)
|
||||
export BL_STRETCHED=1
|
||||
fi
|
||||
if [ "${BL_FPS:-0}" -gt 0 ]; then
|
||||
args+=(-r "$BL_FPS")
|
||||
elif [ "${BL_REFRESH:-0}" -gt 0 ]; then
|
||||
@@ -401,8 +405,14 @@ case $mode in
|
||||
steam_root=$XDG_DATA_HOME/Steam
|
||||
if [ -f "${BL_X64_HOME:-$HOME/.droiddeck-x64}/.local/share/Steam/local.vdf" ]; then
|
||||
droiddeck-steam-x64 --sync-login || true
|
||||
droiddeck-steam-x64 --share || true
|
||||
fi
|
||||
steam_client=("$steam_root/steamrtarm64/steam")
|
||||
_bl_srt_shim=$HOME/.droiddeck-steamrt-shim
|
||||
if droiddeck-steamrt-shim "$steam_root/steamrtarm64" "$_bl_srt_shim"; then
|
||||
echo "== steam: Valve containerized the arm64 Steam client (it carries a Steam Runtime container); starting it through $_bl_srt_shim"
|
||||
steam_client=(env STEAM_RUNTIME_STEAMRT="$_bl_srt_shim" PATH="$_bl_srt_shim/bin:$PATH" "${steam_client[@]}")
|
||||
fi
|
||||
fi
|
||||
_bl_proton_root=$steam_root
|
||||
if [ "$steam_x64" = 1 ]; then
|
||||
@@ -445,48 +455,135 @@ case $mode in
|
||||
fi
|
||||
if [ "${BL_ZRAM:-0}" = 1 ]; then
|
||||
step "zRAM compression: on"
|
||||
[ "${BL_ZRAM_CLIENT:-1}" = 1 ] || step "zRAM: Steam is not compressed while games run (turned off in Performance)"
|
||||
_bl_ram_cap=0
|
||||
case ${BL_RAM_CAP_MB:-} in
|
||||
''|0) ;;
|
||||
*[!0-9]*|0*|???????*) step "RAM cap: ignored invalid value '$BL_RAM_CAP_MB'" ;;
|
||||
*) _bl_ram_cap=$((BL_RAM_CAP_MB * 1024)); step "RAM cap: ${BL_RAM_CAP_MB} MB" ;;
|
||||
esac
|
||||
(
|
||||
bl_zram_scan() {
|
||||
_bl_game=0 _bl_pids=()
|
||||
_bl_game=0 _bl_pids=() _bl_others=()
|
||||
for _d in /proc/[0-9]*; do
|
||||
[ "${_d#/proc/}" != "$BASHPID" ] || continue
|
||||
# Under FEX the program is FEX's first argument.
|
||||
{ IFS= read -r -d '' _c && case ${_c##*/} in FEX|FEXInterpreter) IFS= read -r -d '' _c ;; esac; } \
|
||||
2>/dev/null < "$_d/cmdline" || continue
|
||||
case ${_c##*/} in
|
||||
reaper) _bl_game=1 ;;
|
||||
steam|steamwebhelper) _bl_pids+=("${_d#/proc/}") ;;
|
||||
*) _bl_others+=("${_d#/proc/}") ;;
|
||||
esac
|
||||
done
|
||||
}
|
||||
bl_zram_usage() {
|
||||
local _p _k _v _u _rss=0 _swap=0
|
||||
for _p in "${_bl_pids[@]}"; do
|
||||
for _p in "$@"; do
|
||||
while read -r _k _v _u; do
|
||||
case $_k in VmRSS:) _rss=$((_rss + _v)) ;; VmSwap:) _swap=$((_swap + _v)) ;; esac
|
||||
done 2>/dev/null < "/proc/$_p/status"
|
||||
done
|
||||
echo "${#_bl_pids[@]} processes, resident $((_rss / 1024)) MB, in zram $((_swap / 1024)) MB"
|
||||
_bl_rss=$_rss
|
||||
echo "$# processes, resident $((_rss / 1024)) MB, in zram $((_swap / 1024)) MB"
|
||||
}
|
||||
# Only processes that loaded libblsession are the session's own and answer SIGURG.
|
||||
bl_session_others() {
|
||||
local _p
|
||||
_bl_session=()
|
||||
for _p in "${_bl_others[@]}"; do
|
||||
grep -q -m1 '/libblsession\.so$' "/proc/$_p/maps" 2>/dev/null && _bl_session+=("$_p")
|
||||
done
|
||||
}
|
||||
bl_zram_pick() {
|
||||
if [ "$1" = session ]; then
|
||||
bl_session_others
|
||||
_pids=("${_bl_session[@]}")
|
||||
else
|
||||
_pids=("${_bl_pids[@]}")
|
||||
fi
|
||||
}
|
||||
# Same protocol as SessionSuspendController: an empty ack when the page-out starts, a byte when it is done.
|
||||
# A process whose SIGURG handler was replaced never acks, so it is not waited for after the first 2 s.
|
||||
bl_zram_wait() {
|
||||
local _p _left _start=$SECONDS
|
||||
while [ $((SECONDS - _start)) -lt 12 ]; do
|
||||
_left=0
|
||||
for _p in "$@"; do
|
||||
[ -s "/tmp/.bl-zram.ack.$_p" ] && continue
|
||||
[ -d "/proc/$_p" ] || continue
|
||||
[ $((SECONDS - _start)) -ge 2 ] && [ ! -e "/tmp/.bl-zram.ack.$_p" ] && continue
|
||||
_left=1
|
||||
done
|
||||
[ "$_left" = 1 ] || break
|
||||
nap 0.2
|
||||
done
|
||||
for _p in "$@"; do rm -f "/tmp/.bl-zram.ack.$_p"; done
|
||||
}
|
||||
bl_zram_send() {
|
||||
step "zRAM: $2 ($(bl_zram_usage))"
|
||||
printf '%s' "$1" > /tmp/.bl-zram
|
||||
[ "${#_bl_pids[@]}" = 0 ] || kill -URG "${_bl_pids[@]}" 2>/dev/null
|
||||
nap 5
|
||||
local _mode=$1 _what=$2 _which=$3 _pids _p
|
||||
bl_zram_pick "$_which"
|
||||
step "zRAM: $_what ($(bl_zram_usage "${_pids[@]}"))"
|
||||
for _p in "${_pids[@]}"; do rm -f "/tmp/.bl-zram.ack.$_p"; done
|
||||
printf '%s' "$_mode" > /tmp/.bl-zram
|
||||
[ "${#_pids[@]}" = 0 ] || kill -URG "${_pids[@]}" 2>/dev/null
|
||||
if [ "$_mode" = 1 ]; then bl_zram_wait "${_pids[@]}"; else nap 5; fi
|
||||
bl_zram_scan
|
||||
step "zRAM: done ($(bl_zram_usage))"
|
||||
bl_zram_pick "$_which"
|
||||
step "zRAM: done ($(bl_zram_usage "${_pids[@]}"))"
|
||||
}
|
||||
_bl_since=-1 _bl_packed=-1
|
||||
bl_over_cap() {
|
||||
[ "$_bl_ram_cap" -gt 0 ] || return 1
|
||||
_bl_measured=$SECONDS
|
||||
bl_session_others
|
||||
bl_zram_usage "${_bl_pids[@]}" "${_bl_session[@]}" > /dev/null
|
||||
[ "$_bl_rss" -gt "$_bl_ram_cap" ]
|
||||
}
|
||||
bl_cap_due() {
|
||||
[ "$_bl_ram_cap" -gt 0 ] && { [ "$_bl_measured" -lt 0 ] || [ $((SECONDS - _bl_measured)) -ge 30 ]; }
|
||||
}
|
||||
_bl_since=-1 _bl_packed=-1 _bl_measured=-1 _bl_unpack=0 _bl_capped=-1 _bl_backoff=30
|
||||
while kill -0 $$ 2>/dev/null; do
|
||||
bl_zram_scan
|
||||
if bl_cap_due; then
|
||||
if bl_over_cap; then
|
||||
# A cap below the game's working set cannot be met; paging out again every 30 s only churns.
|
||||
if [ "$_bl_capped" -lt 0 ] || [ $((SECONDS - _bl_capped)) -ge "$_bl_backoff" ]; then
|
||||
bl_zram_usage "${_bl_pids[@]}" > /dev/null
|
||||
if [ "$_bl_rss" -ge $((512 * 1024)) ]; then
|
||||
bl_zram_send 1 "over the ${BL_RAM_CAP_MB} MB RAM cap, compressing the client" client
|
||||
[ "$_bl_game" = 1 ] && _bl_packed=$SECONDS
|
||||
else
|
||||
step "RAM cap: over, client already small ($((_bl_rss / 1024)) MB resident), skipping it"
|
||||
fi
|
||||
bl_over_cap && bl_zram_send 1 "still over the RAM cap, compressing the rest of the session" session
|
||||
if bl_over_cap; then
|
||||
_bl_backoff=$((_bl_backoff * 2 > 600 ? 600 : _bl_backoff * 2))
|
||||
step "RAM cap: still over after paging out, next try in ${_bl_backoff} s"
|
||||
else
|
||||
_bl_backoff=30
|
||||
fi
|
||||
_bl_capped=$SECONDS
|
||||
fi
|
||||
else
|
||||
_bl_backoff=30
|
||||
if [ "$_bl_unpack" = 1 ] && [ "$_bl_game" = 0 ]; then
|
||||
bl_zram_send 0 "back under the RAM cap, reading the client back" client
|
||||
_bl_unpack=0
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
if [ "$_bl_game" = 1 ]; then
|
||||
[ "$_bl_since" -ge 0 ] || _bl_since=$SECONDS
|
||||
if [ $((SECONDS - _bl_since)) -ge 20 ] && [ "${#_bl_pids[@]}" -gt 0 ] &&
|
||||
if [ "${BL_ZRAM_CLIENT:-1}" = 1 ] && [ $((SECONDS - _bl_since)) -ge 20 ] && [ "${#_bl_pids[@]}" -gt 0 ] &&
|
||||
{ [ "$_bl_packed" -lt 0 ] || [ $((SECONDS - _bl_packed)) -ge 300 ]; }; then
|
||||
bl_zram_send 1 "compressing the client"
|
||||
bl_zram_send 1 "compressing the client" client
|
||||
_bl_packed=$SECONDS
|
||||
fi
|
||||
elif [ "$_bl_since" -ge 0 ]; then
|
||||
[ "$_bl_packed" -lt 0 ] || bl_zram_send 0 "game closed, reading the client back"
|
||||
if [ "$_bl_packed" -ge 0 ]; then
|
||||
if bl_over_cap; then _bl_unpack=1; else bl_zram_send 0 "game closed, reading the client back" client; _bl_unpack=0; fi
|
||||
fi
|
||||
_bl_since=-1 _bl_packed=-1
|
||||
fi
|
||||
nap 5
|
||||
@@ -526,6 +623,11 @@ case $mode in
|
||||
fi
|
||||
droiddeck-seed-redists "$steam_root" || true
|
||||
fi
|
||||
if [ -n "${BL_SHADER_PRECACHE:-}" ]; then
|
||||
droiddeck-steam-shaders "$BL_SHADER_PRECACHE" "$XDG_DATA_HOME/Steam" \
|
||||
"${BL_X64_HOME:-$HOME/.droiddeck-x64}/.local/share/Steam" &&
|
||||
echo "$BL_SHADER_PRECACHE" > "$HOME/.bl-shader-precache-applied" || true
|
||||
fi
|
||||
if [ "$steam_x64" = 0 ] && [ ! -f "$steam_root/steamapps/appmanifest_4427310.acf" ]; then
|
||||
step "asking the client to fetch the ARM64 Proton"
|
||||
set -- "$@" steam://install/4427310
|
||||
@@ -746,10 +848,13 @@ BUSCONF
|
||||
fi
|
||||
|
||||
# The UI bridge launches SteamVR, which needs the guest agent's library environment.
|
||||
_bl_compat_env=(env -u LD_LIBRARY_PATH -u STEAM_RUNTIME)
|
||||
_bl_compat_env=(env -u LD_LIBRARY_PATH -u STEAM_RUNTIME -u STEAM_STEAMRT_RECURSION_GUARD)
|
||||
[ "${LD_LIBRARY_PATH+x}" ] && _bl_compat_env+=("LD_LIBRARY_PATH=$LD_LIBRARY_PATH")
|
||||
[ "${STEAM_RUNTIME+x}" ] && _bl_compat_env+=("STEAM_RUNTIME=$STEAM_RUNTIME")
|
||||
[ "${STEAM_STEAMRT_RECURSION_GUARD+x}" ] && _bl_compat_env+=("STEAM_STEAMRT_RECURSION_GUARD=$STEAM_STEAMRT_RECURSION_GUARD")
|
||||
export STEAM_RUNTIME=1
|
||||
# A containerized client re-executes itself through pressure-vessel-wrap (bwrap) unless told it is already inside.
|
||||
export STEAM_STEAMRT_RECURSION_GUARD=1
|
||||
export LD_LIBRARY_PATH=$steam_root/steamrtarm64:$steam_root/steamrtarm64/panorama${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
|
||||
export SDL_VIDEO_X11_DGAMOUSE=0
|
||||
decky_loader=$HOME/homebrew/services/PluginLoader
|
||||
@@ -799,7 +904,11 @@ BUSCONF
|
||||
echo "== steam: devtools port $BL_CDP_PORT, guest processes only"
|
||||
fi
|
||||
[ -n "${BL_LAUNCH_DIR:-}" ] && mkdir -p "$BL_LAUNCH_DIR/agent" && echo "$BL_CDP_PORT" > "$BL_LAUNCH_DIR/agent/cdp-port"
|
||||
[ "$steam_x64" = 1 ] || "${_bl_compat_env[@]}" droiddeck-steam-compat "$steam_root" 2>&1 &
|
||||
if [ "$steam_x64" = 1 ]; then
|
||||
{ droiddeck-steam-compat --files-only "$steam_root" 2>&1 & }
|
||||
else
|
||||
{ "${_bl_compat_env[@]}" droiddeck-steam-compat "$steam_root" 2>&1 & }
|
||||
fi
|
||||
_bl_ui=(-gamepadui)
|
||||
[ "${BL_STEAM_UI:-}" = desktop ] && _bl_ui=()
|
||||
_bl_cef=(-cef-force-gpu -cef-use-gl=angle -cef-use-angle=vulkan)
|
||||
@@ -829,6 +938,9 @@ BUSCONF
|
||||
unset _stale _f
|
||||
fi
|
||||
steam_channel=steamdeck_publicbeta
|
||||
if [ "$steam_x64" = 0 ]; then
|
||||
steam_channel=$(droiddeck-steam-install --channel 2>/dev/null || echo steamdeck_publicbeta)
|
||||
fi
|
||||
_bl_lang=()
|
||||
[ -n "${BL_STEAM_LANGUAGE:-}" ] && _bl_lang=(-language "$BL_STEAM_LANGUAGE")
|
||||
steam_beta=$steam_root/package/beta
|
||||
|
||||
@@ -196,6 +196,51 @@ TOUR_JS = r"""
|
||||
return "off";
|
||||
})()
|
||||
"""
|
||||
FILE_BINDING = "droiddeckOpenFileDialog"
|
||||
FILE_JS = r"""
|
||||
(() => {
|
||||
const cancelled = () => ({ result: 2, message: "" });
|
||||
if (window.__droiddeckFiles) {
|
||||
window.__droiddeckFiles.cancelAll();
|
||||
return "present";
|
||||
}
|
||||
const self = { next: 0, pending: new Map() };
|
||||
const open = function (options) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (typeof window.__BINDING__ !== "function") { reject(cancelled()); return; }
|
||||
const id = ++self.next;
|
||||
self.pending.set(id, { resolve, reject });
|
||||
try { window.__BINDING__(JSON.stringify({ id, options: options || {} })); }
|
||||
catch (e) { self.pending.delete(id); reject(cancelled()); }
|
||||
});
|
||||
};
|
||||
self.done = (id, path) => {
|
||||
const item = self.pending.get(id);
|
||||
if (!item) return false;
|
||||
self.pending.delete(id);
|
||||
if (typeof path === "string" && path) item.resolve(path); else item.reject(cancelled());
|
||||
return true;
|
||||
};
|
||||
self.cancelAll = () => {
|
||||
const items = Array.from(self.pending.values());
|
||||
self.pending.clear();
|
||||
for (const item of items) item.reject(cancelled());
|
||||
};
|
||||
const patch = (w) => {
|
||||
const system = w?.SteamClient?.System;
|
||||
if (system && system.OpenFileDialog !== open) system.OpenFileDialog = open;
|
||||
};
|
||||
patch(window);
|
||||
if (SteamClient.System.OpenFileDialog !== open) throw new Error("Steam OpenFileDialog could not be redirected");
|
||||
const popups = window.g_PopupManager;
|
||||
if (popups) {
|
||||
for (const popup of popups.GetPopups?.() || []) patch(popup.window);
|
||||
popups.AddPopupCreatedCallback?.((popup) => patch(popup.window));
|
||||
}
|
||||
window.__droiddeckFiles = self;
|
||||
return "installed";
|
||||
})()
|
||||
""".replace("__BINDING__", FILE_BINDING)
|
||||
VR_BINDING = "droiddeckLaunchSteamVr"
|
||||
VR_HELPER = "/usr/local/bin/droiddeck-steamvr"
|
||||
VR_JS = r"""
|
||||
@@ -274,6 +319,62 @@ def launch_steamvr():
|
||||
say("SteamVR library launch failed: %s" % e)
|
||||
|
||||
|
||||
def choose_file(options):
|
||||
import gi
|
||||
gi.require_version("Gdk", "3.0")
|
||||
gi.require_version("Gtk", "3.0")
|
||||
from gi.repository import Gdk, Gtk
|
||||
directory = bool(options.get("bChooseDirectory"))
|
||||
save = bool(options.get("bSaveMode")) and not directory
|
||||
action = (Gtk.FileChooserAction.SELECT_FOLDER if directory else
|
||||
Gtk.FileChooserAction.SAVE if save else Gtk.FileChooserAction.OPEN)
|
||||
dialog = Gtk.FileChooserDialog(title=str(options.get("strTitle") or ""), action=action)
|
||||
dialog.add_buttons("gtk-cancel", Gtk.ResponseType.CANCEL,
|
||||
"gtk-save" if save else "gtk-open", Gtk.ResponseType.ACCEPT)
|
||||
dialog.set_default_response(Gtk.ResponseType.ACCEPT)
|
||||
dialog.set_local_only(True)
|
||||
dialog.set_do_overwrite_confirmation(True)
|
||||
for folder in ("/root/Storage", "/mnt/droiddeck-sd"):
|
||||
if os.path.isdir(folder):
|
||||
try:
|
||||
dialog.add_shortcut_folder(folder)
|
||||
except Exception:
|
||||
pass
|
||||
if not directory:
|
||||
for entry in options.get("rgFilters") or []:
|
||||
patterns = [str(p) for p in entry.get("rFilePatterns") or [] if p]
|
||||
if not patterns:
|
||||
continue
|
||||
chosen = Gtk.FileFilter()
|
||||
chosen.set_name(str(entry.get("strFileTypeName") or ", ".join(patterns)))
|
||||
for pattern in patterns:
|
||||
pattern = "*" if pattern == "*.*" else pattern
|
||||
chosen.add_pattern(pattern)
|
||||
if pattern.lower() != pattern.upper():
|
||||
chosen.add_pattern(pattern.upper())
|
||||
dialog.add_filter(chosen)
|
||||
if entry.get("bUseAsDefault"):
|
||||
dialog.set_filter(chosen)
|
||||
initial = str(options.get("strInitialFile") or "").strip('"')
|
||||
if initial:
|
||||
if os.path.isdir(initial):
|
||||
dialog.set_current_folder(initial)
|
||||
elif save:
|
||||
if os.path.isdir(os.path.dirname(initial)):
|
||||
dialog.set_current_folder(os.path.dirname(initial))
|
||||
dialog.set_current_name(os.path.basename(initial))
|
||||
elif os.path.exists(initial):
|
||||
dialog.set_filename(initial)
|
||||
elif os.path.isdir(os.path.dirname(initial)):
|
||||
dialog.set_current_folder(os.path.dirname(initial))
|
||||
screen = Gdk.Screen.get_default()
|
||||
if screen is not None:
|
||||
dialog.set_default_size(screen.get_width(), screen.get_height())
|
||||
chosen_path = dialog.get_filename() if dialog.run() == Gtk.ResponseType.ACCEPT else None
|
||||
dialog.destroy()
|
||||
return chosen_path
|
||||
|
||||
|
||||
class Closed(Exception):
|
||||
pass
|
||||
|
||||
@@ -519,10 +620,11 @@ class Watcher:
|
||||
|
||||
|
||||
class Helper:
|
||||
def __init__(self, steam_root, port, steamos=False):
|
||||
def __init__(self, steam_root, port, steamos=False, files_only=False):
|
||||
self.steam_root = steam_root
|
||||
self.port = port
|
||||
self.steamos = steamos
|
||||
self.files_only = files_only
|
||||
self.page = None
|
||||
self.known = set()
|
||||
self.installed = None
|
||||
@@ -530,6 +632,70 @@ class Helper:
|
||||
self.tools_asked = {}
|
||||
self.tools_checked = None
|
||||
self.vr_launch = None
|
||||
self.chooser = None
|
||||
|
||||
def open_chooser(self, payload):
|
||||
try:
|
||||
request = json.loads(payload)
|
||||
ident = int(request["id"])
|
||||
options = request.get("options", {})
|
||||
if not isinstance(options, dict):
|
||||
raise ValueError("options are not an object")
|
||||
except (ValueError, KeyError, TypeError) as e:
|
||||
say("ignored a file dialog request (%s)" % e)
|
||||
return
|
||||
if self.chooser is not None:
|
||||
self.finish_chooser(ident, None)
|
||||
return
|
||||
command = [sys.executable, os.path.realpath(__file__), "--choose-file"]
|
||||
# Gamescope shows the dialog over the client by the AppId on a reaper above it; the x86-64 client has no
|
||||
# native reaper, so the arm64 client's is borrowed when it is installed.
|
||||
data = os.environ.get("XDG_DATA_HOME") or os.path.join(os.path.expanduser("~"), ".local", "share")
|
||||
for root in (self.steam_root, os.path.join(data, "Steam")):
|
||||
reaper = os.path.join(root, "steamrtarm64", "reaper")
|
||||
if os.access(reaper, os.X_OK):
|
||||
command = [reaper, "SteamLaunch", "AppId=769", "--"] + command
|
||||
break
|
||||
try:
|
||||
proc = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.DEVNULL, start_new_session=True)
|
||||
proc.stdin.write(json.dumps(options).encode("utf-8"))
|
||||
proc.stdin.close()
|
||||
except OSError as e:
|
||||
say("could not open a file dialog (%s)" % e)
|
||||
self.finish_chooser(ident, None)
|
||||
return
|
||||
say("file dialog open: %s" % (options.get("strTitle") or "untitled"))
|
||||
self.chooser = (ident, proc)
|
||||
|
||||
def chooser_done(self):
|
||||
ident, proc = self.chooser
|
||||
self.chooser = None
|
||||
out = proc.stdout.read().decode("utf-8", "replace")
|
||||
proc.stdout.close()
|
||||
proc.wait()
|
||||
if proc.returncode == 2:
|
||||
say("file dialog needs GTK 3 and PyGObject, which come with the desktop")
|
||||
try:
|
||||
path = json.loads(out) if proc.returncode == 0 else None
|
||||
except ValueError:
|
||||
path = None
|
||||
self.finish_chooser(ident, path if isinstance(path, str) and path else None)
|
||||
|
||||
def finish_chooser(self, ident, path):
|
||||
say("file dialog %s" % ("chose " + path if path else "cancelled"))
|
||||
self.page.evaluate("window.__droiddeckFiles?.done(%d, %s)" % (ident, json.dumps(path)))
|
||||
|
||||
def close_chooser(self):
|
||||
if self.chooser is not None:
|
||||
_, proc = self.chooser
|
||||
self.chooser = None
|
||||
try:
|
||||
os.killpg(proc.pid, signal.SIGTERM)
|
||||
except OSError:
|
||||
pass
|
||||
proc.stdout.close()
|
||||
proc.wait()
|
||||
|
||||
def attach(self):
|
||||
path = shared_context(self.port)
|
||||
@@ -539,9 +705,16 @@ class Helper:
|
||||
try:
|
||||
if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True:
|
||||
raise LookupError("SteamClient is not ready")
|
||||
if self.files_only:
|
||||
page.call("Runtime.addBinding", {"name": FILE_BINDING})
|
||||
page.evaluate(FILE_JS)
|
||||
self.page = page
|
||||
return True
|
||||
page.call("Runtime.addBinding", {"name": BINDING})
|
||||
page.call("Runtime.addBinding", {"name": VR_BINDING})
|
||||
page.evaluate(VR_JS)
|
||||
page.call("Runtime.addBinding", {"name": FILE_BINDING})
|
||||
page.evaluate(FILE_JS)
|
||||
try:
|
||||
page.evaluate(TOUR_JS)
|
||||
except RuntimeError:
|
||||
@@ -583,9 +756,8 @@ class Helper:
|
||||
picked = COMPAT["picked_apps"](state)
|
||||
runnable = {t["name"].lower() for t in live}
|
||||
apps = sorted(set(installed) | set(picks) | set(prior_auto) | native_choices, key=COMPAT["app_order"])
|
||||
overrides = COMPAT["requested_games"](
|
||||
COMPAT["game_requests"](), catalog, [t["name"] for t in live])
|
||||
apps = sorted(set(apps) | set(overrides), key=COMPAT["app_order"])
|
||||
asked = [app for app, request in COMPAT["game_requests"]().items() if COMPAT["valid_game_request"](app, request)]
|
||||
apps = sorted(set(apps) | set(asked), key=COMPAT["app_order"])
|
||||
current = dict(page.compat("many(%s)" % json.dumps(apps)) or {})
|
||||
refused = set(apps) - set(current)
|
||||
refused_native = native_choices & refused
|
||||
@@ -597,7 +769,6 @@ class Helper:
|
||||
if isinstance(state.get("auto"), dict):
|
||||
state["auto"] = prior_auto
|
||||
native_choices -= refused
|
||||
overrides = {app: tool for app, tool in overrides.items() if app not in refused}
|
||||
current["0"] = top["selected"]
|
||||
native = COMPAT["native_targets"](self.steam_root, apps)
|
||||
raw_mapping = COMPAT["read_config_mapping"](
|
||||
@@ -619,6 +790,9 @@ class Helper:
|
||||
current[app] = ""
|
||||
elif not current.get(app):
|
||||
current.pop(app, None)
|
||||
requests = COMPAT["settled_game_requests"](state, current, catalog)
|
||||
overrides = COMPAT["requested_games"](requests or {}, catalog, [t["name"] for t in live])
|
||||
overrides = {app: tool for app, tool in overrides.items() if app not in refused}
|
||||
changes, auto = COMPAT["plan_mapping"](
|
||||
current, installed, [t["name"] for t in live], default,
|
||||
COMPAT["followers"](state, current), native, picks, overrides,
|
||||
@@ -630,7 +804,8 @@ class Helper:
|
||||
state.update(
|
||||
auto={app: tool for app, tool in auto.items() if tool is not COMPAT["NATIVE_CHOICE"]},
|
||||
native_choices=sorted(refused_native | {app for app, tool in auto.items() if tool is COMPAT["NATIVE_CHOICE"]}),
|
||||
picked=COMPAT["picked_after"](current, changes), tools=catalog, live=True)
|
||||
picked=COMPAT["picked_after"](current, changes), tools=catalog, live=True,
|
||||
games_applied=COMPAT["applied_game_requests"](requests, overrides, state))
|
||||
state.pop("native", None)
|
||||
if waiting:
|
||||
state["pending"] = wanted
|
||||
@@ -678,9 +853,27 @@ class Helper:
|
||||
if vr_games and (self.vr_launch is None or self.vr_launch.poll() is not None):
|
||||
say("preparing SteamVR for library app(s): " + ", ".join(sorted(vr_games)))
|
||||
self.vr_launch = launch_steamvr()
|
||||
for e in events:
|
||||
if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str):
|
||||
self.open_chooser(e["params"]["payload"])
|
||||
return events
|
||||
|
||||
def serve_files(self):
|
||||
say("attached to the client on port %d for its file dialogs" % self.port)
|
||||
while True:
|
||||
sources = [self.page.ws] + ([self.chooser[1].stdout] if self.chooser is not None else [])
|
||||
queued = self.page.ws.pending() or bool(self.page.events)
|
||||
ready = [self.page.ws] if queued else select.select(sources, [], [], 30)[0]
|
||||
if self.chooser is not None and self.chooser[1].stdout in ready:
|
||||
self.chooser_done()
|
||||
if self.page.ws in ready or self.page.events:
|
||||
for e in self.page.drain():
|
||||
if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str):
|
||||
self.open_chooser(e["params"]["payload"])
|
||||
|
||||
def serve(self, watcher):
|
||||
if self.files_only:
|
||||
return self.serve_files()
|
||||
with open(COMPAT["state_path"]("live.pid"), "w") as f:
|
||||
f.write("%d\n" % os.getpid())
|
||||
say("attached to the client on port %d" % self.port)
|
||||
@@ -688,7 +881,11 @@ class Helper:
|
||||
self.ensure_tools()
|
||||
while True:
|
||||
sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else [])
|
||||
if self.chooser is not None:
|
||||
sources.append(self.chooser[1].stdout)
|
||||
ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 30 if watcher.fileno() >= 0 else 2)[0]
|
||||
if self.chooser is not None and self.chooser[1].stdout in ready:
|
||||
self.chooser_done()
|
||||
due = False
|
||||
if self.page.ws in ready:
|
||||
due = any(called(e, BINDING) for e in self.drain())
|
||||
@@ -716,13 +913,45 @@ def detach():
|
||||
COMPAT["write_json"](state_file, state)
|
||||
|
||||
|
||||
def chooser_main():
|
||||
try:
|
||||
options = json.load(sys.stdin)
|
||||
except ValueError:
|
||||
return 1
|
||||
try:
|
||||
path = choose_file(options if isinstance(options, dict) else {})
|
||||
except (ImportError, ValueError):
|
||||
return 2
|
||||
if not path:
|
||||
return 1
|
||||
print(json.dumps(path))
|
||||
return 0
|
||||
|
||||
|
||||
def main():
|
||||
steam_root = sys.argv[1]
|
||||
files_only = sys.argv[1:2] == ["--files-only"]
|
||||
steam_root = sys.argv[2 if files_only else 1]
|
||||
try:
|
||||
port = int(os.environ.get("BL_CDP_PORT", ""))
|
||||
except ValueError:
|
||||
say("no devtools port for this session; the client's mapping is kept through config.vdf")
|
||||
return 0
|
||||
if files_only:
|
||||
helper = Helper(steam_root, port, files_only=True)
|
||||
failures = 0
|
||||
while True:
|
||||
try:
|
||||
helper.attach()
|
||||
failures = 0
|
||||
helper.serve(None)
|
||||
except Exception as e:
|
||||
helper.close_chooser()
|
||||
if helper.page is not None:
|
||||
say("lost the client (%s); reattaching" % e)
|
||||
helper.page.ws.close()
|
||||
helper.page = None
|
||||
failures += 1
|
||||
time.sleep(min(2 * max(failures, 1), 10))
|
||||
os.makedirs(COMPAT["COMPAT_DIR"], exist_ok=True)
|
||||
watcher = Watcher([COMPAT["state_path"]("request.json"), COMPAT["state_path"]("games.json")] +
|
||||
[os.path.join(lib, "steamapps", "libraryfolders.vdf") for lib in (steam_root, COMPAT["LIBRARY"] + "-sd")])
|
||||
@@ -737,6 +966,7 @@ def main():
|
||||
last = None
|
||||
helper.serve(watcher)
|
||||
except Exception as e:
|
||||
helper.close_chooser()
|
||||
if helper.page is not None:
|
||||
say("lost the client (%s); reattaching" % e)
|
||||
helper.page.ws.close()
|
||||
@@ -750,8 +980,11 @@ def main():
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if sys.argv[1:2] == ["--choose-file"]:
|
||||
sys.exit(chooser_main())
|
||||
signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
|
||||
try:
|
||||
sys.exit(main())
|
||||
finally:
|
||||
detach()
|
||||
if sys.argv[1:2] != ["--files-only"]:
|
||||
detach()
|
||||
@@ -1,25 +1,57 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
cdn_list="https://client-update.steamstatic.com https://client-update.akamai.steamstatic.com https://client-update.fastly.steamstatic.com"
|
||||
steam_channel=steamdeck_publicbeta
|
||||
manifest=steam_client_${steam_channel}_linuxarm64
|
||||
beta_channel=steamdeck_publicbeta
|
||||
stable_channel=steamdeck_stable
|
||||
steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam
|
||||
channel_state=$steam_root/package/droiddeck-channel
|
||||
pinned=1
|
||||
wanted=${BL_STEAM_CHANNEL:-$(cat "$HOME/.config/droiddeck/steam-channel" 2>/dev/null || true)}
|
||||
case $wanted in
|
||||
stable|"$stable_channel") steam_channel=$stable_channel ;;
|
||||
beta|"$beta_channel") steam_channel=$beta_channel ;;
|
||||
*)
|
||||
pinned=
|
||||
steam_channel=$beta_channel
|
||||
[ "$(cat "$channel_state" 2>/dev/null)" = "$stable_channel" ] && steam_channel=$stable_channel
|
||||
;;
|
||||
esac
|
||||
if [ "${1:-}" = --channel ]; then
|
||||
echo "$steam_channel"
|
||||
exit 0
|
||||
fi
|
||||
manifest=steam_client_${steam_channel}_linuxarm64
|
||||
stamp=$steam_root/package/droiddeck-installed
|
||||
legacy_stamp=$steam_root/package/bannerlator-installed
|
||||
unconfirmed=$steam_root/package/droiddeck-unconfirmed
|
||||
repair_request=$HOME/.bl-steam-repair
|
||||
parts=$steam_root/package/droiddeck-download
|
||||
if [ -f "$legacy_stamp" ] && [ ! -f "$stamp" ]; then
|
||||
mv -f "$legacy_stamp" "$stamp" || true
|
||||
fi
|
||||
repair=""
|
||||
fallback=""
|
||||
starts=0
|
||||
[ -f "$unconfirmed" ] && starts=$(grep -cx start "$unconfirmed" || true)
|
||||
if [ -e "$repair_request" ]; then
|
||||
repair="requested"
|
||||
elif [ -f "$unconfirmed" ] && ! grep -qx repaired "$unconfirmed" \
|
||||
&& [ "$(grep -cx start "$unconfirmed")" -ge 2 ]; then
|
||||
repair="the client was started $(grep -cx start "$unconfirmed") times without showing anything"
|
||||
elif [ "$starts" -ge 2 ] && ! grep -qx repaired "$unconfirmed"; then
|
||||
repair="the client was started $starts times without showing anything"
|
||||
elif [ "$starts" -ge 2 ] && [ -z "$pinned" ] && [ "$steam_channel" = "$beta_channel" ] && [ "${1:-}" != --sync ]; then
|
||||
repair="the repaired $beta_channel client was started $starts more times without showing anything"
|
||||
fallback=1
|
||||
fi
|
||||
if [ -n "$fallback" ]; then
|
||||
echo "== STEP $(date -u +%H:%M:%S) falling back to Valve's $stable_channel Steam client: $repair"
|
||||
steam_channel=$stable_channel
|
||||
manifest=steam_client_${steam_channel}_linuxarm64
|
||||
fi
|
||||
if [ -n "$repair" ]; then
|
||||
echo "== STEP $(date -u +%H:%M:%S) repairing the Steam client ($repair)"
|
||||
if [ ! -f "$parts/.repair" ]; then
|
||||
rm -rf "$parts"
|
||||
mkdir -p "$parts" && : > "$parts/.repair"
|
||||
fi
|
||||
rm -f "$stamp" "$legacy_stamp" "$steam_root/.crash" "$steam_root/steam.pid" \
|
||||
"$steam_root"/package/steam_client_*.manifest "$steam_root"/package/steam_client_*.installed
|
||||
for part in "$steam_root"/package/*.zip.*; do
|
||||
@@ -42,20 +74,99 @@ fi
|
||||
|
||||
work=$(mktemp -d)
|
||||
trap 'rm -rf "$work"' EXIT
|
||||
cdn=""
|
||||
for candidate in $cdn_list; do
|
||||
if curl -fsSL --connect-timeout 10 --max-time 30 --retry 2 --retry-connrefused --retry-delay 3 \
|
||||
"$candidate/$manifest" -o "$work/manifest"; then
|
||||
cdn=$candidate
|
||||
break
|
||||
|
||||
nap() {
|
||||
[ -n "${nap_fd:-}" ] || exec {nap_fd}<> <(:)
|
||||
read -r -t "$1" -u "$nap_fd" _ 2>/dev/null || :
|
||||
}
|
||||
size_of() {
|
||||
local n=0
|
||||
[ -f "$1" ] && n=$(wc -c < "$1")
|
||||
echo $((n))
|
||||
}
|
||||
limits=(--connect-timeout 30 --speed-limit 4096 --speed-time 60)
|
||||
read -r -a delays <<< "${BL_STEAM_RETRY_DELAYS:-5 10 20 30 30}"
|
||||
|
||||
step() { echo "== STEP $(date -u +%H:%M:%S) $*"; }
|
||||
progress() {
|
||||
local mb=$(( (done_bytes + $(size_of "$1")) / 1000000 ))
|
||||
[ -z "${3:-}" ] && [ "$mb" = "${shown_mb:-}" ] && [ "$2" = "${shown_part:-}" ] && return 0
|
||||
shown_mb=$mb shown_part=$2
|
||||
step "downloading Steam: $2 ($i/$total), $mb of $((total_bytes / 1000000)) MB${3:+ - $3}"
|
||||
}
|
||||
|
||||
fetch() {
|
||||
local url=$1 dest=$2 size=$3 sum=$4 part=$5 failures=0 bad=0 finished=0 before rc fd wait
|
||||
while :; do
|
||||
if [ -f "$dest" ] && { [ "$finished" = 1 ] || { [ "$size" -gt 0 ] && [ "$(size_of "$dest")" -ge "$size" ]; }; }; then
|
||||
echo "$sum $dest" | sha256sum -c --quiet 2>/dev/null && return 0
|
||||
rm -f "$dest"
|
||||
finished=0 bad=$((bad + 1))
|
||||
[ "$bad" -lt 3 ] || { echo "droiddeck-steam-install: $part does not match its checksum" >&2; return 1; }
|
||||
fi
|
||||
before=$(size_of "$dest")
|
||||
exec {fd}< <(code=$(curl -fsSL "${limits[@]}" -w '%{http_code}' -C - -o "$dest" "$url") && echo "0 $code" || echo "$? $code")
|
||||
until read -r -t 5 -u "$fd" rc http; do
|
||||
if [ $? -le 128 ]; then rc=1; break; fi
|
||||
progress "$dest" "$part"
|
||||
done
|
||||
exec {fd}<&-
|
||||
if [ "$rc" = 0 ]; then finished=1; continue; fi
|
||||
case "$rc:${http:-}" in
|
||||
22:416 | 33:*) rm -f "$dest" ;;
|
||||
22:4??)
|
||||
echo "droiddeck-steam-install: $part: HTTP $http from ${url%/*}" >&2
|
||||
return 1
|
||||
;;
|
||||
esac
|
||||
if [ "$(size_of "$dest")" -gt "$before" ]; then failures=0; else failures=$((failures + 1)); fi
|
||||
if [ "$failures" -gt "${#delays[@]}" ]; then
|
||||
echo "droiddeck-steam-install: could not download $part (curl exit $rc); what arrived is kept for the next try" >&2
|
||||
return 1
|
||||
fi
|
||||
wait=${delays[$((failures > 0 ? failures - 1 : 0))]}
|
||||
progress "$dest" "$part" "interrupted (curl exit $rc), trying again in ${wait} s"
|
||||
nap "$wait"
|
||||
done
|
||||
}
|
||||
|
||||
fetch_manifest() {
|
||||
cdn=""
|
||||
for candidate in $cdn_list; do
|
||||
if curl -fsSL --connect-timeout 10 --max-time 30 --retry 2 --retry-connrefused --retry-delay 3 \
|
||||
"$candidate/$manifest" -o "$work/manifest"; then
|
||||
cdn=$candidate
|
||||
break
|
||||
fi
|
||||
done
|
||||
[ -n "$cdn" ] || { echo "droiddeck-steam-install: no Steam client CDN answered for $manifest" >&2; exit 1; }
|
||||
cdn_order=("$cdn")
|
||||
for candidate in $cdn_list; do
|
||||
[ "$candidate" = "$cdn" ] || cdn_order+=("$candidate")
|
||||
done
|
||||
version=$(awk -F'"' '$2 == "version" { print $4; exit }' "$work/manifest")
|
||||
awk -F'"' '
|
||||
/^\t"/ && NF >= 3 && $4 == "" { block = $2 }
|
||||
$2 == "file" { file[block] = $4 }
|
||||
$2 == "sha2" { sha[block] = $4 }
|
||||
$2 == "size" { size[block] = $4 }
|
||||
END { for (b in file) if (b ~ /_all$/ || b ~ /_linuxarm64_linuxarm64$/) print b, file[b], sha[b], size[b] + 0 }
|
||||
' "$work/manifest" | sort > "$work/parts"
|
||||
[ -s "$work/parts" ] && return 0
|
||||
echo "droiddeck-steam-install: no client components in $manifest; its blocks are:" \
|
||||
"$(awk -F'"' '/^\t"/ && NF >= 3 && $4 == "" { printf "%s ", $2 }' "$work/manifest")" >&2
|
||||
return 1
|
||||
}
|
||||
if ! fetch_manifest; then
|
||||
if [ -n "$sync" ] || [ -n "$pinned" ] || [ "$steam_channel" = "$stable_channel" ]; then
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
[ -n "$cdn" ] || { echo "droiddeck-steam-install: no Steam client CDN answered for $manifest" >&2; exit 1; }
|
||||
cdn_order=("$cdn")
|
||||
for candidate in $cdn_list; do
|
||||
[ "$candidate" = "$cdn" ] || cdn_order+=("$candidate")
|
||||
done
|
||||
version=$(awk -F'"' '$2 == "version" { print $4; exit }' "$work/manifest")
|
||||
echo "== STEP $(date -u +%H:%M:%S) falling back to Valve's $stable_channel Steam client: $manifest has no arm64 client"
|
||||
steam_channel=$stable_channel
|
||||
manifest=steam_client_${steam_channel}_linuxarm64
|
||||
fallback=1
|
||||
fetch_manifest || exit 1
|
||||
fi
|
||||
if [ -n "$sync" ]; then
|
||||
installed=$(awk -F'"' '$2 == "version" { print $4; exit }' "$steam_root/package/$manifest.manifest" 2>/dev/null || true)
|
||||
if [ -x "$steam_root/steamrtarm64/steam" ] && [ "$installed" = "$version" ]; then
|
||||
@@ -64,31 +175,36 @@ if [ -n "$sync" ]; then
|
||||
fi
|
||||
echo "== STEP $(date -u +%H:%M:%S) updating the arm64 Steam client to $version (was ${installed:-none}) for the x86-64 client"
|
||||
fi
|
||||
awk -F'"' '
|
||||
/^\t"/ && NF >= 3 && $4 == "" { block = $2 }
|
||||
$2 == "file" { file[block] = $4 }
|
||||
$2 == "sha2" { sha[block] = $4 }
|
||||
END { for (b in file) if (b ~ /_all$/ || b ~ /_linuxarm64_linuxarm64$/) print b, file[b], sha[b] }
|
||||
' "$work/manifest" | sort > "$work/parts"
|
||||
[ -s "$work/parts" ] || { echo "droiddeck-steam-install: no client components in $manifest" >&2; exit 1; }
|
||||
total=$(grep -c . "$work/parts" 2>/dev/null || echo 0)
|
||||
total_bytes=$(awk '{ n += $4 } END { print n + 0 }' "$work/parts")
|
||||
|
||||
mkdir -p "$steam_root/package"
|
||||
while read -r block file sum; do
|
||||
mkdir -p "$parts"
|
||||
for left in "$parts"/*; do
|
||||
[ -e "$left" ] || continue
|
||||
name=${left##*/}
|
||||
name=${name%.unpacked}
|
||||
grep -qF " $name " "$work/parts" || rm -rf "$left"
|
||||
done
|
||||
done_bytes=0
|
||||
while read -r block file sum size; do
|
||||
i=$((${i:-0} + 1))
|
||||
echo "== STEP $(date -u +%H:%M:%S) downloading Steam: $block ($i/$total)"
|
||||
if [ -f "$parts/$file.unpacked" ]; then
|
||||
done_bytes=$((done_bytes + size))
|
||||
continue
|
||||
fi
|
||||
progress "$parts/$file" "$block"
|
||||
fetched=""
|
||||
for host in "${cdn_order[@]}"; do
|
||||
if curl -fsSL --connect-timeout 10 --speed-limit 1024 --speed-time 60 --max-time 1800 \
|
||||
"$host/$file" -o "$work/$file" && echo "$sum $work/$file" | sha256sum -c --quiet; then
|
||||
if fetch "$host/$file" "$parts/$file" "$size" "$sum" "$block"; then
|
||||
fetched=$host
|
||||
break
|
||||
fi
|
||||
rm -f "$work/$file"
|
||||
done
|
||||
[ -n "$fetched" ] || { echo "droiddeck-steam-install: $file failed on every CDN" >&2; exit 1; }
|
||||
unzip -qo "$work/$file" -d "$steam_root"
|
||||
rm -f "$work/$file"
|
||||
unzip -qo "$parts/$file" -d "$steam_root"
|
||||
: > "$parts/$file.unpacked"
|
||||
rm -f "$parts/$file"
|
||||
done_bytes=$((done_bytes + size))
|
||||
done < "$work/parts"
|
||||
find "$steam_root" -depth -name '*\\*' | while read -r odd; do
|
||||
fixed=${odd//\\//}
|
||||
@@ -117,6 +233,11 @@ ln -sfn "$steam_root/linuxarm64" "$HOME/.steam/sdkarm64"
|
||||
ln -sfn "$steam_root/steamrtarm64" "$HOME/.steam/binarm64"
|
||||
ln -sfn "$steam_root/linux32" "$HOME/.steam/sdk32"
|
||||
echo "$version" > "$stamp"
|
||||
rm -rf "$parts"
|
||||
if [ -n "$fallback" ]; then
|
||||
echo "$stable_channel" > "$channel_state"
|
||||
echo "== STEP $(date -u +%H:%M:%S) the Steam client now follows $stable_channel (beta in ~/.config/droiddeck/steam-channel returns to $beta_channel)"
|
||||
fi
|
||||
if [ -n "$repair" ]; then
|
||||
echo repaired > "$unconfirmed"
|
||||
rm -f "$repair_request"
|
||||
|
||||
@@ -12,6 +12,10 @@ case $target in
|
||||
esac
|
||||
|
||||
if [ "$ui" = desktop ] && [ "${BL_DESKTOP:-}" = 1 ]; then
|
||||
case ",${MESA_VK_WSI_DEBUG:-}," in
|
||||
*,sw,*) ;;
|
||||
*) export MESA_VK_WSI_DEBUG=${MESA_VK_WSI_DEBUG:+$MESA_VK_WSI_DEBUG,}sw ;;
|
||||
esac
|
||||
if [ "${BL_STEAM_CLIENT_ARCH:-}" = x86_64 ]; then
|
||||
client_home=${BL_X64_HOME:-${HOME:-/root}/.droiddeck-x64}
|
||||
client=(/usr/local/bin/droiddeck-steam-x64 --exec)
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/python3
|
||||
"""Sets the Steam client's shader pre-caching (Settings > Downloads), before the client starts.
|
||||
|
||||
droiddeck-steam-shaders <0|1> <steam root>...
|
||||
|
||||
The client stores the toggle as InstallConfigStore/Software/Valve/Steam/ShaderCacheManager/
|
||||
DisableShaderCache in config/config.vdf: "1" when off, "0" when on. It keeps the setting in memory
|
||||
and writes config.vdf back on exit, so this runs only while the client is stopped. The launcher
|
||||
passes a value only after its own toggle changes; otherwise the client's toggle stays the user's."""
|
||||
from pathlib import Path
|
||||
import runpy
|
||||
import sys
|
||||
|
||||
|
||||
VDF = runpy.run_path(str(Path(__file__).with_name("droiddeck-steam-ui-scale")))
|
||||
PATH = ("Software", "Valve", "Steam", "ShaderCacheManager", "DisableShaderCache")
|
||||
|
||||
|
||||
def set_text(text, enabled):
|
||||
value = "0" if enabled else "1"
|
||||
updated, changed = VDF["seed_value"](text, PATH, value)
|
||||
if changed:
|
||||
return updated, True
|
||||
block = VDF["parse"](text).get("InstallConfigStore")
|
||||
for section in PATH[:-1]:
|
||||
block = block.get(section)
|
||||
current = block.get(PATH[-1])
|
||||
if isinstance(current, VDF["Block"]):
|
||||
raise ValueError("invalid DisableShaderCache setting")
|
||||
if current == value:
|
||||
return text, False
|
||||
at = block.offset(PATH[-1])
|
||||
end = VDF["TOKEN"].match(text, at).end()
|
||||
return text[:at] + f'"{value}"' + text[end:], True
|
||||
|
||||
|
||||
def apply(steam_root, enabled):
|
||||
config = Path(steam_root) / "config/config.vdf"
|
||||
text = config.read_text() if config.exists() else '"InstallConfigStore"\n{\n}\n'
|
||||
updated, changed = set_text(text, enabled)
|
||||
if changed:
|
||||
VDF["atomic_write"](config, updated)
|
||||
return changed
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) < 3 or sys.argv[1] not in ("0", "1"):
|
||||
print("usage: droiddeck-steam-shaders <0|1> <steam root>...", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
enabled = sys.argv[1] == "1"
|
||||
status = 0
|
||||
for root in sys.argv[2:]:
|
||||
if not Path(root).is_dir():
|
||||
continue
|
||||
try:
|
||||
if apply(root, enabled):
|
||||
print(f"== steam: shader pre-caching {'on' if enabled else 'off'} in {root}")
|
||||
except (OSError, ValueError, RecursionError) as error:
|
||||
print(f"== steam: left shader pre-caching unchanged in {root}: {error}", file=sys.stderr)
|
||||
status = 1
|
||||
sys.exit(status)
|
||||
+273
@@ -0,0 +1,273 @@
|
||||
#!/usr/bin/python3
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import runpy
|
||||
import sys
|
||||
|
||||
NOT_GAMES = frozenset((
|
||||
"228980", "1070560", "1391110", "1628350", "1493710", "3127680",
|
||||
"4183110", "4185400", "4427310", "4628740",
|
||||
))
|
||||
TOOL_DIR = re.compile(r"(steam ?linux ?runtime.*|proton.*|steamworks shared|fex|steamvr)", re.I)
|
||||
AUTOMATIC = ("", "droiddeck-direct", "droiddeck-fex", "droiddeck-proton-arm64", "droiddeck-proton-11-arm64")
|
||||
LINUX_TOOLS = ("droiddeck-direct", "droiddeck-fex")
|
||||
STATE = ".droiddeck-shared.json"
|
||||
LABELS = {"arm64": "ARM64 client games", "x86-64": "x86-64 client games"}
|
||||
|
||||
|
||||
def say(message):
|
||||
print("droiddeck-steam-share: " + message)
|
||||
|
||||
|
||||
def read(path):
|
||||
try:
|
||||
with open(path, encoding="utf-8", errors="surrogateescape") as f:
|
||||
return f.read()
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def write(path, text):
|
||||
staged = path + ".droiddeck-new"
|
||||
with open(staged, "w", encoding="utf-8", errors="surrogateescape") as f:
|
||||
f.write(text)
|
||||
os.replace(staged, path)
|
||||
|
||||
|
||||
def field(text, key):
|
||||
m = re.search(r'"%s"\s+"([^"]*)"' % re.escape(key), text or "", re.I)
|
||||
return m.group(1) if m else None
|
||||
|
||||
|
||||
def number(text, key):
|
||||
value = field(text, key)
|
||||
return int(value) if value and value.isdigit() else 0
|
||||
|
||||
|
||||
def same(a, b):
|
||||
return os.path.realpath(a) == os.path.realpath(b)
|
||||
|
||||
|
||||
def libraries(root, skip):
|
||||
found = [root] + [p.replace("\\\\", "\\") for p in
|
||||
re.findall(r'"path"\s+"((?:[^"\\]|\\.)*)"', read(os.path.join(root, "steamapps", "libraryfolders.vdf")) or "")]
|
||||
return [p for p in dict.fromkeys(found) if not any(same(p, s) for s in skip)]
|
||||
|
||||
|
||||
def installs(libs):
|
||||
games = {}
|
||||
for library in libs:
|
||||
steamapps = os.path.join(library, "steamapps")
|
||||
try:
|
||||
names = sorted(os.listdir(steamapps))
|
||||
except OSError:
|
||||
continue
|
||||
for name in names:
|
||||
m = re.fullmatch(r"appmanifest_(\d+)\.acf", name)
|
||||
if not m or m.group(1) in NOT_GAMES or m.group(1) in games:
|
||||
continue
|
||||
text = read(os.path.join(steamapps, name))
|
||||
folder = field(text, "installdir")
|
||||
if (not folder or folder in (".", "..") or "/" in folder or TOOL_DIR.fullmatch(folder)
|
||||
or not number(text, "StateFlags") & 4
|
||||
or not os.path.isdir(os.path.join(steamapps, "common", folder))):
|
||||
continue
|
||||
games[m.group(1)] = (steamapps, text, folder)
|
||||
return games
|
||||
|
||||
|
||||
def link(path, target):
|
||||
if os.path.islink(path):
|
||||
if os.readlink(path) == target:
|
||||
return True
|
||||
os.unlink(path)
|
||||
elif os.path.lexists(path):
|
||||
return False
|
||||
os.symlink(target, path)
|
||||
return True
|
||||
|
||||
|
||||
def unlink(path):
|
||||
if os.path.islink(path):
|
||||
os.unlink(path)
|
||||
|
||||
|
||||
def emptied(src, folder):
|
||||
path = os.path.join(src, "common", folder)
|
||||
return not os.path.isdir(path) or not os.listdir(path)
|
||||
|
||||
|
||||
def sync(view, source, own):
|
||||
steamapps = os.path.join(view, "steamapps")
|
||||
for sub in ("common", "compatdata"):
|
||||
os.makedirs(os.path.join(steamapps, sub), exist_ok=True)
|
||||
state = {}
|
||||
try:
|
||||
state = json.loads(read(os.path.join(view, STATE)) or "{}")
|
||||
except ValueError:
|
||||
pass
|
||||
managed = {app: tuple(v) for app, v in state.get("shared", {}).items() if isinstance(v, list) and len(v) == 2}
|
||||
hidden = state.get("hidden", {})
|
||||
shared, back = {}, []
|
||||
for app, (src, folder) in managed.items():
|
||||
if app in source and app not in own:
|
||||
continue
|
||||
manifest = os.path.join(steamapps, "appmanifest_%s.acf" % app)
|
||||
if app not in own and not os.path.isfile(manifest) and emptied(src, folder) and os.path.isfile(os.path.join(src, "appmanifest_%s.acf" % app)):
|
||||
os.unlink(os.path.join(src, "appmanifest_%s.acf" % app))
|
||||
unlink(os.path.join(steamapps, "common", folder))
|
||||
unlink(os.path.join(steamapps, "compatdata", app))
|
||||
if os.path.isfile(manifest):
|
||||
os.unlink(manifest)
|
||||
for app, (src, text, folder) in sorted(source.items(), key=lambda item: int(item[0])):
|
||||
if app in own:
|
||||
continue
|
||||
stamp = number(text, "LastUpdated")
|
||||
if hidden.get(app) == stamp:
|
||||
continue
|
||||
hidden.pop(app, None)
|
||||
manifest = os.path.join(steamapps, "appmanifest_%s.acf" % app)
|
||||
mine = read(manifest)
|
||||
if app in managed and mine is None:
|
||||
unlink(os.path.join(steamapps, "common", folder))
|
||||
unlink(os.path.join(steamapps, "compatdata", app))
|
||||
if emptied(src, folder):
|
||||
os.unlink(os.path.join(src, "appmanifest_%s.acf" % app))
|
||||
else:
|
||||
hidden[app] = stamp
|
||||
continue
|
||||
if not link(os.path.join(steamapps, "common", folder), os.path.join(src, "common", folder)):
|
||||
continue
|
||||
if os.path.isdir(os.path.join(src, "compatdata", app)):
|
||||
link(os.path.join(steamapps, "compatdata", app), os.path.join(src, "compatdata", app))
|
||||
if mine is not None and number(mine, "LastUpdated") > stamp:
|
||||
write(os.path.join(src, "appmanifest_%s.acf" % app), mine)
|
||||
back.append(app)
|
||||
elif mine != text:
|
||||
write(manifest, text)
|
||||
shared[app] = [src, folder]
|
||||
state = {"shared": shared, "hidden": hidden}
|
||||
write(os.path.join(view, STATE), json.dumps(state, indent=1, sort_keys=True) + "\n")
|
||||
return shared, back
|
||||
|
||||
|
||||
def tools(root):
|
||||
names = set()
|
||||
folder = os.path.join(root, "compatibilitytools.d")
|
||||
try:
|
||||
entries = os.listdir(folder)
|
||||
except OSError:
|
||||
return names
|
||||
for entry in entries:
|
||||
text = read(os.path.join(folder, entry, "compatibilitytool.vdf")) or ""
|
||||
m = re.search(r'"compat_tools"\s*\{\s*"([^"]+)"', text)
|
||||
if m:
|
||||
names.add(m.group(1))
|
||||
return names
|
||||
|
||||
|
||||
def mapping_block(text):
|
||||
m = re.search(r'"CompatToolMapping"\s*\{', text)
|
||||
if not m:
|
||||
return None
|
||||
depth, k = 1, m.end()
|
||||
while depth and k < len(text):
|
||||
depth += {"{": 1, "}": -1}.get(text[k], 0)
|
||||
k += 1
|
||||
return m.end(), k - 1
|
||||
|
||||
|
||||
def entries(text):
|
||||
span = mapping_block(text)
|
||||
found = {}
|
||||
if not span:
|
||||
return found
|
||||
inner = text[span[0]:span[1]]
|
||||
for m in re.finditer(r'"(\d+)"\s*\{([^{}]*)\}', inner):
|
||||
name = re.search(r'"name"\s*"([^"]*)"', m.group(2))
|
||||
found.setdefault(m.group(1), name.group(1) if name else "")
|
||||
return found
|
||||
|
||||
|
||||
def set_tools(config, wanted):
|
||||
text = read(config)
|
||||
if text is None or not wanted:
|
||||
return []
|
||||
span = mapping_block(text)
|
||||
if not span:
|
||||
return []
|
||||
inner = text[span[0]:span[1]]
|
||||
changed = []
|
||||
for app, tool in sorted(wanted.items(), key=lambda item: int(item[0])):
|
||||
m = re.search(r'"%s"\s*\{([^{}]*)\}' % app, inner)
|
||||
if m:
|
||||
name = re.search(r'"name"\s*"([^"]*)"', m.group(1))
|
||||
name = name.group(1) if name else ""
|
||||
if name == tool or not (canonical(name) in map(canonical, AUTOMATIC) or name.startswith("proton_")):
|
||||
continue
|
||||
if name and (name in LINUX_TOOLS) == (tool in LINUX_TOOLS):
|
||||
continue
|
||||
inner = inner[:m.start()] + inner[m.end():]
|
||||
inner = ('\n\t\t\t\t\t"%s"\n\t\t\t\t\t{\n\t\t\t\t\t\t"name"\t\t"%s"\n\t\t\t\t\t\t"config"\t\t""\n'
|
||||
'\t\t\t\t\t\t"priority"\t\t"250"\n\t\t\t\t\t}' % (app, tool)) + inner
|
||||
changed.append(app)
|
||||
if changed:
|
||||
write(config, text[:span[0]] + inner + text[span[1]:])
|
||||
return changed
|
||||
|
||||
|
||||
def canonical(name):
|
||||
return re.sub(r"arm64|aarch64", "a64", name)
|
||||
|
||||
|
||||
def translate(name, here, available):
|
||||
if name == "droiddeck-fex" and here == "x86-64":
|
||||
return "droiddeck-direct"
|
||||
if name == "droiddeck-direct" and here == "arm64":
|
||||
return "droiddeck-fex"
|
||||
return {canonical(a): a for a in available}.get(canonical(name))
|
||||
|
||||
|
||||
def library_helper():
|
||||
sibling = os.path.join(os.path.dirname(os.path.realpath(__file__)), "droiddeck-steam-library")
|
||||
return runpy.run_path(sibling if os.path.isfile(sibling) else "/usr/local/bin/droiddeck-steam-library")
|
||||
|
||||
|
||||
def main(argv):
|
||||
if len(argv) != 5 or argv[0] not in LABELS:
|
||||
say("usage: droiddeck-steam-share arm64|x86-64 ARM_STEAM X64_STEAM X64_CARD SHARED_DIR")
|
||||
return 2
|
||||
here, arm, x64, x64_card, shared_dir = argv
|
||||
views = {name: os.path.join(shared_dir, name) for name in LABELS}
|
||||
roots = {"arm64": arm, "x86-64": x64}
|
||||
other = "x86-64" if here == "arm64" else "arm64"
|
||||
skip = list(views.values()) + [x64, x64_card]
|
||||
arm_libs = libraries(arm, skip)
|
||||
x64_libs = [x64] + [p for p in libraries(x64, list(views.values()) + [arm]) if not same(p, x64)]
|
||||
games = {"arm64": installs(arm_libs), "x86-64": installs(x64_libs)}
|
||||
view = views[other]
|
||||
shared, back = sync(view, games[other], games[here])
|
||||
helper = library_helper()
|
||||
if not any(re.fullmatch(r"appmanifest_\d+\.acf", n) for n in os.listdir(os.path.join(view, "steamapps"))):
|
||||
helper["forget"](roots[here], view)
|
||||
return 0
|
||||
helper["register"](roots[here], view, LABELS[other])
|
||||
helper["relabel"](roots[here], view, LABELS[other])
|
||||
picks = entries(read(os.path.join(roots[other], "config", "config.vdf")) or "")
|
||||
available = tools(roots[here]) | {"droiddeck-direct" if here == "x86-64" else "droiddeck-fex"}
|
||||
wanted = {}
|
||||
for app in shared:
|
||||
tool = translate(picks.get(app) or picks.get("0", ""), here, available)
|
||||
if tool:
|
||||
wanted[app] = tool
|
||||
changed = set_tools(os.path.join(roots[here], "config", "config.vdf"), wanted)
|
||||
say("%d game(s) from the %s client%s%s" % (
|
||||
len(shared), other,
|
||||
"; tools set for %s" % " ".join(changed) if changed else "",
|
||||
"; manifests sent back for %s" % " ".join(back) if back else ""))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -18,13 +18,17 @@ TAG = "droiddeck-app"
|
||||
def account_dir(steam_root):
|
||||
"""The most recent account's userdata folder, else the only one that is not 0."""
|
||||
users = os.path.join(steam_root, "config", "loginusers.vdf")
|
||||
recent = None
|
||||
recent, best = None, None
|
||||
try:
|
||||
with open(users, encoding="utf-8", errors="replace") as f:
|
||||
text = f.read()
|
||||
for block in re.finditer(r'"(\d{5,})"\s*\{([^}]*)\}', text):
|
||||
if re.search(r'"MostRecent"\s*"1"', block.group(2)):
|
||||
recent = int(block.group(1))
|
||||
stamp = re.search(r'"timestamp"\s*"(\d+)"', block.group(2))
|
||||
rank = (bool(re.search(r'"MostRecent"\s*"1"', block.group(2))),
|
||||
bool(re.search(r'"AutoLogin"\s*"1"', block.group(2))),
|
||||
int(stamp.group(1)) if stamp else 0)
|
||||
if any(rank) and (best is None or rank >= best):
|
||||
recent, best = int(block.group(1)), rank
|
||||
except OSError:
|
||||
pass
|
||||
userdata = os.path.join(steam_root, "userdata")
|
||||
|
||||
@@ -26,9 +26,10 @@ TOKEN = re.compile(r'\s+|//[^\n]*|"(?:\\.|[^"\\])*"|[{}]')
|
||||
|
||||
|
||||
class Block:
|
||||
def __init__(self, pairs, end):
|
||||
def __init__(self, pairs, end, offsets=()):
|
||||
self.pairs = pairs
|
||||
self.end = end
|
||||
self.offsets = offsets
|
||||
|
||||
def get(self, name):
|
||||
matches = [value for key, value in self.pairs if key.lower() == name.lower()]
|
||||
@@ -36,6 +37,9 @@ class Block:
|
||||
raise ValueError("duplicate UI setting")
|
||||
return matches[0] if matches else None
|
||||
|
||||
def offset(self, name):
|
||||
return next(at for (key, _), at in zip(self.pairs, self.offsets) if key.lower() == name.lower())
|
||||
|
||||
|
||||
def parse(text):
|
||||
tokens = []
|
||||
@@ -51,17 +55,17 @@ def parse(text):
|
||||
raise ValueError("invalid config.vdf")
|
||||
|
||||
def block(index, nested=False):
|
||||
pairs = []
|
||||
pairs, offsets = [], []
|
||||
while index < len(tokens):
|
||||
token, offset = tokens[index]
|
||||
if token == '}':
|
||||
if not nested:
|
||||
raise ValueError("unexpected closing brace")
|
||||
return Block(pairs, offset), index + 1
|
||||
return Block(pairs, offset, offsets), index + 1
|
||||
if not token.startswith('"') or index + 1 == len(tokens):
|
||||
raise ValueError("missing config value")
|
||||
key = token[1:-1]
|
||||
value = tokens[index + 1][0]
|
||||
value, at = tokens[index + 1]
|
||||
index += 2
|
||||
if value == '{':
|
||||
value, index = block(index, True)
|
||||
@@ -70,9 +74,10 @@ def parse(text):
|
||||
else:
|
||||
raise ValueError("invalid config value")
|
||||
pairs.append((key, value))
|
||||
offsets.append(at)
|
||||
if nested:
|
||||
raise ValueError("unclosed config block")
|
||||
return Block(pairs, len(text)), index
|
||||
return Block(pairs, len(text), offsets), index
|
||||
|
||||
return block(0)[0]
|
||||
|
||||
|
||||
@@ -87,7 +87,7 @@ x64_map_direct() {
|
||||
[ -f "$STEAM_X64/config/config.vdf" ] || return 0
|
||||
if [ "$mode" = write ] && pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then return 0; fi
|
||||
python3 - "$mode" "$STEAM_X64/config/config.vdf" "$STEAM_X64/appcache/appinfo.vdf" "$X64_HOME/direct-auto.json" \
|
||||
"$X64_HOME/direct-sniper" "$STEAM_X64/steamapps:/mnt/droiddeck-sd/x86-64/steamapps" "$(x64_default_tool)" \
|
||||
"$X64_HOME/direct-sniper" "$STEAM_X64/steamapps:/mnt/droiddeck-sd/x86-64/steamapps:$X64_HOME/shared/arm64/steamapps" "$(x64_default_tool)" \
|
||||
"$REAL_HOME/.bl-compat-pending" ${BL_X64_DIRECT_APPS:-550} \
|
||||
<<'PY' || { [ "$mode" = live ] || step "could not map titles to DroidDeck direct"; }
|
||||
# Steam does not swap an installed build when the tool changes: a title installed for Windows stays on Proton.
|
||||
@@ -520,39 +520,8 @@ ln -sfn "$STEAM_X64/ubuntu12_32" "$X64_HOME/.steam/bin32"
|
||||
ln -sfn "$STEAM_X64/ubuntu12_64" "$X64_HOME/.steam/bin64"
|
||||
ln -sfn "$STEAM_X64/linux32" "$X64_HOME/.steam/sdk32"
|
||||
ln -sfn "$STEAM_X64/linux64" "$X64_HOME/.steam/sdk64"
|
||||
# The client's bwrap probe (steam-runtime-check-requirements) needs user namespaces, which no Android app has.
|
||||
srt_real=$STEAM_X64/steamrt64/pv-runtime/steam-runtime-steamrt
|
||||
srt_shim=$X64_HOME/steamrt-shim
|
||||
if [ -d "$srt_real" ]; then
|
||||
rm -rf "$srt_shim"
|
||||
mkdir -p "$srt_shim/bin"
|
||||
for e in "$srt_real"/* "$srt_real"/.[!.]*; do
|
||||
[ -e "$e" ] || continue
|
||||
[ "$(basename "$e")" = bin ] || ln -s "$e" "$srt_shim/$(basename "$e")"
|
||||
done
|
||||
for e in "$srt_real"/bin/*; do ln -s "$e" "$srt_shim/bin/$(basename "$e")"; done
|
||||
rm -f "$srt_shim/bin/steam-runtime-check-requirements"
|
||||
printf '#!/bin/sh
|
||||
exit 0
|
||||
' > "$srt_shim/bin/steam-runtime-check-requirements"
|
||||
chmod 755 "$srt_shim/bin/steam-runtime-check-requirements"
|
||||
rm -f "$srt_shim/bin/steam-runtime-launch-client"
|
||||
cat > "$srt_shim/bin/steam-runtime-launch-client" <<'LAUNCH'
|
||||
#!/bin/sh
|
||||
while [ $# -gt 0 ]; do
|
||||
case $1 in
|
||||
--) shift; break ;;
|
||||
--directory=*) cd "${1#--directory=}" || exit 127 ;;
|
||||
--env=*) export "${1#--env=}" ;;
|
||||
--unset-env=*) unset "${1#--unset-env=}" ;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
[ $# -gt 0 ] || exit 0
|
||||
exec "$@"
|
||||
LAUNCH
|
||||
chmod 755 "$srt_shim/bin/steam-runtime-launch-client"
|
||||
fi
|
||||
# Valve's Steam Runtime container needs user namespaces and a session-bus launcher; steamrt-shim stands in for both.
|
||||
droiddeck-steamrt-shim "$STEAM_X64/steamrt64" "$X64_HOME/steamrt-shim" || rm -rf "$X64_HOME/steamrt-shim"
|
||||
# Valve's platform libraries ship without soname links (pressure-vessel makes them); ldconfig adds them here.
|
||||
srt_libs=$X64_HOME/steamrt-libs
|
||||
rm -rf "$srt_libs"
|
||||
@@ -641,6 +610,7 @@ RUN
|
||||
printf '"InstallConfigStore"\n{\n\t"Software"\n\t{\n\t\t"Valve"\n\t\t{\n\t\t\t"Steam"\n\t\t\t{\n\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n' \
|
||||
> "$STEAM_X64/config/config.vdf"
|
||||
fi
|
||||
x64_share x86-64
|
||||
x64_map_direct
|
||||
# Each wrapper execs droiddeck-x64-arm-proton through an arm64 binary, which FEX hands straight to the CPU.
|
||||
arm_tools=$ARM_STEAM/compatibilitytools.d
|
||||
@@ -690,9 +660,9 @@ VDF
|
||||
# Each client keeps its own libraries; written only while no x86 client runs, as it rewrites these on exit.
|
||||
if ! pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1; then
|
||||
listing_ok=0
|
||||
if python3 - "$STEAM_X64" "${BL_X64_STEAM_LIBRARIES:-}" "$STEAM_X64/config/libraryfolders.vdf" "$STEAM_X64/steamapps/libraryfolders.vdf" <<'PY'; then
|
||||
if BL_X64_SHARED=$X64_HOME/shared/arm64 python3 - "$STEAM_X64" "${BL_X64_STEAM_LIBRARIES:-}" "$STEAM_X64/config/libraryfolders.vdf" "$STEAM_X64/steamapps/libraryfolders.vdf" <<'PY'; then
|
||||
import json, os, re, sys
|
||||
keep = {os.path.realpath(sys.argv[1])}
|
||||
keep = {os.path.realpath(sys.argv[1]), os.path.realpath(os.environ["BL_X64_SHARED"])}
|
||||
# Without the session's list nothing is known about the card: leave the folders as they are.
|
||||
if not sys.argv[2]:
|
||||
sys.exit(3)
|
||||
@@ -942,6 +912,14 @@ x64_exec() {
|
||||
exec "${BL_FEX:-/usr/local/bin/FEX}" "$STEAM_X64/steamrt64/steam" "$@"
|
||||
}
|
||||
|
||||
x64_share() {
|
||||
pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1 && return 0
|
||||
pgrep -f 'steamrtarm64/steam( |$)' >/dev/null 2>&1 && return 0
|
||||
[ -d "$STEAM_X64/steamapps" ] && [ -d "$ARM_STEAM/steamapps" ] || return 0
|
||||
droiddeck-steam-share "$1" "$ARM_STEAM" "$STEAM_X64" /mnt/droiddeck-sd/x86-64 "$X64_HOME/shared" ||
|
||||
step "could not share the games between the clients"
|
||||
}
|
||||
|
||||
# Steam renews its token every few days and refuses old copies: copy the newest every start, never while a client runs.
|
||||
x64_sync_login() {
|
||||
pgrep -f 'steamrt64/steam( |$)' >/dev/null 2>&1 && return 0
|
||||
@@ -1058,6 +1036,7 @@ PY
|
||||
|
||||
case "${1:-}" in
|
||||
--sync-login) x64_sync_login; exit 0 ;;
|
||||
--share) x64_share arm64; exit 0 ;;
|
||||
--prepare) x64_prepare; exit 0 ;;
|
||||
--exec) shift; x64_exec "$@" ;;
|
||||
--gpu) x64_gpu; exit $? ;;
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/bin/bash
|
||||
# droiddeck-steamrt-shim <client runtime dir> <shim dir>
|
||||
# Builds <shim dir> from the Steam Runtime container the client carries and exits 0, or removes it and exits 1
|
||||
# when the client carries none.
|
||||
set -eu
|
||||
client=$1
|
||||
shim=$2
|
||||
srt_real=$client/pv-runtime/steam-runtime-steamrt
|
||||
if [ ! -d "$srt_real" ]; then
|
||||
probe=$(find "$client" -maxdepth 4 -name steam-runtime-check-requirements -path '*/bin/*' -print -quit 2>/dev/null || true)
|
||||
srt_real=${probe:+${probe%/bin/*}}
|
||||
fi
|
||||
if [ -z "$srt_real" ] || [ ! -d "$srt_real" ]; then
|
||||
rm -rf "$shim"
|
||||
exit 1
|
||||
fi
|
||||
rm -rf "$shim"
|
||||
trap 'rm -rf "$shim"' ERR
|
||||
mkdir -p "$shim/bin"
|
||||
for e in "$srt_real"/* "$srt_real"/.[!.]*; do
|
||||
[ -e "$e" ] || continue
|
||||
[ "$(basename "$e")" = bin ] || ln -s "$e" "$shim/$(basename "$e")"
|
||||
done
|
||||
for e in "$srt_real"/bin/*; do
|
||||
[ -e "$e" ] || continue
|
||||
ln -s "$e" "$shim/bin/$(basename "$e")"
|
||||
done
|
||||
# The client's bwrap probe (steam-runtime-check-requirements) needs user namespaces, which no Android app has.
|
||||
rm -f "$shim/bin/steam-runtime-check-requirements"
|
||||
printf '#!/bin/sh
|
||||
exit 0
|
||||
' > "$shim/bin/steam-runtime-check-requirements"
|
||||
chmod 755 "$shim/bin/steam-runtime-check-requirements"
|
||||
# Valve's launcher asks a service on the session bus; proot is already the container, so the command runs here.
|
||||
rm -f "$shim/bin/steam-runtime-launch-client"
|
||||
cat > "$shim/bin/steam-runtime-launch-client" <<'LAUNCH'
|
||||
#!/bin/sh
|
||||
while [ $# -gt 0 ]; do
|
||||
case $1 in
|
||||
--) shift; break ;;
|
||||
--directory=*) cd "${1#--directory=}" || exit 127 ;;
|
||||
--env=*) export "${1#--env=}" ;;
|
||||
--unset-env=*) unset "${1#--unset-env=}" ;;
|
||||
--directory|--env|--unset-env)
|
||||
[ $# -ge 2 ] || exit 127
|
||||
case $1 in
|
||||
--directory) cd "$2" || exit 127 ;;
|
||||
--env) export "$2" ;;
|
||||
--unset-env) unset "$2" ;;
|
||||
esac
|
||||
shift ;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
[ $# -gt 0 ] || exit 0
|
||||
exec "$@"
|
||||
LAUNCH
|
||||
chmod 755 "$shim/bin/steam-runtime-launch-client"
|
||||
@@ -25,6 +25,8 @@ Android: an EOS sign-in step that falls back to a browser (a consent Epic asks f
|
||||
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.
|
||||
|
||||
Battle.net.exe in Battle.net's prefix is handed to droiddeck-battlenet, which runs the whole launch.
|
||||
|
||||
droiddeck-store-launch <the arguments Steam gave the compat tool>
|
||||
"""
|
||||
|
||||
@@ -291,6 +293,27 @@ def create_prefix(compat_data, proton, timeout=120):
|
||||
CLOUD_TIMEOUT = 15.0
|
||||
CLOUD_STORES = ("gog", "epic")
|
||||
STORE_GAME = 10
|
||||
RAN = 11
|
||||
RAN_FAILED = 12
|
||||
BATTLENET = "/usr/local/bin/droiddeck-battlenet"
|
||||
BATTLENET_EXE = re.compile(r"(?i)/compatdata/2596113170/pfx/drive_c/Program Files \(x86\)/Battle\.net/Battle\.net\.exe$")
|
||||
BATTLENET_LAUNCH = re.compile(r'(?i)^--exec=\s*"?launch\s+([A-Za-z0-9_]{1,16})"?$')
|
||||
|
||||
|
||||
def battlenet(argv, env=os.environ):
|
||||
if env.get("BL_BATTLENET"):
|
||||
return None
|
||||
exe, code = False, None
|
||||
for raw in argv:
|
||||
arg = raw.strip().strip('"').strip("'")
|
||||
if BATTLENET_EXE.search(arg.replace("\\", "/")):
|
||||
exe = True
|
||||
found = BATTLENET_LAUNCH.match(arg)
|
||||
if found:
|
||||
code = found.group(1)
|
||||
if not exe:
|
||||
return None
|
||||
return [BATTLENET, "launch", code] if code else [BATTLENET, "open"]
|
||||
|
||||
|
||||
def cloud_on(sidecar):
|
||||
@@ -511,6 +534,10 @@ def main(argv):
|
||||
pass
|
||||
rest = rest[2:]
|
||||
return exited(rest, code)
|
||||
command = battlenet(argv)
|
||||
if command is not None:
|
||||
log("battlenet " + " ".join(command[1:]))
|
||||
return RAN if subprocess.call(command) == 0 else RAN_FAILED
|
||||
found = find_store_game(argv)
|
||||
if found is None:
|
||||
return 0
|
||||
|
||||
@@ -15,7 +15,18 @@ import threading
|
||||
|
||||
BIN = Path(__file__).resolve().parent
|
||||
RUNTIME = Path('/usr/local/lib/droiddeck-xbox')
|
||||
DLLS = ('xgameruntime.dll', 'winhttp.dll', 'windows.web.dll', 'twinapi.appcore.dll', 'libnghttp2.dll')
|
||||
DLLS = ('xgameruntime.dll', 'winhttp.dll', 'windows.web.dll', 'twinapi.appcore.dll', 'wintypes.dll', 'libnghttp2.dll')
|
||||
CLASSES = {
|
||||
'twinapi.appcore.dll': ('Windows.ApplicationModel.DataTransfer.DataTransferManager',
|
||||
'Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation',
|
||||
'Windows.System.Profile.AnalyticsInfo', 'Windows.System.UserProfile.AdvertisingManager',
|
||||
'Windows.UI.ViewManagement.ApplicationView'),
|
||||
'windows.web.dll': ('Windows.Data.Json.JsonArray', 'Windows.Data.Json.JsonObject', 'Windows.Data.Json.JsonValue'),
|
||||
'wintypes.dll': ('Windows.Foundation.PropertyValue', 'Windows.Foundation.Collections.PropertySet',
|
||||
'Windows.Foundation.Metadata.ApiInformation', 'Windows.Storage.Streams.Buffer',
|
||||
'Windows.Storage.Streams.DataWriter'),
|
||||
}
|
||||
CLASS_KEY = 'Software\\Microsoft\\WindowsRuntime\\ActivatableClassId\\'
|
||||
|
||||
|
||||
def bridge(upstream):
|
||||
@@ -102,6 +113,30 @@ def bridge(upstream):
|
||||
return server.getsockname()[1], key.decode('ascii'), close
|
||||
|
||||
|
||||
def register_classes(proton, prefix, env):
|
||||
try:
|
||||
registry = (prefix / 'system.reg').read_text(encoding='utf-8', errors='replace')
|
||||
except OSError:
|
||||
return
|
||||
missing = [(name, dll) for dll, names in CLASSES.items() for name in names
|
||||
if '[%s]' % (CLASS_KEY + name).replace('\\', '\\\\') not in registry]
|
||||
if not missing:
|
||||
return
|
||||
text = 'Windows Registry Editor Version 5.00\r\n\r\n' + ''.join(
|
||||
'[HKEY_LOCAL_MACHINE\\%s%s]\r\n"DllPath"="C:\\\\windows\\\\system32\\\\%s"\r\n\r\n' % (CLASS_KEY, name, dll)
|
||||
for name, dll in missing)
|
||||
with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
|
||||
source = Path(temporary) / 'classes.reg'
|
||||
source.write_bytes(b'\xff\xfe' + text.encode('utf-16-le'))
|
||||
try:
|
||||
failed = subprocess.run([proton, 'run', 'reg.exe', 'import', 'Z:' + str(source).replace('/', '\\')],
|
||||
stdout=sys.stderr, env=env, timeout=90).returncode != 0
|
||||
except subprocess.TimeoutExpired:
|
||||
failed = True
|
||||
if failed:
|
||||
print('droiddeck-xbox: Windows Runtime class registration failed; launching without it', file=sys.stderr)
|
||||
|
||||
|
||||
def wine(argv, source_env=None):
|
||||
source_env = os.environ if source_env is None else source_env
|
||||
with open(source_env['DROIDDECK_XBOX_COMMAND_FILE'], encoding='utf-8') as file:
|
||||
@@ -109,7 +144,8 @@ def wine(argv, source_env=None):
|
||||
if len(command) < 3 or command[1] != 'waitforexitandrun' or len(argv) != 1:
|
||||
raise ValueError('Invalid Xbox Proton invocation')
|
||||
env = dict(source_env)
|
||||
env.pop('DROIDDECK_XBOX_CREDENTIAL_SOCKET', None)
|
||||
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
||||
env.pop(name, None)
|
||||
env.pop('DROIDDECK_XBOX_COMMAND_FILE', None)
|
||||
prefix = Path(source_env['STEAM_COMPAT_DATA_PATH']) / 'pfx'
|
||||
prefix.parent.mkdir(parents=True, exist_ok=True)
|
||||
@@ -124,6 +160,7 @@ def wine(argv, source_env=None):
|
||||
if target.is_symlink():
|
||||
target.unlink()
|
||||
shutil.copyfile(RUNTIME / 'windows' / name, target)
|
||||
register_classes(command[0], prefix, env)
|
||||
overrides = ';'.join(name[:-4] + '=n' for name in DLLS if name != 'libnghttp2.dll')
|
||||
env['WINEDLLOVERRIDES'] = overrides + ';' + env.get('WINEDLLOVERRIDES', '')
|
||||
return subprocess.call([*command[:2], argv[0], *command[3:]], env=env)
|
||||
@@ -171,7 +208,8 @@ def launch(command, env):
|
||||
owned_env = dict(env, DROIDDECK_XBOX_ACTIVE='1', DROIDDECK_XBOX_COMMAND_FILE=str(context),
|
||||
XODUS_SOCKET=reply['socket'], XODUS_BRIDGE_PORT=str(port), XODUS_BRIDGE_KEY=key,
|
||||
XODUS_LOG='off', RUST_LOG='off', XODUS_SAVE_SYNC='auto' if sidecar.get('cloud', True) else 'off')
|
||||
owned_env.pop('DROIDDECK_XBOX_CREDENTIAL_SOCKET', None)
|
||||
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
||||
owned_env.pop(name, None)
|
||||
if reply.get('playfab'):
|
||||
owned_env['XODUS_XSTS_PLAYFAB'] = reply['playfab']
|
||||
content = folder / '.xbox-content'
|
||||
|
||||
@@ -69,7 +69,10 @@ bl_store_launch() {
|
||||
fi
|
||||
[ -x /usr/local/bin/droiddeck-store-launch ] || return 0
|
||||
/usr/local/bin/droiddeck-store-launch "$@"
|
||||
[ $? -eq 10 ] && BL_STORE_EXIT=1
|
||||
rc=$?
|
||||
[ $rc -eq 10 ] && BL_STORE_EXIT=1
|
||||
[ $rc -eq 11 ] && exit 0
|
||||
[ $rc -eq 12 ] && exit 1
|
||||
return 0
|
||||
}
|
||||
|
||||
@@ -1113,10 +1116,89 @@ def requested_tool(request, catalog):
|
||||
|
||||
|
||||
def game_requests(directory=None):
|
||||
value = read_json(state_path("games.json", directory))
|
||||
if value.get("version") != 1 or not isinstance(value.get("games"), dict):
|
||||
return {}
|
||||
return value["games"]
|
||||
return read_game_requests(directory)[0]
|
||||
|
||||
|
||||
def read_game_requests(directory=None):
|
||||
try:
|
||||
with open(state_path("games.json", directory), encoding="utf-8") as f:
|
||||
text = f.read()
|
||||
value = json.loads(text)
|
||||
except (OSError, ValueError):
|
||||
return {}, None
|
||||
if not isinstance(value, dict) or value.get("version") != 1 or not isinstance(value.get("games"), dict):
|
||||
return {}, text
|
||||
return value["games"], text
|
||||
|
||||
|
||||
def write_game_requests(requests, original, directory=None):
|
||||
path = state_path("games.json", directory)
|
||||
try:
|
||||
with open(path, encoding="utf-8") as f:
|
||||
if f.read() != original:
|
||||
return False
|
||||
except OSError:
|
||||
if original is not None:
|
||||
return False
|
||||
return write_json(path, {"version": 1, "games": requests})
|
||||
|
||||
|
||||
def valid_game_request(app, request):
|
||||
return (isinstance(app, str) and re.fullmatch(r"[1-9][0-9]*", app) is not None and int(app) <= 0xFFFFFFFF and
|
||||
(request is None or isinstance(request, dict) and isinstance(request.get("dir"), str) and
|
||||
request["dir"] != "" and isinstance(request.get("valve"), bool)))
|
||||
|
||||
|
||||
def settle_game_requests(requests, state, current, catalog, missing_is_cleared=False):
|
||||
recorded = state.get("games_applied")
|
||||
if isinstance(recorded, dict):
|
||||
applied = dict(recorded)
|
||||
else:
|
||||
applied = dict(requests) if "tools" in state else {}
|
||||
by_name = {t["name"]: t for t in catalog}
|
||||
out = dict(requests)
|
||||
for app, request in requests.items():
|
||||
if not valid_game_request(app, request) or app not in applied or applied[app] != request:
|
||||
continue
|
||||
if request is None:
|
||||
del out[app]
|
||||
continue
|
||||
wanted = requested_tool(request, catalog)
|
||||
if wanted is None:
|
||||
continue
|
||||
if app in current:
|
||||
picked = current[app]
|
||||
elif missing_is_cleared:
|
||||
picked = ""
|
||||
else:
|
||||
continue
|
||||
if picked == wanted:
|
||||
continue
|
||||
tool = by_name.get(picked)
|
||||
if tool and tool["dir"]:
|
||||
out[app] = {"valve": tool["valve"], "dir": tool["dir"]}
|
||||
else:
|
||||
del out[app]
|
||||
return out, out != requests
|
||||
|
||||
|
||||
def settled_game_requests(state, current, catalog, missing_is_cleared=False, directory=None):
|
||||
for _ in range(2):
|
||||
requests, text = read_game_requests(directory)
|
||||
settled, moved = settle_game_requests(requests, state, current, catalog, missing_is_cleared)
|
||||
if not moved or write_game_requests(settled, text, directory):
|
||||
return settled
|
||||
return None
|
||||
|
||||
|
||||
def applied_game_requests(requests, overrides, state):
|
||||
recorded = state.get("games_applied")
|
||||
before = recorded if isinstance(recorded, dict) else {}
|
||||
if requests is None:
|
||||
return dict(before)
|
||||
return {app: request if app in overrides and overrides[app] is not DEFERRED_GAME_TOOL else before[app]
|
||||
for app, request in requests.items()
|
||||
if app in overrides and overrides[app] is not DEFERRED_GAME_TOOL or app in before}
|
||||
|
||||
|
||||
def requested_games(requests, catalog, runnable=None):
|
||||
@@ -1140,6 +1222,32 @@ def requested_games(requests, catalog, runnable=None):
|
||||
return resolved
|
||||
|
||||
|
||||
OWN_PROTON = "DroidDeck-Proton"
|
||||
ARCH_WORDS = re.compile(r"(?i)aarch64|arm64|x86_64|x86-64|amd64")
|
||||
|
||||
|
||||
def own_builds(tools):
|
||||
return [t for t in tools if isinstance(t, dict) and not t.get("valve") and
|
||||
isinstance(t.get("dir"), str) and t["dir"].startswith(OWN_PROTON) and t.get("name")]
|
||||
|
||||
|
||||
def build_key(name):
|
||||
return [int(n) for n in re.findall(r"\d+", ARCH_WORDS.sub(" ", name))]
|
||||
|
||||
|
||||
def own_proton_moves(state, catalog):
|
||||
names = {t["name"] for t in catalog}
|
||||
before = state.get("tools") if isinstance(state.get("tools"), list) else ()
|
||||
seen = state.get("own_builds") if isinstance(state.get("own_builds"), list) else []
|
||||
known = {n for n in seen if isinstance(n, str)} | {t["name"] for t in own_builds(before)} | {t["name"] for t in own_builds(catalog)}
|
||||
state["own_builds"] = sorted(known)
|
||||
builds = own_builds(catalog)
|
||||
if not builds:
|
||||
return None, set()
|
||||
newest = max(builds, key=lambda t: (build_key(t["dir"]), t["dir"]))["name"]
|
||||
return newest, known - names
|
||||
|
||||
|
||||
def now_ms():
|
||||
import time
|
||||
return int(time.time() * 1000)
|
||||
@@ -1300,13 +1408,29 @@ def register_default(config_path, apps=(), protect=(), default=None, catalog=Non
|
||||
catalog = tool_catalog(os.path.dirname(os.path.dirname(os.path.abspath(config_path))),
|
||||
dict(protect) if isinstance(protect, dict) else {name: name for name in protect})
|
||||
names = [t["name"] for t in catalog]
|
||||
newest, gone = own_proton_moves(state, catalog)
|
||||
previous, applied, chosen = state.get("default"), state.get("applied"), state.get("seq")
|
||||
if default is None:
|
||||
if settle:
|
||||
default, state = choose_default(current.get("0", ""), state, read_json(state_path("request.json", directory)), catalog)
|
||||
else:
|
||||
default = state.get("default") if state.get("default") in names else TOOL
|
||||
if settle and newest and default == TOOL and state.get("applied") == applied and state.get("seq") == chosen and (
|
||||
previous in gone or not state.get("own_proton")):
|
||||
default = newest
|
||||
state.update(default=newest, seq=now_ms(), source="update")
|
||||
if settle and newest:
|
||||
state["own_proton"] = True
|
||||
if newest:
|
||||
for app, name in list(current.items()):
|
||||
if app != "0" and name in gone:
|
||||
set_mapping(tokens, mapping, app, newest)
|
||||
current[app] = newest
|
||||
if isinstance(state.get("auto"), dict):
|
||||
state["auto"] = {app: newest if name in gone else name for app, name in state["auto"].items()}
|
||||
steam_root = os.path.dirname(os.path.dirname(os.path.abspath(config_path)))
|
||||
overrides = requested_games(game_requests(directory), catalog)
|
||||
requests = settled_game_requests(state, current, catalog, not steam_running(), directory)
|
||||
overrides = requested_games(requests or {}, catalog)
|
||||
managed = state.get("auto", {}).keys() if isinstance(state.get("auto"), dict) else ()
|
||||
native_choices = state.get("native_choices", ())
|
||||
native = native_targets(steam_root, set(apps) | set(picks) | set(managed) | set(native_choices))
|
||||
@@ -1325,6 +1449,7 @@ def register_default(config_path, apps=(), protect=(), default=None, catalog=Non
|
||||
state["auto"] = {app: tool for app, tool in auto.items() if tool is not NATIVE_CHOICE}
|
||||
state["native_choices"] = sorted(app for app, tool in auto.items() if tool is NATIVE_CHOICE)
|
||||
state["picked"] = picked_after(current, changes)
|
||||
state["games_applied"] = applied_game_requests(requests, overrides, state)
|
||||
state.pop("native", None)
|
||||
state["tools"] = catalog
|
||||
state.setdefault("default", default)
|
||||
|
||||
Reference in new issue
Block a user