mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
* fix(desktop): run a store game's exe through its launcher so the EA environment and Origin process are set up * fix(desktop): keep a store game's prefix and resolve its launcher through symlinks and deep folders * fix(desktop): keep the exe's resolved compatdata folder when running its launcher and find the sidecar beside a symlinked exe
431 lines
16 KiB
Python
431 lines
16 KiB
Python
#!/usr/bin/python3
|
|
import fcntl
|
|
import hashlib
|
|
import os
|
|
import runpy
|
|
import shutil
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
HOME = os.environ.get("HOME") or "/root"
|
|
BIN = "/usr/local/bin"
|
|
FEX = os.path.join(BIN, "droiddeck-fex")
|
|
GPU = os.path.join(BIN, "droiddeck-gpu")
|
|
PROTON_RUN = os.path.join(BIN, "droiddeck-proton-run")
|
|
APPIMAGE_RUN = os.path.join(BIN, "droiddeck-appimage-run")
|
|
SCRIPT_RUN = os.path.join(BIN, "droiddeck-script-run")
|
|
STEAM_LAUNCH = os.path.join(BIN, "droiddeck-steam-launch")
|
|
STORE_LAUNCH = os.path.join(BIN, "droiddeck-store-launch")
|
|
PROGRAMS = os.path.join(BIN, "droiddeck-desktop-programs")
|
|
CACHE = os.path.join(HOME, ".cache", "droiddeck")
|
|
IMPORTS = {"appimage": ("/opt/appimages/user", "app"), "folder": ("/opt/droiddeck-apps", "entry")}
|
|
SHARED_FOLDERS = ("alarms", "android", "audiobooks", "dcim", "documents", "download", "movies", "music",
|
|
"notifications", "pictures", "podcasts", "recordings", "ringtones")
|
|
SCAN_LIMIT = 4000
|
|
APPS_DIR = "/usr/local/share/applications"
|
|
WINDOWS = (".exe", ".bat", ".cmd", ".com", ".msi")
|
|
NOT_PROGRAMS = (".dll", ".sys", ".drv", ".cpl", ".ocx", ".efi", ".scr", ".mui")
|
|
SCRIPTS = (".sh", ".bash")
|
|
MACHINES = {3: "i386", 62: "x86_64", 183: "arm64"}
|
|
EMULATED = (3, 62)
|
|
QUICK_FAILURE = 20
|
|
IMPORT_WAIT = 1800
|
|
WINDOWS_TYPES = ("application/x-ms-dos-executable", "application/x-msdownload",
|
|
"application/vnd.microsoft.portable-executable", "application/x-msi", "application/x-bat")
|
|
SCRIPT_TYPES = ("application/x-shellscript", "text/x-shellscript")
|
|
LINUX_TYPES = ("application/x-executable", "application/x-pie-executable", "application/vnd.appimage")
|
|
ENTRIES = (
|
|
("droiddeck-open.desktop", "Run", "", WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES),
|
|
("droiddeck-open-window.desktop", "Run in a Desktop Window", "--window ", WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES),
|
|
("droiddeck-open-terminal.desktop", "Run in Konsole", "--terminal ", SCRIPT_TYPES + LINUX_TYPES),
|
|
)
|
|
|
|
|
|
def say(message):
|
|
print("droiddeck-open: %s" % message, file=sys.stderr, flush=True)
|
|
|
|
|
|
def notify(title, body, icon="dialog-error"):
|
|
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 head(path, size=64):
|
|
try:
|
|
with open(path, "rb") as f:
|
|
return f.read(size)
|
|
except OSError:
|
|
return b""
|
|
|
|
|
|
def machine(data):
|
|
if len(data) < 20 or data[:4] != b"\x7fELF":
|
|
return None
|
|
return int.from_bytes(data[18:20], "big" if data[5] == 2 else "little")
|
|
|
|
|
|
def kind(path):
|
|
data = head(path)
|
|
ext = os.path.splitext(path)[1].lower()
|
|
if data[:4] == b"\x7fELF":
|
|
return "appimage" if data[8:11] == b"AI\x02" or ext == ".appimage" else "elf"
|
|
if ext in NOT_PROGRAMS:
|
|
return None
|
|
if ext in WINDOWS or data[:2] == b"MZ":
|
|
return "windows"
|
|
if data[:2] == b"#!" or ext in SCRIPTS:
|
|
return "script"
|
|
return None
|
|
|
|
|
|
def noexec(path):
|
|
try:
|
|
return bool(os.statvfs(path).f_flag & os.ST_NOEXEC)
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def interpreter(path):
|
|
line = head(path, 256).split(b"\n", 1)[0].rstrip(b"\r")
|
|
if line.startswith(b"#!"):
|
|
words = line[2:].decode("utf-8", "replace").split()
|
|
if words:
|
|
return words
|
|
return ["/bin/bash"]
|
|
|
|
|
|
def for_x86(script):
|
|
return subprocess.call([FEX, "needs", os.path.dirname(script)], stdout=subprocess.DEVNULL,
|
|
stderr=subprocess.DEVNULL) == 0
|
|
|
|
|
|
def runnable(path):
|
|
if not noexec(path) or machine(head(path)) in EMULATED:
|
|
return path
|
|
st = os.stat(path)
|
|
key = hashlib.sha1(os.path.realpath(path).encode("utf-8")).hexdigest()[:16]
|
|
copy = os.path.join(CACHE, "exec", key, os.path.basename(path))
|
|
try:
|
|
same = os.stat(copy)
|
|
if same.st_size == st.st_size and same.st_mtime_ns == st.st_mtime_ns:
|
|
return copy
|
|
except OSError:
|
|
pass
|
|
os.makedirs(os.path.dirname(copy), exist_ok=True)
|
|
shutil.copyfile(path, copy + ".tmp")
|
|
os.utime(copy + ".tmp", ns=(st.st_atime_ns, st.st_mtime_ns))
|
|
os.chmod(copy + ".tmp", 0o755)
|
|
os.replace(copy + ".tmp", copy)
|
|
return copy
|
|
|
|
|
|
def appimage(path):
|
|
st = os.stat(path)
|
|
real = os.path.realpath(path)
|
|
key = hashlib.sha1(("%s\0%d\0%d" % (real, st.st_size, st.st_mtime_ns)).encode("utf-8")).hexdigest()[:16]
|
|
images = os.path.join(CACHE, "appimages")
|
|
return once(key, lambda: unpacked(path, real, key, images, os.path.join(images, key)))
|
|
|
|
|
|
def once(key, make):
|
|
locks = os.path.join(CACHE, "locks")
|
|
os.makedirs(locks, exist_ok=True)
|
|
with open(os.path.join(locks, key), "w") as lock:
|
|
fcntl.flock(lock, fcntl.LOCK_EX)
|
|
return make()
|
|
|
|
|
|
def unpacked(path, real, key, images, folder):
|
|
if os.path.exists(os.path.join(folder, "app", "AppRun")):
|
|
return folder
|
|
earlier = import_of(key, "appimage")
|
|
if earlier:
|
|
return earlier
|
|
name = os.path.splitext(os.path.basename(path))[0]
|
|
notify("Preparing %s" % name, "Unpacking it for its first start.", "system-run")
|
|
work = folder + ".tmp"
|
|
shutil.rmtree(work, ignore_errors=True)
|
|
os.makedirs(work)
|
|
status = subprocess.call([FEX, "extract", real], cwd=work, stdout=subprocess.DEVNULL)
|
|
unpacked = os.path.realpath(os.path.join(work, "squashfs-root"))
|
|
if status != 0 or not os.path.isdir(unpacked):
|
|
shutil.rmtree(work, ignore_errors=True)
|
|
return imported("appimage", real, key, name)
|
|
os.replace(unpacked, os.path.join(work, "app"))
|
|
if os.path.islink(os.path.join(work, "squashfs-root")):
|
|
os.unlink(os.path.join(work, "squashfs-root"))
|
|
for file, value in (("name", name), ("arch", MACHINES.get(machine(head(path)), "")), ("source", real)):
|
|
with open(os.path.join(work, file), "w", encoding="utf-8") as f:
|
|
f.write(value + "\n")
|
|
for other in os.listdir(images):
|
|
old = os.path.join(images, other)
|
|
if other != key + ".tmp" and (head(os.path.join(old, "source"), 4096).decode("utf-8", "replace").strip() == real):
|
|
shutil.rmtree(old, ignore_errors=True)
|
|
os.replace(work, folder)
|
|
return folder
|
|
|
|
|
|
def import_of(key, what):
|
|
root, made = IMPORTS[what]
|
|
try:
|
|
entries = sorted(os.listdir(root))
|
|
except OSError:
|
|
return None
|
|
for entry in entries:
|
|
folder = os.path.join(root, entry)
|
|
if head(os.path.join(folder, "desktop-import"), 64).split(b"\n", 1)[0] == key.encode() \
|
|
and os.path.exists(os.path.join(folder, made)):
|
|
return folder
|
|
return None
|
|
|
|
|
|
def imported(what, real, key, name):
|
|
launch = os.environ.get("BL_LAUNCH_DIR")
|
|
if not launch or not os.path.isdir(launch):
|
|
raise RuntimeError("%s cannot run from here; add it in DroidDeck with Add an app." % name)
|
|
result = os.path.join(launch, "desktop-import-%s.result" % key)
|
|
request = os.path.join(launch, "desktop-import-%s.request" % key)
|
|
with open(request + ".tmp", "w", encoding="utf-8") as f:
|
|
f.write("id=%s\nkind=%s\npath=%s\n" % (key, what, real))
|
|
os.replace(request + ".tmp", request)
|
|
if what == "appimage":
|
|
notify("Adding %s to DroidDeck" % name, "It is unpacked once, then it starts, and it stays in the menu.", "system-run")
|
|
else:
|
|
notify("Adding %s to DroidDeck" % name, "Shared storage cannot run its programs, so the folder is copied in "
|
|
"once; then it starts, and it stays in the menu.", "system-run")
|
|
deadline = time.monotonic() + IMPORT_WAIT
|
|
while time.monotonic() < deadline:
|
|
try:
|
|
with open(result, encoding="utf-8") as f:
|
|
answer = f.read().strip()
|
|
except OSError:
|
|
time.sleep(1)
|
|
continue
|
|
os.unlink(result)
|
|
verdict, _, detail = answer.partition(" ")
|
|
if verdict == "ok" and os.path.exists(os.path.join(detail, IMPORTS[what][1])):
|
|
return detail
|
|
raise RuntimeError(detail or "DroidDeck could not add %s." % name)
|
|
raise RuntimeError("DroidDeck did not finish adding %s." % name)
|
|
|
|
|
|
def game_folder(path):
|
|
real = os.path.realpath(path)
|
|
folder = os.path.dirname(real)
|
|
if in_steam_library(real) or not noexec(folder):
|
|
return None
|
|
top = storage_root(folder)
|
|
parts = os.path.relpath(folder, top).split(os.sep)
|
|
if folder == top or (len(parts) == 1 and parts[0].lower() in SHARED_FOLDERS):
|
|
return None
|
|
seen = 0
|
|
for root, dirs, files in os.walk(folder):
|
|
if root[len(folder):].count(os.sep) >= 3:
|
|
dirs[:] = []
|
|
for name in files:
|
|
child = os.path.join(root, name)
|
|
if child == real:
|
|
continue
|
|
seen += 1
|
|
if seen > SCAN_LIMIT:
|
|
return None
|
|
if machine(head(child)) not in (None,) + EMULATED:
|
|
return folder
|
|
return None
|
|
|
|
|
|
def in_steam_library(path):
|
|
return "steamapps" in os.path.realpath(path).lower().split(os.sep)
|
|
|
|
|
|
def storage_root(folder):
|
|
top = folder
|
|
try:
|
|
dev = os.stat(folder).st_dev
|
|
while os.path.dirname(top) != top and os.stat(os.path.dirname(top)).st_dev == dev:
|
|
top = os.path.dirname(top)
|
|
except OSError:
|
|
pass
|
|
return top
|
|
|
|
|
|
def copied_in(path):
|
|
real = os.path.realpath(path)
|
|
key = hashlib.sha1(("folder\0%s" % real).encode("utf-8")).hexdigest()[:16]
|
|
name = os.path.basename(os.path.dirname(real))
|
|
return once(key, lambda: import_of(key, "folder") or imported("folder", real, key, name))
|
|
|
|
|
|
def steam_title(path):
|
|
try:
|
|
run = runpy.run_path(PROTON_RUN)
|
|
root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or run["STEAM_ROOT"]
|
|
target = run["locate"](path, root)
|
|
return target.appid if run["steam_launches"](target, path, root) else None
|
|
except (OSError, ValueError, KeyError, IndexError):
|
|
return None
|
|
|
|
|
|
def exe_prefix(path):
|
|
try:
|
|
run = runpy.run_path(PROTON_RUN)
|
|
root = os.environ.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or run["STEAM_ROOT"]
|
|
target = run["locate"](path, root)
|
|
return ["--prefix", target.appid, "--compatdata", target.compatdata]
|
|
except (OSError, ValueError, KeyError, IndexError):
|
|
return None
|
|
|
|
|
|
def store_launcher(path):
|
|
try:
|
|
return runpy.run_path(STORE_LAUNCH)["store_launcher"](path)
|
|
except (OSError, ValueError, KeyError):
|
|
return None
|
|
|
|
|
|
def command(path, args, what, window=False, appid=None):
|
|
folder = os.path.dirname(path)
|
|
if what == "steam":
|
|
return [STEAM_LAUNCH, "desktop", appid], folder
|
|
if what == "windows":
|
|
launcher = None if args else store_launcher(path)
|
|
prefix = exe_prefix(path) if launcher else None
|
|
keep = prefix or []
|
|
return [PROTON_RUN] + (["--window"] if window else []) + keep + [launcher or path] + args, folder
|
|
if what == "x86 script":
|
|
return [FEX, "run", "--mode", "on", "--for", folder, "--"] + interpreter(path) + [path] + args, folder
|
|
if what == "script":
|
|
return interpreter(path) + [path] + args, folder
|
|
if what == "appimage":
|
|
return [APPIMAGE_RUN, appimage(path)] + args, folder
|
|
if what == "folder":
|
|
return [SCRIPT_RUN, copied_in(path)] + args, folder
|
|
return [FEX, "run", "--mode", "auto", "--", runnable(path)] + args, folder
|
|
|
|
|
|
def on_desktop(env):
|
|
return env.get("BL_DESKTOP") == "1" and not env.get("GAMESCOPE_WAYLAND_DISPLAY") and os.access(GPU, os.X_OK)
|
|
|
|
|
|
def unattended(env):
|
|
try:
|
|
out = os.fstat(1)
|
|
except OSError:
|
|
return True
|
|
if stat.S_ISCHR(out.st_mode):
|
|
return not os.isatty(1)
|
|
folder = env.get("BL_DEBUG_DIR")
|
|
try:
|
|
log = os.stat(os.path.join(folder, "desktop.log")) if folder else None
|
|
except OSError:
|
|
log = None
|
|
return log is not None and (log.st_dev, log.st_ino) == (out.st_dev, out.st_ino)
|
|
|
|
|
|
def placed(cmd, what, mode, env):
|
|
if mode == "terminal" and what not in ("windows", "steam") and shutil.which("konsole"):
|
|
return ["konsole", "--hold", "-e"] + cmd
|
|
if mode == "window" or what in ("script", "steam") or not on_desktop(env):
|
|
return cmd
|
|
if mode == "exec" and what != "windows" and not unattended(env):
|
|
return cmd
|
|
return [GPU] + cmd
|
|
|
|
|
|
def install(directory=APPS_DIR):
|
|
os.makedirs(directory, exist_ok=True)
|
|
defaults = []
|
|
for file, name, option, types in ENTRIES:
|
|
body = ("[Desktop Entry]\nType=Application\nName=%s\nIcon=system-run\nExec=%s %s%%f\nTerminal=false\n"
|
|
"NoDisplay=true\nMimeType=%s;\n" % (name, os.path.join(BIN, "droiddeck-open"), option, ";".join(types)))
|
|
write(os.path.join(directory, file), body)
|
|
for mime in WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES:
|
|
defaults.append("%s=%s" % (mime, ENTRIES[0][0]))
|
|
added = ["%s=%s" % (mime, ";".join(f for f, _, _, types in ENTRIES if mime in types) + ";")
|
|
for mime in WINDOWS_TYPES + SCRIPT_TYPES + LINUX_TYPES]
|
|
write(os.path.join(directory, "mimeapps.list"),
|
|
"[Default Applications]\n%s\n\n[Added Associations]\n%s\n" % ("\n".join(defaults), "\n".join(added)))
|
|
return 0
|
|
|
|
|
|
def write(path, text):
|
|
try:
|
|
with open(path, encoding="utf-8") as f:
|
|
if f.read() == text:
|
|
return
|
|
except OSError:
|
|
pass
|
|
with open(path + ".tmp", "w", encoding="utf-8") as f:
|
|
f.write(text)
|
|
os.replace(path + ".tmp", path)
|
|
|
|
|
|
def main(argv):
|
|
mode = "run"
|
|
if argv and argv[0] == "--install":
|
|
return install()
|
|
if argv and argv[0] in ("--window", "--terminal", "--exec"):
|
|
mode = argv.pop(0)[2:]
|
|
if argv and argv[0] == "--":
|
|
argv.pop(0)
|
|
if not argv:
|
|
say("usage: droiddeck-open [--window | --terminal | --exec] FILE [ARGS...] | --install")
|
|
return 2
|
|
path = os.path.abspath(argv[0])
|
|
what = kind(path)
|
|
if what is None:
|
|
say("%s is not a program this desktop can run" % path)
|
|
if mode != "exec":
|
|
notify("Cannot run %s" % os.path.basename(path), "It is not a Windows or Linux program or a script.")
|
|
return 126
|
|
linux_game = what in ("script", "elf") and mode == "run" and in_steam_library(path)
|
|
appid = steam_title(path) if (what == "windows" and mode != "window") or linux_game else None
|
|
if appid:
|
|
what = "steam"
|
|
elif what == "script" and for_x86(path):
|
|
what = "x86 script"
|
|
elif what in ("script", "elf") and not (mode == "exec" and machine(head(path)) in EMULATED) and game_folder(path):
|
|
what = "folder"
|
|
try:
|
|
cmd, folder = command(path, argv[1:], what, mode == "window", appid)
|
|
except (OSError, RuntimeError) as error:
|
|
say(str(error))
|
|
notify("Cannot run %s" % os.path.basename(path), str(error))
|
|
return 126
|
|
cmd = placed(cmd, what, mode, os.environ)
|
|
if mode != "exec" or not sys.stderr.isatty():
|
|
say("%s (%s): %s" % (path, what, " ".join(cmd[:4])))
|
|
if not (mode == "exec" and what in ("elf", "script", "x86 script")):
|
|
try:
|
|
os.chdir(folder)
|
|
except OSError:
|
|
pass
|
|
if mode == "exec":
|
|
os.execv(cmd[0], cmd)
|
|
started = time.monotonic()
|
|
try:
|
|
status = subprocess.call(cmd)
|
|
except OSError as error:
|
|
status = 127
|
|
say("%s: %s" % (cmd[0], error))
|
|
if status != 0 and time.monotonic() - started < QUICK_FAILURE:
|
|
notify("%s did not start" % os.path.basename(path),
|
|
"It exited with status %d; the session's desktop.log says why." % status)
|
|
if what == "windows":
|
|
try:
|
|
subprocess.call([sys.executable, PROGRAMS])
|
|
except OSError as error:
|
|
say("%s: %s" % (PROGRAMS, error))
|
|
return status
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main(sys.argv[1:]))
|