From 1760f008ae7a9238fca81ec15e99dd70dcacaa2e Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 14:39:31 -0500 Subject: [PATCH 01/16] fix(desktop): Flatpak and Snap apps get the game GPU setting (#2295) The session's TU_DEBUG=sysmem is meant for the Steam client and Chromium-based apps. Flatpak and Snap apps inherited it, so emulators and other programs installed that way rendered through system memory. droiddeck-game-env now holds the Chromium check next to game_gpu, and a small droiddeck-game-gpu wrapper applies both to any program. The AppImage, Flatpak and Snap launchers use it, so the rule lives in one place. --- README.md | 2 +- .../launcher/session/SessionFiles.kt | 1 + .../usr/local/bin/droiddeck-appimage-run | 9 +- .../usr/local/bin/droiddeck-flatpak-run | 12 ++- .../overlay/usr/local/bin/droiddeck-game-env | 15 ++- .../overlay/usr/local/bin/droiddeck-game-gpu | 42 ++++++++ .../overlay/usr/local/bin/droiddeck-snap-run | 13 ++- tools/tests/test_game_environment.py | 40 ++++++++ tools/tests/test_game_gpu_launchers.py | 98 +++++++++++++++++++ 9 files changed, 221 insertions(+), 11 deletions(-) create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-game-gpu create mode 100644 tools/tests/test_game_gpu_launchers.py diff --git a/README.md b/README.md index dfadf1bf5a..3139abd284 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ DroidDeck is [GPL-3.0](LICENSE). Steam and Proton belong to Valve Corporation. V - The proot fast path orders bindings like [PRoot](https://github.com/proot-me/proot)'s `path/binding.c` (GPL-2.0-or-later). - DiRT 3 and DiRT Showdown keep their telemetry socket the way RoccoC's DiRTTelemetryErrorFix (MIT) does, based on the fix by Carsten Gottschling. - Zink on PowerVR keeps colour textures in colour with Icenowy Zheng's upstream [Mesa](https://gitlab.freedesktop.org/mesa/mesa) fix d55418dae7 (MIT), carried as a runtime patch. -- Games and AppImage programs such as emulators use [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's per render pass memory choice. The Steam client and Chromium-based apps keep `TU_DEBUG=sysmem`. +- Games and AppImage, Flatpak and Snap programs such as emulators use [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's per render pass memory choice. The Steam client and Chromium-based apps keep `TU_DEBUG=sysmem`. - Black Ops III and Dark Souls Remastered start without [umu-protonfixes](https://github.com/Open-Wine-Components/umu-protonfixes) (BSD-2-Clause), whose `311210.py` and `570940.py` fail under ARM64 Proton. - [ReSkate](https://github.com/Dingo-Shenanigans/ReSkate) (GPL-3.0) by Dingo Shenanigans uses the launch option from its README and D3D12 feature level 12_1. - The arm64 client's sign in was checked by reading Steam's saved token with the `ConnectCache` format from [deadlock-api-ingest](https://github.com/deadlock-api/deadlock-api-ingest). diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 1b4e78ad00..3cefd44c06 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -40,6 +40,7 @@ object SessionFiles { WinComponents.publish(context) val files = arrayOf( "usr/local/bin/droiddeck-game-env" to "usr/local/bin/droiddeck-game-env", + "usr/local/bin/droiddeck-game-gpu" to "usr/local/bin/droiddeck-game-gpu", "usr/local/bin/droiddeck-diagnostic-inventory" to "usr/local/bin/droiddeck-diagnostic-inventory", "usr/local/bin/droiddeck-wincomponents" to "usr/local/bin/droiddeck-wincomponents", "usr/local/bin/droiddeck-msi-install" to "usr/local/bin/droiddeck-msi-install", diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-appimage-run b/tools/linuxfs/overlay/usr/local/bin/droiddeck-appimage-run index cb32d4696e..b4a1910f24 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-appimage-run +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-appimage-run @@ -25,12 +25,6 @@ if [ -n "$(find -H "$APPDIR" -maxdepth 4 \( -name chrome-sandbox -o -name chrome flags+=(--ozone-platform=x11) fi fi -if [ -n "${DROIDDECK_GAME_TU_DEBUG+set}" ]; then - if [ ${#flags[@]} -eq 0 ]; then - if [ -n "$DROIDDECK_GAME_TU_DEBUG" ]; then export TU_DEBUG=$DROIDDECK_GAME_TU_DEBUG; else unset TU_DEBUG; fi - fi - unset DROIDDECK_GAME_TU_DEBUG -fi qt=$(cat "$dir/qt" 2>/dev/null) case $qt in wayland|xcb) ;; *) qt=auto ;; esac wayland=${GAMESCOPE_WAYLAND_DISPLAY:-${WAYLAND_DISPLAY:-}} @@ -61,6 +55,9 @@ if [ -x /usr/local/bin/droiddeck-fex ]; then *) run=(/usr/local/bin/droiddeck-fex run --mode "$fex" --for "$APPDIR" -- "$APPDIR/AppRun") ;; esac fi +gpu=("${BASH_SOURCE[0]%/*}/droiddeck-game-gpu") +[ ${#flags[@]} -gt 0 ] && gpu+=(--chromium) +run=("${gpu[@]}" -- "${run[@]}") echo "== appimage $ARGV0 ($APPDIR) ${flags[*]} FEX $fex Qt $qt${QT_QPA_PLATFORM:+ ($QT_QPA_PLATFORM)}" cd "$APPDIR" || exit 1 started=$(mktemp "${TMPDIR:-/tmp}/droiddeck-appimage.XXXXXX") diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak-run b/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak-run index 08e6e7a265..6fdd22f3d0 100644 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak-run +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak-run @@ -11,8 +11,16 @@ if [ -n "${BL_INSIDE:-}" ] || [ -n "${GAMESCOPE_WAYLAND_DISPLAY:-}" ]; then export XDG_SESSION_TYPE=x11 socket=(--nosocket=wayland --socket=x11) fi +app= +for arg in "$@"; do + case $arg in -*) ;; *) app=$arg; break ;; esac +done +gpu=("${BASH_SOURCE[0]%/*}/droiddeck-game-gpu") +location= +[ -n "$app" ] && location=$(flatpak info --show-location "$app" 2>/dev/null) +[ -n "$location" ] && gpu+=(--for "$location/files") echo "== flatpak run ${socket[*]} $*" if [ -z "${DBUS_SESSION_BUS_ADDRESS:-}" ] && command -v dbus-run-session >/dev/null 2>&1; then - exec dbus-run-session -- flatpak run "${socket[@]}" "$@" + exec "${gpu[@]}" -- dbus-run-session -- flatpak run "${socket[@]}" "$@" fi -exec flatpak run "${socket[@]}" "$@" +exec "${gpu[@]}" -- flatpak run "${socket[@]}" "$@" diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index 9fb3c39c66..a2e130b5a1 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -11,6 +11,7 @@ import tempfile from pathlib import Path GAME_TU_DEBUG = "DROIDDECK_GAME_TU_DEBUG" +CHROMIUM_FILES = {"chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"} SYNC_KEYS = ("BL_SYNC", "BL_SYNC_FALLBACK", "BL_FSYNC_FIRST", "BL_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC") SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists" PACK_KEYS = ("WINESERVER", "BL_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC") @@ -346,11 +347,23 @@ def win_components(compat, app_id): return "" -def game_gpu(env): +def chromium_app(folder): + root = os.path.realpath(folder) + for top, dirs, files in os.walk(root): + if CHROMIUM_FILES.intersection(files) or CHROMIUM_FILES.intersection(dirs): + return True + if os.path.relpath(top, root).count(os.sep) >= 2: + dirs[:] = [] + return False + + +def game_gpu(env, keep=False): if GAME_TU_DEBUG not in env: return env result = env.copy() value = result.pop(GAME_TU_DEBUG) + if keep: + return result if value: result["TU_DEBUG"] = value else: diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-gpu b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-gpu new file mode 100755 index 0000000000..40055010d0 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-gpu @@ -0,0 +1,42 @@ +#!/usr/bin/python3 +import os +import runpy +import sys + +BIN_DIR = os.path.dirname(os.path.abspath(__file__)) + + +def main(argv): + keep = False + folder = None + while argv and argv[0] != "--": + if argv[0] == "--chromium": + keep = True + argv = argv[1:] + elif argv[0] == "--for" and len(argv) > 1: + folder = argv[1] + argv = argv[2:] + else: + break + if argv and argv[0] == "--": + argv = argv[1:] + if not argv: + print("usage: droiddeck-game-gpu [--chromium] [--for FOLDER] -- PROGRAM [ARGS...]", file=sys.stderr) + return 2 + env = dict(os.environ) + try: + game_env = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-env")) + if folder and not keep: + keep = game_env["chromium_app"](folder) + env = game_env["game_gpu"](env, keep) + except Exception as error: + print("droiddeck-game-gpu: the game GPU setting was not applied (%s)" % error, file=sys.stderr) + try: + os.execvpe(argv[0], argv, env) + except OSError as error: + print("droiddeck-game-gpu: %s: %s" % (argv[0], error.strerror), file=sys.stderr) + return 127 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-snap-run b/tools/linuxfs/overlay/usr/local/bin/droiddeck-snap-run index 6529005a24..9e8acf9cc8 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-snap-run +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-snap-run @@ -1,11 +1,13 @@ #!/usr/bin/python3 import os import re +import runpy import shlex import sys import yaml +BIN_DIR = os.path.dirname(os.path.abspath(__file__)) SNAP_DIR = "/snap" HOST_DIRS = ("/etc", "/home", "/root", "/tmp", "/run", "/var/snap", "/var/lib/snapd", "/var/tmp", "/var/log", "/media", "/mnt", "/snap", "/usr/src", "/lib/modules") @@ -59,6 +61,15 @@ def content_binds(name, meta, env): return out +def game_gpu(env, snap): + try: + game_env = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-env")) + return game_env["game_gpu"](env, game_env["chromium_app"](snap)) + except Exception as error: + print(f"droiddeck-snap-run: the game GPU setting was not applied ({error})", file=sys.stderr) + return env + + def main(argv): if len(argv) < 3: print("usage: droiddeck-snap-run SNAP APP [ARG...]", file=sys.stderr) @@ -72,7 +83,7 @@ def main(argv): revision = os.path.basename(os.path.realpath(f"{SNAP_DIR}/{name}/current")) home = os.environ.get("HOME", "/root") snap = f"{SNAP_DIR}/{name}/{revision}" - env = dict(os.environ) + env = game_gpu(dict(os.environ), snap) for k in ("LD_PRELOAD", "LD_LIBRARY_PATH"): env.pop(k, None) env.update({ diff --git a/tools/tests/test_game_environment.py b/tools/tests/test_game_environment.py index 6e21ec2de7..48d08a0b59 100644 --- a/tools/tests/test_game_environment.py +++ b/tools/tests/test_game_environment.py @@ -902,6 +902,46 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(MODULE["apply_config"](env, config, "42")["TU_DEBUG"], "sysmem") self.assertNotIn("TU_DEBUG", MODULE["apply_config"](env, config, "43")) + def test_a_chromium_app_keeps_the_sessions_turnip_debug(self): + gpu = MODULE["game_gpu"] + self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "KEEP": "1"}, True), + {"TU_DEBUG": "sysmem", "KEEP": "1"}) + self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"}, True), {"TU_DEBUG": "sysmem"}) + self.assertEqual(gpu({"TU_DEBUG": "sysmem"}, True), {"TU_DEBUG": "sysmem"}) + + def test_chromium_files_are_found_four_levels_deep_and_no_further(self): + chromium = MODULE["chromium_app"] + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) / "app" + (root / "usr/lib/tool").mkdir(parents=True) + (root / "usr/lib/tool/libtool.so").write_bytes(b"") + self.assertFalse(chromium(str(root))) + for name in ("chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"): + found = root / "a/b/c" / name + found.parent.mkdir(parents=True, exist_ok=True) + found.write_bytes(b"") + self.assertTrue(chromium(str(root)), name) + found.unlink() + deep = root / "a/b/c/d/chrome-sandbox" + deep.parent.mkdir(parents=True) + deep.write_bytes(b"") + self.assertFalse(chromium(str(root))) + self.assertFalse(chromium(str(Path(tmp) / "missing"))) + + def test_chromium_detection_does_not_follow_links_inside_the_app(self): + chromium = MODULE["chromium_app"] + with tempfile.TemporaryDirectory() as tmp: + other = Path(tmp) / "other" + other.mkdir() + (other / "chrome-sandbox").write_bytes(b"") + root = Path(tmp) / "app" + root.mkdir() + (root / "linked").symlink_to(other, target_is_directory=True) + self.assertFalse(chromium(str(root))) + link = Path(tmp) / "app-link" + link.symlink_to(other, target_is_directory=True) + self.assertTrue(chromium(str(link))) + def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self): cap = MODULE["vram_cap"] self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096") diff --git a/tools/tests/test_game_gpu_launchers.py b/tools/tests/test_game_gpu_launchers.py new file mode 100644 index 0000000000..71f39c22ca --- /dev/null +++ b/tools/tests/test_game_gpu_launchers.py @@ -0,0 +1,98 @@ +import os +import runpy +import shutil +import subprocess +import sys +import tempfile +import unittest +from pathlib import Path + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +KEYS = ("TU_DEBUG", "DROIDDECK_GAME_TU_DEBUG") +SESSION = {"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": ""} + + +class GameGpuLaunchersTest(unittest.TestCase): + def setUp(self): + self.tmp = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.tmp, True) + self.out = self.tmp / "env" + self.tools = self.tmp / "tools" + self.tools.mkdir() + self.app = self.tmp / "deploy" + (self.app / "files/bin").mkdir(parents=True) + self.report = self.tools / "report" + self.report.write_text("#!/bin/sh\nfor k in %s; do eval \"echo $k=\\${$k-unset}\"; done > %s\n" + % (" ".join(KEYS), self.out)) + self.report.chmod(0o755) + flatpak = self.tools / "flatpak" + flatpak.write_text("#!/bin/sh\n" + "if [ \"$1\" = info ]; then [ \"$3\" = org.example.App ] && echo %s; exit 0; fi\n" + "exec %s\n" % (self.app, self.report)) + flatpak.chmod(0o755) + + def chromium(self): + (self.app / "files/lib/browser").mkdir(parents=True) + (self.app / "files/lib/browser/chrome_100_percent.pak").write_bytes(b"") + + def run_env(self, command, session): + env = {k: v for k, v in os.environ.items() if k not in KEYS + ("DBUS_SESSION_BUS_ADDRESS", "GAMESCOPE_WAYLAND_DISPLAY")} + env.update(session, PATH="%s:%s" % (self.tools, env.get("PATH", "/usr/bin:/bin")), + DBUS_SESSION_BUS_ADDRESS="unix:path=/dev/null") + result = subprocess.run(command, env=env, capture_output=True, text=True, timeout=30) + self.assertEqual(0, result.returncode, result.stderr) + return dict(line.split("=", 1) for line in self.out.read_text().splitlines()) + + def wrapper(self, *args, session=SESSION): + return self.run_env([sys.executable, str(BIN / "droiddeck-game-gpu"), *args, "--", str(self.report)], session) + + def flatpak(self, session=SESSION): + return self.run_env(["bash", str(BIN / "droiddeck-flatpak-run"), "--command=app", "org.example.App"], session) + + def test_the_wrapper_gives_a_program_the_game_setting(self): + self.assertEqual({"TU_DEBUG": "unset", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.wrapper()) + self.assertEqual("gmem", self.wrapper(session={"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "gmem"})["TU_DEBUG"]) + + def test_the_wrapper_keeps_the_session_setting_for_chromium(self): + self.assertEqual({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.wrapper("--chromium")) + self.assertEqual("unset", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"]) + self.chromium() + self.assertEqual("sysmem", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"]) + + def test_without_the_game_setting_the_wrapper_changes_nothing(self): + self.assertEqual("sysmem", self.wrapper(session={"TU_DEBUG": "sysmem"})["TU_DEBUG"]) + self.assertEqual("unset", self.wrapper(session={})["TU_DEBUG"]) + + def test_the_wrapper_reports_a_missing_program(self): + result = subprocess.run([sys.executable, str(BIN / "droiddeck-game-gpu"), "--", str(self.tmp / "missing")], + capture_output=True, text=True, timeout=30) + self.assertEqual(127, result.returncode) + self.assertEqual(2, subprocess.run([sys.executable, str(BIN / "droiddeck-game-gpu")], capture_output=True, + timeout=30).returncode) + + def test_a_flatpak_app_gets_the_game_setting(self): + self.assertEqual({"TU_DEBUG": "unset", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.flatpak()) + self.assertEqual("nolrz", self.flatpak({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"})["TU_DEBUG"]) + + def test_a_chromium_flatpak_keeps_the_session_setting(self): + self.chromium() + self.assertEqual({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.flatpak()) + + def test_a_flatpak_without_the_game_setting_is_unchanged(self): + self.assertEqual("sysmem", self.flatpak({"TU_DEBUG": "sysmem"})["TU_DEBUG"]) + + def test_a_snap_gets_the_game_setting_unless_it_is_chromium(self): + try: + snap_run = runpy.run_path(str(BIN / "droiddeck-snap-run")) + except ImportError: + self.skipTest("PyYAML is not installed") + gpu = snap_run["game_gpu"] + snap = self.app / "files" + self.assertEqual({"KEEP": "1"}, gpu(dict(SESSION, KEEP="1"), str(snap))) + self.assertEqual({"TU_DEBUG": "nolrz"}, gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"}, str(snap))) + self.chromium() + self.assertEqual({"TU_DEBUG": "sysmem"}, gpu(dict(SESSION), str(snap))) + + +if __name__ == "__main__": + unittest.main() From a7c10e3f5164632fd352850ec4ccac40280dc9a3 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Sun, 8 Nov 2026 16:53:01 -0500 Subject: [PATCH 02/16] fix(session): give Steam a session bus so launches stop hanging at the install script (#2303) --- .../overlay/usr/local/bin/droiddeck-session | 17 ++++++ tools/tests/test_session_bus.py | 55 +++++++++++++++++++ 2 files changed, 72 insertions(+) create mode 100644 tools/tests/test_session_bus.py diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 0428d8f1f0..415f9472fe 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -1338,6 +1338,23 @@ case $mode in echo "== network: no dbus-daemon or netmanager in this runtime; the client will show no connection" exit 69 fi + # Without a session bus libdbus autolaunches one under the game; it never exits and Steam's + # reaper waits on it, so the launch or exit never finishes. + if [ -z "${DBUS_SESSION_BUS_ADDRESS:-}" ]; then + _bl_bus=${XDG_RUNTIME_DIR:-/run/droiddeck}/bus + rm -f "$_bl_bus" + dbus-daemon --session --address="unix:path=$_bl_bus" --nofork --nopidfile & + for _ in $(seq 1 50); do + [ -S "$_bl_bus" ] && break + nap 0.1 + done + if [ -S "$_bl_bus" ]; then + export DBUS_SESSION_BUS_ADDRESS="unix:path=$_bl_bus" + echo "== session bus up at $_bl_bus" + else + echo "== session bus did not come up; programs may start their own" + fi + fi _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") diff --git a/tools/tests/test_session_bus.py b/tools/tests/test_session_bus.py new file mode 100644 index 0000000000..3528500f1d --- /dev/null +++ b/tools/tests/test_session_bus.py @@ -0,0 +1,55 @@ +import re +import shutil +import subprocess +import tempfile +import unittest +from pathlib import Path + +SESSION = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-session" + +FAKE_DAEMON = """#!/usr/bin/env python3 +import socket, sys, time +address = next(a for a in sys.argv if a.startswith("--address=")) +path = address.split("unix:path=", 1)[1] +open(sys.argv[0] + ".args", "w").write(" ".join(sys.argv[1:])) +s = socket.socket(socket.AF_UNIX) +s.bind(path) +time.sleep(5) +""" + + +class SessionBusTest(unittest.TestCase): + def setUp(self): + self.root = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.root, True) + self.bin = self.root / "bin" + self.bin.mkdir() + self.runtime = self.root / "run" + self.runtime.mkdir() + daemon = self.bin / "dbus-daemon" + daemon.write_text(FAKE_DAEMON) + daemon.chmod(0o755) + + def run_block(self, env_address=""): + match = re.search(r'^ *if \[ -z "\$\{DBUS_SESSION_BUS_ADDRESS:-\}" \]; then\n.*?^ *fi\n *fi\n', + SESSION.read_text(), re.M | re.S) + self.assertIsNotNone(match) + script = "nap() { sleep \"$1\"; }\n" + match.group(0) + 'echo "ADDRESS=$DBUS_SESSION_BUS_ADDRESS"\nkill %1 2>/dev/null\n' + env = {"PATH": "%s:/usr/bin:/bin" % self.bin, "XDG_RUNTIME_DIR": str(self.runtime)} + if env_address: + env["DBUS_SESSION_BUS_ADDRESS"] = env_address + return subprocess.run(["bash", "-c", script], env=env, capture_output=True, text=True, timeout=30).stdout + + def test_steam_mode_exports_its_own_session_bus(self): + out = self.run_block() + self.assertIn("ADDRESS=unix:path=%s/bus" % self.runtime, out) + self.assertIn("--session", (self.bin / "dbus-daemon.args").read_text()) + + def test_an_existing_session_bus_is_kept(self): + out = self.run_block("unix:path=/somewhere/else") + self.assertIn("ADDRESS=unix:path=/somewhere/else", out) + self.assertFalse((self.bin / "dbus-daemon.args").exists()) + + +if __name__ == "__main__": + unittest.main() From ecd916d43f5ecc8041fb6fbfd1d39559602dffce Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 18:32:40 -0500 Subject: [PATCH 03/16] fix(input): show the panel tabs under the controls-below-the-game bar (#2302) * fix(input): show the panel tabs under the controls-below-the-game bar * fix(input): take the tab row out of the game, not the controls below it --- .../java/com/droiddeck/launcher/SessionActivity.kt | 13 ++++++++++--- .../droiddeck/launcher/session/SessionDisplay.kt | 4 ++-- .../launcher/session/SessionDisplayTest.kt | 7 +++++++ 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 86e57cd4fe..45a831f954 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -3609,7 +3609,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { val width = sessionRoot.width val height = sessionRoot.height val wanted = controlsBelowWanted() - val gameHeight = if (wanted) com.droiddeck.launcher.session.SessionDisplay.unfoldedGameHeight(width, height) + val tabRow = unfoldedColumn?.getChildAt(0)?.height?.let { + it - (com.droiddeck.launcher.ui.BAR_HEIGHT.value * resources.displayMetrics.density + 0.5f).toInt() + } ?: 0 + val gameHeight = if (wanted) com.droiddeck.launcher.session.SessionDisplay.unfoldedGameHeight(width, height, tabRow) else FrameLayout.LayoutParams.MATCH_PARENT val params = surfaceView.layoutParams as FrameLayout.LayoutParams if (params.height != gameHeight) { @@ -3635,8 +3638,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { panel = OnScreenControls(this, padBridge, dock).also { it.updateLayout(primaryInputLayout) } val column = android.widget.LinearLayout(this).apply { orientation = android.widget.LinearLayout.VERTICAL - addView(unfoldedBar(), android.widget.LinearLayout.LayoutParams(android.widget.LinearLayout.LayoutParams.MATCH_PARENT, - (com.droiddeck.launcher.ui.BAR_HEIGHT.value * resources.displayMetrics.density + 0.5f).toInt())) + addView(unfoldedBar().apply { + addOnLayoutChangeListener { _, _, top, _, bottom, _, oldTop, _, oldBottom -> + if (bottom - top != oldBottom - oldTop) post { applyUnfoldedControls() } + } + }, android.widget.LinearLayout.LayoutParams(android.widget.LinearLayout.LayoutParams.MATCH_PARENT, + android.widget.LinearLayout.LayoutParams.WRAP_CONTENT)) addView(panel, android.widget.LinearLayout.LayoutParams(android.widget.LinearLayout.LayoutParams.MATCH_PARENT, 0, 1f)) } sessionRoot.addView(column, sessionRoot.indexOfChild(surfaceView) + 1) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionDisplay.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionDisplay.kt index 1cb526c90d..9b253d88a7 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionDisplay.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionDisplay.kt @@ -69,8 +69,8 @@ object SessionDisplay { const val UNFOLDED_MIN_DP = 600 - fun unfoldedGameHeight(width: Int, height: Int): Int = - minOf(width * 9 / 16, (height * UNFOLDED_MAX_GAME_SHARE).toInt()) and 1.inv() + fun unfoldedGameHeight(width: Int, height: Int, tabRow: Int = 0): Int = + (minOf(width * 9 / 16, (height * UNFOLDED_MAX_GAME_SHARE).toInt()) - tabRow.coerceAtLeast(0)).coerceAtLeast(0) and 1.inv() fun unfoldedControlsWanted( enabled: Boolean, diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionDisplayTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionDisplayTest.kt index 82512c0b91..7f3eec4092 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SessionDisplayTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionDisplayTest.kt @@ -60,6 +60,13 @@ class SessionDisplayTest { assertEquals(864, SessionDisplay.unfoldedGameHeight(1920, 1080)) } + @Test fun aTabRowUnderTheBarComesOutOfTheGameNotTheControls() { + assertEquals(1376, SessionDisplay.unfoldedGameHeight(2448, 1848, 0)) + assertEquals(1240, SessionDisplay.unfoldedGameHeight(2448, 1848, 136)) + assertEquals(1376, SessionDisplay.unfoldedGameHeight(2448, 1848, -20)) + assertEquals(0, SessionDisplay.unfoldedGameHeight(200, 100, 500)) + } + private fun unfoldedWanted( enabled: Boolean = true, controller: Boolean = false, From 92742f37c11d359848cee907f5125ce4f83f8b6e Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 18:40:57 -0500 Subject: [PATCH 04/16] fix(preload): answer netlink requests sent with write and writev (#2304) --- tools/linuxfs/preload/netif.c | 28 +++++++++++++ tools/tests/test_netlink_preload.py | 64 +++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) diff --git a/tools/linuxfs/preload/netif.c b/tools/linuxfs/preload/netif.c index d7f56e32ab..aeeeb9eb24 100644 --- a/tools/linuxfs/preload/netif.c +++ b/tools/linuxfs/preload/netif.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -1655,6 +1656,7 @@ static void reply_attr(struct nl_reply *out, unsigned char *message, int type, return; } attr = (struct rtattr *) (message + offset); + memset(attr, 0, total); attr->rta_type = (unsigned short) type; attr->rta_len = (unsigned short) RTA_LENGTH(len); if (len > 0) memcpy(RTA_DATA(attr), data, len); @@ -2155,3 +2157,29 @@ ssize_t send(int fd, const void *buffer, size_t length, int flags) { } return real(fd, buffer, length, flags); } + +ssize_t write(int fd, const void *buffer, size_t length) { + static ssize_t (*real)(int, const void *, size_t); + ssize_t rc; + if (bl_nl_owns(fd) && deliver(fd, buffer, length, 0, &rc)) return rc; + if (real == NULL) real = (ssize_t (*)(int, const void *, size_t)) dlsym(RTLD_NEXT, "write"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, buffer, length); +} + +ssize_t writev(int fd, const struct iovec *iov, int iovcnt) { + static ssize_t (*real)(int, const struct iovec *, int); + if (iovcnt >= 0 && bl_nl_owns(fd)) { + struct msghdr msg = { .msg_iov = (struct iovec *) iov, .msg_iovlen = (size_t) iovcnt }; + return sendmsg_request(fd, &msg, 0); + } + if (real == NULL) real = (ssize_t (*)(int, const struct iovec *, int)) dlsym(RTLD_NEXT, "writev"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, iov, iovcnt); +} diff --git a/tools/tests/test_netlink_preload.py b/tools/tests/test_netlink_preload.py index 64c3b9c97a..aedbdbd733 100644 --- a/tools/tests/test_netlink_preload.py +++ b/tools/tests/test_netlink_preload.py @@ -118,6 +118,7 @@ PROGRAM = r""" #include #include #include +#include #include #include @@ -317,6 +318,8 @@ static void *ordinary_traffic(void *argument) { probe_end(counts); require(counts[0] == 0, "ordinary setup avoids netlink lock"); + int pipes[2]; + require(pipe(pipes) == 0, "ordinary pipe setup"); probe_begin(0); const int rounds = 32; for (int round = 0; round < rounds; round++) { @@ -338,6 +341,15 @@ static void *ordinary_traffic(void *argument) { message.msg_name = &source; message.msg_namelen = sizeof(source); require(recvmsg(server, &message, 0) == 1 && buffer == 'z', "ordinary recvmsg"); + require(write(client, "w", 1) == 1, "ordinary write"); + require(read(server, &buffer, 1) == 1 && buffer == 'w', "ordinary read"); + char pair[2]; + struct iovec pieces[2] = {{.iov_base = "v", .iov_len = 1}, {.iov_base = "u", .iov_len = 1}}; + require(writev(client, pieces, 2) == 2, "ordinary writev"); + require(recv(server, pair, 2, MSG_WAITALL) == 2 && pair[0] == 'v' && pair[1] == 'u', + "ordinary writev data"); + require(write(pipes[1], "p", 1) == 1 && read(pipes[0], &buffer, 1) == 1 && buffer == 'p', + "ordinary pipe"); length = sizeof(source); require(getpeername(client, (struct sockaddr *)&source, &length) == 0, "ordinary peer"); const int options[] = {SO_TYPE, SO_DOMAIN, SO_PROTOCOL}; @@ -368,6 +380,8 @@ static void *ordinary_traffic(void *argument) { require(counts[2] == (unsigned)rounds, "ordinary traffic has only requested getpeername"); require(counts[3] == 0, "ordinary traffic avoids restoration fstat"); require(counts[4] == (unsigned)rounds * 3, "ordinary socket options use one syscall each"); + close(pipes[0]); + close(pipes[1]); close(client); close(server); if (server != listener) close(listener); @@ -798,6 +812,52 @@ static void connect_test(void) { close(descriptor); } +static ssize_t link_reply(int descriptor, const char *path, unsigned char *buffer, size_t capacity) { + struct { + struct nlmsghdr header; + struct ifinfomsg info; + } query = { + .header = {.nlmsg_len = sizeof(query), .nlmsg_type = RTM_GETLINK, + .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK, .nlmsg_seq = 42}, + .info = {.ifi_index = 1} + }; + struct iovec parts[2] = {{.iov_base = &query.header, .iov_len = sizeof(query.header)}, + {.iov_base = &query.info, .iov_len = sizeof(query.info)}}; + struct msghdr message = {.msg_iov = parts, .msg_iovlen = 2}; + ssize_t sent; + if (!strcmp(path, "send")) sent = send(descriptor, &query, sizeof(query), 0); + else if (!strcmp(path, "sendmsg")) sent = sendmsg(descriptor, &message, 0); + else if (!strcmp(path, "write")) sent = write(descriptor, &query, sizeof(query)); + else sent = writev(descriptor, parts, 2); + require(sent == sizeof(query), path); + ssize_t received = read(descriptor, buffer, capacity); + require(received > 0, "read reply"); + return received; +} + +static void write_test(void) { + const char *paths[] = {"send", "sendmsg", "write", "writev"}; + unsigned char expected[4096]; + int descriptor = route_socket(); + ssize_t expected_length = link_reply(descriptor, paths[0], expected, sizeof(expected)); + struct nlmsghdr *header = (struct nlmsghdr *)expected; + require(header->nlmsg_type == RTM_NEWLINK && header->nlmsg_seq == 42 + && header->nlmsg_pid == port_of(descriptor), "send reply"); + require(expected_length > (ssize_t)NLMSG_ALIGN(header->nlmsg_len), "acknowledged reply"); + struct nlmsghdr *acknowledgement = (struct nlmsghdr *)(expected + NLMSG_ALIGN(header->nlmsg_len)); + require(acknowledgement->nlmsg_type == NLMSG_ERROR + && ((struct nlmsgerr *)NLMSG_DATA(acknowledgement))->error == 0, "send acknowledgement"); + for (size_t index = 1; index < sizeof(paths) / sizeof(paths[0]); index++) { + unsigned char buffer[4096]; + ssize_t length = link_reply(descriptor, paths[index], buffer, sizeof(buffer)); + require(length == expected_length, "reply length"); + require(!memcmp(buffer, expected, length), "reply bytes"); + } + require(recv(descriptor, expected, sizeof(expected), MSG_DONTWAIT) == -1 && errno == EAGAIN, + "no extra replies"); + close(descriptor); +} + static void receive_test(void) { int descriptor = route_socket(); send_link(descriptor, 1, 0); @@ -985,6 +1045,7 @@ int main(int argc, char **argv) { else if (!strcmp(argv[1], "nonblocking")) send_timeout_test(1); else if (!strcmp(argv[1], "connect")) connect_test(); else if (!strcmp(argv[1], "receive")) receive_test(); + else if (!strcmp(argv[1], "write")) write_test(); else if (!strcmp(argv[1], "replace")) replacement_test(0); else if (!strcmp(argv[1], "raw_replace")) replacement_test(1); else if (!strcmp(argv[1], "shared")) shared_test(0); @@ -1160,6 +1221,9 @@ class NetlinkPreloadTest(unittest.TestCase): def test_kernel_connect_and_disconnect(self): self.run_program("connect") + def test_write_and_writev_requests_get_the_same_replies_as_send(self): + self.run_program("write") + def test_receive_sources_and_truncation(self): self.run_program("receive") From 6b110581ac167b1476d945db6b38327c63cd399e Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 18:45:53 -0500 Subject: [PATCH 05/16] fix(gog): install scripts' support files reach the prefix (#2294) * fix(gog): install scripts' support files reach the prefix A goggame-.script can copy files into the prefix with supportData actions: default INI files, Plugins.txt and other settings that mods such as one-click editions need. Only setRegistry actions were applied, so those games started without their configuration and ran as the base game. droiddeck-store-launch now applies supportData after the registry, once per script revision: copies from {app} and {supportDir} into {userdocs} and {localappdata}, matching paths without regard to case. Links are copied as links, paths outside those folders are refused, and existing files are replaced only when the action asks for it. * Keep GOG support data copies inside the game and prefix folders * Copy linked GOG support sources as links and keep a player's own links --- docs/development/stores.md | 9 + .../usr/local/bin/droiddeck-store-launch | 117 +++++++++++ tools/tests/test_store_launch.py | 191 +++++++++++++++++- 3 files changed, 316 insertions(+), 1 deletion(-) diff --git a/docs/development/stores.md b/docs/development/stores.md index 78855ea749..278c0cbd8d 100644 --- a/docs/development/stores.md +++ b/docs/development/stores.md @@ -244,6 +244,15 @@ self-extractor stops at "Path not found", so the values it installs are applied `witcher.exe` exits during startup. The language comes from the installed product's `goggame-.info`, and a script's own `setRegistry` entries always win over the built-in table. +The script's `supportData` actions run right after: files and folders from the game folder +(`{app}`) or its support files (`{supportDir}`, `support//`) are copied to `{userdocs}` and +`{localappdata}` in the prefix, and `type: folder` without a source creates the folder. Mods such +as one-click editions ship their `Plugins.txt` and INI files this way. Paths match without regard +to case, links are copied as links, and a path outside those folders is refused. A file the +player already has is replaced only when the action says `overwrite`. `.droiddeck-gog-support` in +the prefix holds the actions' hash, so they run once per script revision and a player's later +edits stay. + A GOG game's exe comes from its own manifest first: `goggame-.info`'s play task in category `game` (`isPrimary` first), or a primary `launcher` task for launcher games, whose `path` stays inside the folder; any other `goggame-*.info` in the folder supplies the task only when the diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch index 131c049062..b2e2b870e0 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch @@ -5,6 +5,7 @@ import binascii import json import os import re +import shutil import sys import time import subprocess @@ -352,6 +353,7 @@ def prepare_gog(sidecar, compat_data, launch_dir): GOG_SCRIPTS = "goggame-*.script" GOG_REGISTRY_MARK = ".droiddeck-gog-registry" +GOG_SUPPORT_MARK = ".droiddeck-gog-support" GOG_ROOTS = {"HKEY_LOCAL_MACHINE": "HKEY_LOCAL_MACHINE", "HKLM": "HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER": "HKEY_CURRENT_USER", "HKCU": "HKEY_CURRENT_USER", "HKEY_CLASSES_ROOT": "HKEY_CLASSES_ROOT", "HKCR": "HKEY_CLASSES_ROOT"} @@ -611,6 +613,120 @@ def apply_gog_registry(folder, compat_data, proton, timeout=90, installation=Non return "import-failed" + note +def gog_support_actions(folder): + found = [] + for script in sorted(Path(folder).glob(GOG_SCRIPTS)): + product = script.name[len("goggame-"):-len(".script")] + try: + actions = json.loads(script.read_text(encoding="utf-8-sig")).get("actions") + except (OSError, ValueError, AttributeError): + continue + for action in actions if isinstance(actions, list) else []: + install = action.get("install") if isinstance(action, dict) else None + if isinstance(install, dict) and install.get("action") == "supportData" \ + and isinstance(install.get("arguments"), dict): + found.append((product, install["arguments"])) + return found + + +def gog_support_bases(folder, product, pfx): + user = Path(pfx) / "drive_c" / "users" / "steamuser" + support = Path(folder) / "support" / product + return {"app": Path(folder), "supportdir": support, "support": support, + "userdocs": user / "Documents", "localappdata": user / "AppData" / "Local"} + + +def gog_inside(path, base): + root = os.path.realpath(base) + real = os.path.realpath(path) + return real == root or real.startswith(root + os.sep) + + +def gog_support_path(text, bases): + match = re.fullmatch(r"\{(\w+)\}(.*)", text) if isinstance(text, str) else None + if not match or match.group(1).lower() not in bases: + return None + parts = [part for part in re.split(r"[\\/]+", match.group(2)) if part] + if any(part in (".", "..") for part in parts): + return None + base = bases[match.group(1).lower()] + path = base + for part in parts: + exact = path / part + if not exact.exists() and path.is_dir(): + exact = next((child for child in path.iterdir() if child.name.lower() == part.lower()), exact) + path = exact + if path != base and not gog_inside(path.parent, base): + return None + return path, base + + +def gog_copy_file(source, target, root): + if not gog_inside(target.parent, root): + raise OSError("outside " + str(root)) + target.parent.mkdir(parents=True, exist_ok=True) + if target.is_symlink(): + target.unlink() + shutil.copy2(source, target, follow_symlinks=False) + + +def gog_support_data(folder, compat_data, proton): + actions = gog_support_actions(folder) + if not actions: + return "none" + pfx = Path(compat_data) / "pfx" if compat_data else None + if not pfx or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): + made = create_prefix(compat_data, proton) + if made not in ("present", "created") or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): + return "no-prefix" + stamp = hashlib.sha256(json.dumps(actions, sort_keys=True).encode("utf-8")).hexdigest() + marker = pfx / GOG_SUPPORT_MARK + try: + if marker.is_file() and marker.read_text() == stamp: + return "ready" + except OSError: + pass + copied = skipped = missing = 0 + for product, arguments in actions: + bases = gog_support_bases(folder, product, pfx) + found = gog_support_path(arguments.get("target"), bases) + origin = gog_support_path(arguments["source"], bases) if "source" in arguments else None + if found is None or ("source" in arguments and origin is None): + skipped += 1 + continue + target, root = found + source = origin[0] if origin else None + try: + if source is None: + target.mkdir(parents=True, exist_ok=True) + elif not source.exists(): + missing += 1 + elif source.is_dir() and not source.is_symlink(): + for top, dirs, files in os.walk(source): + for name in sorted(files + [d for d in dirs if (Path(top) / d).is_symlink()]): + item = Path(top) / name + destination = target / item.relative_to(source) + if (destination.exists() or destination.is_symlink()) and not arguments.get("overwrite"): + continue + gog_copy_file(item, destination, root) + copied += 1 + target.mkdir(parents=True, exist_ok=True) + elif (target.exists() or target.is_symlink()) and not arguments.get("overwrite"): + continue + else: + gog_copy_file(source, target, root) + copied += 1 + except OSError: + skipped += 1 + note = "".join(" %s=%d" % (name, count) for name, count in (("skipped", skipped), ("missing", missing)) if count) + if not skipped: + try: + marker.write_text(stamp) + except OSError: + pass + return "copied=%d%s" % (copied, note) + + def main(argv): if os.environ.get("DROIDDECK_GOG_MAINTENANCE") == "1": return 0 @@ -654,6 +770,7 @@ def main(argv): if store == "gog": prepare_gog(sidecar, compat_data, launch_dir) log("gog registry: " + apply_gog_registry(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) + log("gog support data: " + gog_support_data(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) if store == "epic": handled = os.environ.get(EPIC_HANDLED) == "1" and (folder / EPIC_ARGS).is_file() if not handled: diff --git a/tools/tests/test_store_launch.py b/tools/tests/test_store_launch.py index 7ea5a1ae79..863eb679a9 100644 --- a/tools/tests/test_store_launch.py +++ b/tools/tests/test_store_launch.py @@ -387,6 +387,193 @@ def set_registry(**arguments): return {'install': {'action': 'setRegistry', 'arguments': arguments}, 'name': 'setRegistry'} +def support_data(**arguments): + return {'install': {'action': 'supportData', 'arguments': arguments}, 'name': 'supportData'} + + +class GogSupportData(unittest.TestCase): + def prefix(self, root): + user = Path(root) / 'compat/pfx/drive_c/users/steamuser' + user.mkdir(parents=True) + return user + + def test_support_files_reach_the_prefix_once(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + support = folder / 'support/9' + (support / 'Docs').mkdir(parents=True) + (support / 'Docs/Fallout4.ini').write_text('[Archive]\n') + (support / 'Plugins.txt').write_text('*LondonWorldSpace.esm\n') + (folder / '__AppData/Saves').mkdir(parents=True) + (folder / '__AppData/Saves/a.txt').write_text('a') + gog_script(folder, '9', [ + set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string'), + support_data(type='folder', target='{userdocs}/My Games/Fallout4'), + support_data(type='file', overwrite=True, source='{supportDir}/docs/Fallout4.ini', + target='{userdocs}/My Games/Fallout4/Fallout4.ini'), + support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt', + target='{localappdata}/Fallout4/Plugins.txt'), + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/Fallout4'), + ]) + with patch.object(store, 'create_prefix') as create: + self.assertEqual('copied=3', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_not_called() + self.assertTrue((user / 'Documents/My Games/Fallout4').is_dir()) + self.assertEqual('[Archive]\n', (user / 'Documents/My Games/Fallout4/Fallout4.ini').read_text()) + self.assertEqual('*LondonWorldSpace.esm\n', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text()) + self.assertEqual('a', (user / 'AppData/Local/Fallout4/Saves/a.txt').read_text()) + (user / 'AppData/Local/Fallout4/Plugins.txt').write_text('player order') + self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('player order', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text()) + + def test_a_source_the_build_lacks_does_not_recopy_the_rest_every_launch(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/Plugins.txt').write_text('x') + gog_script(folder, '9', [ + support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt', target='{localappdata}/G/Plugins.txt'), + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'), + ]) + self.assertEqual('copied=1 missing=1', store.gog_support_data(folder, root + '/compat', '/proton')) + (user / 'AppData/Local/G/Plugins.txt').write_text('player order') + self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('player order', (user / 'AppData/Local/G/Plugins.txt').read_text()) + + def test_a_link_never_carries_a_copy_outside(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.ini').write_text('s') + (folder / '__AppData').mkdir() + (folder / '__AppData/linked').symlink_to(outside) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('a') + gog_script(folder, '9', [ + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'), + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{localappdata}/G/linked/a.ini'), + support_data(type='file', overwrite=True, source='{app}/__AppData/linked/secret.ini', target='{userdocs}/secret.ini'), + ]) + self.assertEqual('copied=1 skipped=2', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((user / 'AppData/Local/G/linked').is_symlink()) + self.assertEqual(['secret.ini'], sorted(p.name for p in outside.iterdir())) + self.assertFalse((user / 'Documents/secret.ini').exists()) + + def test_a_linked_source_folder_is_copied_as_a_link(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.ini').write_text('s') + (folder / 'linked').symlink_to(outside) + gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/linked', target='{userdocs}/G')]) + store.gog_support_data(folder, root + '/compat', '/proton') + self.assertTrue((user / 'Documents/G').is_symlink()) + self.assertEqual(outside, Path(os.readlink(user / 'Documents/G'))) + + def test_a_players_own_links_stay_without_overwrite(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9/Saves').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('a') + (folder / 'support/9/Saves/b.ini').write_text('b') + (user / 'Documents/G').mkdir(parents=True) + (user / 'Documents/a.ini').symlink_to(user / 'mine.ini') + (user / 'Documents/G/b.ini').symlink_to(user / 'gone.ini') + gog_script(folder, '9', [ + support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini'), + support_data(type='folder', source='{supportDir}/Saves', target='{userdocs}/G'), + ]) + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual(user / 'mine.ini', Path(os.readlink(user / 'Documents/a.ini'))) + self.assertEqual(user / 'gone.ini', Path(os.readlink(user / 'Documents/G/b.ini'))) + + def test_a_changed_script_applies_again(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('1') + action = support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/a.ini') + gog_script(folder, '9', [action]) + self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton')) + (folder / 'support/9/b.ini').write_text('2') + gog_script(folder, '9', [action, support_data(type='file', overwrite=True, source='{supportDir}/b.ini', + target='{userdocs}/b.ini')]) + self.assertEqual('copied=2', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('2', (user / 'Documents/b.ini').read_text()) + + def test_a_players_file_is_kept_unless_the_script_overwrites_it(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('default') + (user / 'Documents').mkdir() + (user / 'Documents/a.ini').write_text('mine') + gog_script(folder, '9', [support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini')]) + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('mine', (user / 'Documents/a.ini').read_text()) + + def test_paths_outside_the_known_folders_are_refused(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('x') + gog_script(folder, '9', [ + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/../../../../escape.ini'), + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='C:/escape.ini'), + support_data(type='folder', target='{windir}/x'), + ]) + self.assertEqual('copied=0 skipped=3', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual([], list(Path(root).rglob('escape.ini'))) + self.assertFalse((Path(root) / 'compat/pfx' / store.GOG_SUPPORT_MARK).exists()) + + def test_links_in_a_support_folder_are_copied_as_links(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.txt').write_text('s') + (folder / '__AppData').mkdir() + (folder / '__AppData/linked').symlink_to(outside, target_is_directory=True) + gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G')]) + self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((user / 'AppData/Local/G/linked').is_symlink()) + self.assertEqual('s', (outside / 'secret.txt').read_text()) + + def test_without_support_data_no_prefix_is_made(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + gog_script(folder, '9', [set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string')]) + with patch.object(store, 'create_prefix') as create: + self.assertEqual('none', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_not_called() + + def test_a_missing_prefix_is_made_first(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + gog_script(folder, '9', [support_data(type='folder', target='{userdocs}/My Games/G')]) + with patch.object(store, 'create_prefix', return_value='failed') as create: + self.assertEqual('no-prefix', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_called_once_with(root + '/compat', '/proton') + + def made(compat_data, proton): + self.prefix(root) + return 'created' + with patch.object(store, 'create_prefix', side_effect=made): + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((Path(root) / 'compat/pfx/drive_c/users/steamuser/Documents/My Games/G').is_dir()) + + class GogRegistry(unittest.TestCase): def test_patch_registration_uses_authentic_build_and_the_prefix_registry_executable(self): with tempfile.TemporaryDirectory() as root: @@ -605,6 +792,8 @@ class GogRegistry(unittest.TestCase): folder = game(root, store_id='gog') with patch.dict(os.environ, {'BL_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': root + '/compat/', 'BL_STORE_PROTON': '/chosen/proton'}), \ patch.object(store, 'prepare_gog', return_value=False), patch.object(store, 'ask', return_value=None), \ - patch.object(store, 'apply_gog_registry', return_value='ready') as apply: + patch.object(store, 'apply_gog_registry', return_value='ready') as apply, \ + patch.object(store, 'gog_support_data', return_value='ready') as support: store.main([str(folder / store.LAUNCHER)]) apply.assert_called_once_with(folder, root + '/compat', '/chosen/proton') + support.assert_called_once_with(folder, root + '/compat', '/chosen/proton') From 5e438e9248e46be8ab2e5de2af7cbb3b0ecc5a0a Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 19:37:20 -0500 Subject: [PATCH 06/16] fix(gog): owned games the listing leaves out stay owned, and search reaches GOG's catalog (#2296) * fix(gog): owned games the library listing leaves out stay owned Since the GOG library is read from account/getFilteredProducts, a game that listing does not return (one hidden in GOG Galaxy, for example) dropped out of the library, and with it out of the GOG tab, which shows owned games and the shelves. 0.5.0 read every owned id from user/data/games and showed them. The sync now takes the union of the listing and user/data/games. The listing still names most games at once, and an owned id it lacks is fetched like any other. * fix(gog): the GOG tab's search reaches GOG's catalog GogStoreCatalog.search was never wired to the backend, so searching the GOG tab only filtered the owned library and the featured shelves; a game that is neither could not be found. GogBackend now answers search from GOG's catalog, like the other stores. * fix(gog): keep cached owned games when the account list is unavailable --- .../droiddeck/launcher/stores/gog/GogBackend.kt | 2 ++ .../droiddeck/launcher/stores/gog/GogLibrary.kt | 12 ++++++++---- .../launcher/stores/gog/GogListingTest.kt | 17 +++++++++++++++++ 3 files changed, 27 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt index fb6b0c8905..e36f0fc16d 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt @@ -64,6 +64,8 @@ object GogBackend : StoreBackend { }, "gog-sync").start() } + override fun search(context: Context, query: String): List = GogStoreCatalog.search(query) + override fun loadShelves(context: Context, force: Boolean) { val app = context.applicationContext GogStoreCatalog.cachedFeatured(app)?.let { StoresState.post { StoresState.shelves[store] = it } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt index 8f48740ee2..5b8be22303 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt @@ -58,16 +58,17 @@ object GogLibrary { val token = GogAuth.validToken(app) ?: return SyncResult.NotLoggedIn onStatus(app.getString(R.string.stores_sync_game_list)) val listing = ownedListing(token) + val account = ownedIds(token) val listed: List = listing?.games - ?: ownedIds(token)?.map { GogGame(it, "", "", "", "", "", 1, null, "", "") } + ?: account?.map { GogGame(it, "", "", "", "", "", 1, null, "", "") } ?: return SyncResult.Failed(app.getString(R.string.stores_sync_gog_unreachable)) val named = listing != null - StoresState.logLine(if (named) "GOG: listing ${listed.size} games" else "GOG: listing unreadable, ${listed.size} owned ids") - val ownedSet = listing?.owned ?: listed.mapTo(HashSet()) { it.gameId } val cachedList = cached(app) + val cachedIds = cachedList.mapTo(HashSet()) { it.gameId } + val ownedSet = ownedSet(listing?.owned ?: listed.mapTo(HashSet()) { it.gameId }, account, cachedIds) + StoresState.logLine(if (named) "GOG: listing ${listed.size} games, ${ownedSet.size} owned ids" else "GOG: listing unreadable, ${listed.size} owned ids") val stale = System.currentTimeMillis() - p.getLong(LAST_SYNC_KEY, 0L) >= THROTTLE_MS val heavy = force || cachedList.isEmpty() || stale - val cachedIds = cachedList.mapTo(HashSet()) { it.gameId } val skipped = java.util.Collections.newSetFromMap(java.util.concurrent.ConcurrentHashMap()) skipped.addAll(p.getStringSet(SKIPPED_KEY, emptySet()).orEmpty()) val idsToFetch = if (heavy) ownedSet.toList() else ownedSet.filter { it !in cachedIds && it !in skipped } @@ -133,6 +134,9 @@ object GogLibrary { return all.ifEmpty { null }?.let { Listing(it, owned) } } + fun ownedSet(listed: Set, account: List?, cached: Set = emptySet()): Set = + if (account == null) listed + cached else listed + account + private fun ownedIds(token: String): List? { val json = StoreNet.get(OWNED_URL, bearer = token, userAgent = GogAuth.GALAXY_UA) ?: return null val owned = runCatching { JSONObject(json).optJSONArray("owned") }.getOrNull() ?: return null diff --git a/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt index 5aace971f6..86e54aad06 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt @@ -24,6 +24,23 @@ class GogListingTest { assertEquals("", shadowrun.description) } + @Test + fun ownedGamesTheListingLeavesOutStayOwned() { + assertEquals(setOf("1", "2", "1086370078"), GogLibrary.ownedSet(setOf("1", "2"), listOf("2", "1086370078"))) + } + + @Test + fun withoutTheAccountListTheListingStillCounts() { + assertEquals(setOf("1", "2"), GogLibrary.ownedSet(setOf("1", "2"), null)) + assertEquals(setOf("3"), GogLibrary.ownedSet(emptySet(), listOf("3"))) + } + + @Test + fun cachedGamesStayWhenTheAccountListIsUnavailable() { + assertEquals(setOf("1", "2", "1086370078"), GogLibrary.ownedSet(setOf("1", "2"), null, setOf("1086370078"))) + assertEquals(setOf("1", "2", "3"), GogLibrary.ownedSet(setOf("1"), listOf("2", "3"), setOf("1086370078"))) + } + @Test fun moviesOtherPlatformsAndGalaxysOwnEntryAreLeftOut() { assertEquals(listOf("1207660413", "1207664663"), GogLibrary.parseListing(PAGE)!!.games.map { it.gameId }) From b4a953c6593824d1a04cb8978ac7e0d536c2e77e Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Sun, 8 Nov 2026 21:08:22 -0500 Subject: [PATCH 07/16] fix(ci): post new Discord notice for each PR build --- tools/release/pr_discord.py | 51 +++++++++++++++--- tools/tests/test_pr_discord.py | 97 ++++++++++++++++++++++++++++++++-- 2 files changed, 135 insertions(+), 13 deletions(-) diff --git a/tools/release/pr_discord.py b/tools/release/pr_discord.py index b577df247b..c0ca0b9618 100644 --- a/tools/release/pr_discord.py +++ b/tools/release/pr_discord.py @@ -101,23 +101,31 @@ def description_excerpt(body): return "" -def build_content(repo, number, title, sha, apk, release, description=None): +def commit_subject(message): + subject = (message or "").splitlines()[0].strip() if message else "" + return plain_title(subject[:300]) + + +def build_content(repo, number, title, sha, apk, release, description=None, commit_message=None): excerpt = description_excerpt(description) + subject = commit_subject(commit_message) return (f"**Signed test build** `pr-{number}` · `{sha[:7]}`\n" f"[#{number}](https://github.com/{repo}/pull/{number}): {plain_title(title)}\n" + + (f"Latest commit: {subject}\n" if subject else "") + (f"\n{excerpt}\n\n" if excerpt else "") + "_Not merged — for testing._\n" f"In the app: **Updates → Test builds → #{number}**\n" f"Download: [standard APK](<{apk}>) · [all variants](<{release}>)") -def retired_content(content, merged): - label = "Merged" if merged else "Closed" - if content.startswith(("**Merged** —", "**Closed** —")): +def retired_content(content, merged=False, superseded_by=None): + label = f"Superseded by `{superseded_by[:7]}`" if superseded_by else ("Merged" if merged else "Closed") + if content.startswith(("**Merged** —", "**Closed** —", "**Superseded by `")): content = "\n".join(line[2:-2] if line.startswith("~~") and line.endswith("~~") else line for line in content.splitlines()[2:]) struck = "\n".join(f"~~{line}~~" if line else "" for line in content.splitlines()) - return f"**{label}** — this test build is no longer available.\n\n{struck}" + note = "This test build has been replaced." if superseded_by else "This test build is no longer available." + return f"**{label}** — {note}\n\n{struck}" def sync(mode, repo, number, discord, sha="", apk="", release=""): @@ -136,6 +144,11 @@ def sync(mode, repo, number, discord, sha="", apk="", release=""): return raise RuntimeError("Signed build report comment is missing") message_id = saved_message(comment["body"], discord.id) + state_match = STATE.search(comment["body"]) + try: + old_state = json.loads(state_match.group(1)) if state_match else {} + except ValueError: + old_state = {} if mode == "retire": if message_id: message = discord.request("GET", f"/messages/{message_id}") @@ -144,16 +157,38 @@ def sync(mode, repo, number, discord, sha="", apk="", release=""): {"content": retired_content(message["content"], pull.get("merged", False)), "allowed_mentions": {"parse": []}, "flags": 4}) return - content = build_content(repo, number, pull["title"], sha, apk, release, pull.get("body")) + commit = github(f"repos/{repo}/commits/{sha}") + commit_message = commit.get("commit", {}).get("message", "") + content = build_content(repo, number, pull["title"], sha, apk, release, pull.get("body"), commit_message) if len(content) > 1800: raise RuntimeError("Discord announcement is too long") payload = {"content": content, "allowed_mentions": {"parse": []}, "flags": 4} - message = discord.request("PATCH", f"/messages/{message_id}", payload) if message_id else None + old_message = None + previous_sha = old_state.get("sha") + if message_id and not previous_sha: + old_message = discord.request("GET", f"/messages/{message_id}") + if old_message: + match = re.search(r"`([0-9a-f]{7})`", old_message.get("content", "")) + previous_sha = match.group(1) if match else None + if message_id and (previous_sha == sha or previous_sha == sha[:7]): + message = discord.request("PATCH", f"/messages/{message_id}", payload) + else: + if message_id and old_state.get("sha"): + previous = discord.request("GET", f"/messages/{message_id}") + if previous: + discord.request("PATCH", f"/messages/{message_id}", + {"content": retired_content(previous["content"], superseded_by=sha), + "allowed_mentions": {"parse": []}, "flags": 4}) + elif message_id and old_message: + discord.request("PATCH", f"/messages/{message_id}", + {"content": retired_content(old_message["content"], superseded_by=sha), + "allowed_mentions": {"parse": []}, "flags": 4}) + message = None if message is None: message = discord.request("POST", "?wait=true", payload) if message is None: raise RuntimeError("Discord webhook no longer exists") - state = {"webhook_id": discord.id, "message_id": message["id"]} + state = {"webhook_id": discord.id, "message_id": message["id"], "sha": sha} latest = github(f"repos/{repo}/issues/comments/{comment['id']}") body = STATE.sub("", latest["body"]).rstrip() + f"\n" github(f"repos/{repo}/issues/comments/{comment['id']}", "PATCH", {"body": body}) diff --git a/tools/tests/test_pr_discord.py b/tools/tests/test_pr_discord.py index 0533e7094c..5c901f6bde 100644 --- a/tools/tests/test_pr_discord.py +++ b/tools/tests/test_pr_discord.py @@ -14,17 +14,30 @@ class PrDiscordTest(unittest.TestCase): self.discord.request.return_value = {"id": "1557547293375332465"} self.github = patch.object(module, "github").start() self.addCleanup(patch.stopall) - self.github.side_effect = lambda path, method="GET", body=None: self.pull if "/pulls/" in path else self.comment + def github_request(path, method="GET", body=None): + if "/pulls/" in path: + return self.pull + if "/commits/" in path: + return {"commit": {"message": "Fix reconnect behavior\n\nMore details"}} + if path.endswith("/issues/comments/10"): + if method == "PATCH": + self.comment["body"] = body["body"] + return self.comment + return self.comment + self.github.side_effect = github_request patch.object(module, "report_comment", return_value=self.comment).start() - def publish(self): - module.sync("publish", "Droid-Deck/DroidDeck", "410", self.discord, "a" * 40, + def publish(self, sha=None): + if sha is not None: + self.pull["head"]["sha"] = sha + sha = sha or "a" * 40 + module.sync("publish", "Droid-Deck/DroidDeck", "410", self.discord, sha, "https://github.com/Droid-Deck/DroidDeck-CI/releases/download/pr-410/build.apk", "https://github.com/Droid-Deck/DroidDeck-CI/releases/tag/pr-410") def save_state(self): self.comment["body"] += '\n' + "webhook_id": self.discord.id, "message_id": "1557547293375332465", "sha": "a" * 40}) + ' -->' def test_create_confirmed_message_and_persist_reference(self): self.publish() @@ -36,12 +49,76 @@ class PrDiscordTest(unittest.TestCase): self.assertEqual("1557547293375332465", module.saved_message(saved, self.discord.id)) self.assertIn("Build download", saved) - def test_new_build_updates_existing_message(self): + def test_same_build_updates_existing_message_without_duplicate(self): self.save_state() self.publish() self.assertEqual("PATCH", self.discord.request.call_args.args[0]) saved = self.github.call_args.args[2]["body"] self.assertEqual(1, len(module.STATE.findall(saved))) + self.assertIn('"sha": "' + "a" * 40 + '"', saved) + + def test_new_commit_retires_old_message_and_posts_replacement(self): + self.save_state() + old_content = module.build_content("Droid-Deck/DroidDeck", "410", self.pull["title"], "a" * 40, + "apk", "release") + self.discord.request.side_effect = [ + {"content": old_content}, {"id": "1557547293375332465"}, {"id": "1557547293375332466"}] + self.publish("b" * 40) + calls = self.discord.request.call_args_list + self.assertEqual(["GET", "PATCH", "POST"], [call.args[0] for call in calls]) + self.assertIn("**Superseded by `bbbbbbb`**", calls[1].args[2]["content"]) + self.assertIn("~~Download:", calls[1].args[2]["content"]) + self.assertIn("Latest commit: Fix reconnect behavior", calls[2].args[2]["content"]) + saved = self.github.call_args.args[2]["body"] + self.assertEqual("1557547293375332466", module.saved_message(saved, self.discord.id)) + self.assertIn('"sha": "' + "b" * 40 + '"', saved) + + def test_publish_supersede_rerun_and_close_lifecycle(self): + messages = {} + created = [] + next_id = 1 + + def discord_request(method, suffix="", body=None): + nonlocal next_id + if method == "POST": + message_id = str(1557547293375332465 + next_id) + next_id += 1 + messages[message_id] = {"id": message_id, "content": body["content"]} + created.append(message_id) + return messages[message_id] + message_id = suffix.split("/")[-1] + if method == "GET": + return messages.get(message_id) + if method == "PATCH": + if message_id not in messages: + return None + messages[message_id].update(body) + return messages[message_id] + self.fail(f"Unexpected Discord method: {method}") + + self.discord.request.side_effect = discord_request + self.publish("a" * 40) + first_id = created[-1] + self.publish("b" * 40) + second_id = created[-1] + self.publish("b" * 40) + self.assertEqual(2, len(created)) + self.assertIn("**Superseded by `bbbbbbb`**", messages[first_id]["content"]) + self.assertIn("`bbbbbbb`", messages[second_id]["content"]) + + self.pull.update(state="closed", merged=True) + module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord) + self.assertTrue(messages[second_id]["content"].startswith("**Merged**")) + self.assertIn("~~Latest commit:", messages[second_id]["content"]) + + def test_legacy_state_uses_embedded_short_sha_to_supersede(self): + self.save_state() + self.comment["body"] = self.comment["body"].replace(', "sha": "' + "a" * 40 + '"', '') + old_content = "**Signed test build** `pr-410` · `aaaaaaa`\nold build" + self.discord.request.side_effect = [ + {"content": old_content}, {"id": "1557547293375332465"}, {"id": "1557547293375332466"}] + self.publish("b" * 40) + self.assertEqual(["GET", "PATCH", "POST"], [call.args[0] for call in self.discord.request.call_args_list]) def test_deleted_message_is_recreated(self): self.save_state() @@ -78,6 +155,10 @@ class PrDiscordTest(unittest.TestCase): module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord) self.discord.request.assert_not_called() + def test_superseded_content_is_idempotent(self): + once = module.retired_content("first\n\nlast", superseded_by="a" * 40) + self.assertEqual(once, module.retired_content(once, superseded_by="a" * 40)) + def test_old_build_without_saved_id_is_not_guessed(self): self.pull["state"] = "closed" module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord) @@ -153,6 +234,12 @@ class PrDiscordTest(unittest.TestCase): self.assertLessEqual(len(content), 1800) self.assertLessEqual(len(module.retired_content(content, True)), 2000) + def test_commit_subject_is_sanitized_and_uses_only_first_line(self): + content = module.build_content("Droid-Deck/DroidDeck", "410", "title", "a" * 40, + "apk", "release", commit_message="Fix *input* @everyone\nDetails") + self.assertIn(r"Latest commit: Fix \*input\* @everyone", content) + self.assertNotIn("Details", content) + original_report = module.report_comment From 51407155fc00c3a67c63ef059969d571f67fad62 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Sun, 8 Nov 2026 21:12:58 -0500 Subject: [PATCH 08/16] fix(ci): keep commit lookup failures from blocking notices --- tools/release/pr_discord.py | 7 +++++-- tools/tests/test_pr_discord.py | 10 ++++++++++ 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/tools/release/pr_discord.py b/tools/release/pr_discord.py index c0ca0b9618..84fe0265b9 100644 --- a/tools/release/pr_discord.py +++ b/tools/release/pr_discord.py @@ -157,8 +157,11 @@ def sync(mode, repo, number, discord, sha="", apk="", release=""): {"content": retired_content(message["content"], pull.get("merged", False)), "allowed_mentions": {"parse": []}, "flags": 4}) return - commit = github(f"repos/{repo}/commits/{sha}") - commit_message = commit.get("commit", {}).get("message", "") + try: + commit = github(f"repos/{repo}/commits/{sha}") + except RuntimeError: + commit = {} + commit_message = (commit.get("commit") or {}).get("message", "") content = build_content(repo, number, pull["title"], sha, apk, release, pull.get("body"), commit_message) if len(content) > 1800: raise RuntimeError("Discord announcement is too long") diff --git a/tools/tests/test_pr_discord.py b/tools/tests/test_pr_discord.py index 5c901f6bde..2a1394d3b3 100644 --- a/tools/tests/test_pr_discord.py +++ b/tools/tests/test_pr_discord.py @@ -240,6 +240,16 @@ class PrDiscordTest(unittest.TestCase): self.assertIn(r"Latest commit: Fix \*input\* @everyone", content) self.assertNotIn("Details", content) + def test_commit_lookup_failure_does_not_block_announcement(self): + def unavailable_commit(path, method="GET", body=None): + if "/commits/" in path: + raise RuntimeError("GitHub request failed") + return self.pull if "/pulls/" in path else self.comment + self.github.side_effect = unavailable_commit + self.publish() + self.assertEqual("POST", self.discord.request.call_args.args[0]) + self.assertNotIn("Latest commit:", self.discord.request.call_args.args[2]["content"]) + original_report = module.report_comment From 1355cb3a2ba74b41fde393c2347247da809acd59 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Sun, 8 Nov 2026 21:13:53 -0500 Subject: [PATCH 09/16] fix(ci): handle empty commit lookup responses --- tools/release/pr_discord.py | 2 +- tools/tests/test_pr_discord.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/tools/release/pr_discord.py b/tools/release/pr_discord.py index 84fe0265b9..77a576208e 100644 --- a/tools/release/pr_discord.py +++ b/tools/release/pr_discord.py @@ -158,7 +158,7 @@ def sync(mode, repo, number, discord, sha="", apk="", release=""): "allowed_mentions": {"parse": []}, "flags": 4}) return try: - commit = github(f"repos/{repo}/commits/{sha}") + commit = github(f"repos/{repo}/commits/{sha}") or {} except RuntimeError: commit = {} commit_message = (commit.get("commit") or {}).get("message", "") diff --git a/tools/tests/test_pr_discord.py b/tools/tests/test_pr_discord.py index 2a1394d3b3..a80efdff75 100644 --- a/tools/tests/test_pr_discord.py +++ b/tools/tests/test_pr_discord.py @@ -250,6 +250,13 @@ class PrDiscordTest(unittest.TestCase): self.assertEqual("POST", self.discord.request.call_args.args[0]) self.assertNotIn("Latest commit:", self.discord.request.call_args.args[2]["content"]) + def test_empty_commit_response_does_not_block_announcement(self): + self.github.side_effect = lambda path, method="GET", body=None: ( + self.pull if "/pulls/" in path else None if "/commits/" in path else self.comment) + self.publish() + self.assertEqual("POST", self.discord.request.call_args.args[0]) + self.assertNotIn("Latest commit:", self.discord.request.call_args.args[2]["content"]) + original_report = module.report_comment From 92a71245890943e822367cba98d336725098725f Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 22:07:39 -0500 Subject: [PATCH 10/16] fix(gpu): skip system Vulkan pruning when the runtime pack is absent (#2316) fix: skip pruning system Vulkan runtimes when the runtime pack is not installed --- .../launcher/gpu/SystemVulkanDriver.java | 1 + .../gpu/SystemVulkanPruneAbsentRuntimeTest.kt | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 app/src/test/java/com/droiddeck/launcher/gpu/SystemVulkanPruneAbsentRuntimeTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/SystemVulkanDriver.java b/app/src/main/java/com/droiddeck/launcher/gpu/SystemVulkanDriver.java index 25a6e363c6..1106ac9602 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/SystemVulkanDriver.java +++ b/app/src/main/java/com/droiddeck/launcher/gpu/SystemVulkanDriver.java @@ -191,6 +191,7 @@ public final class SystemVulkanDriver { /** Collect abandoned stages, and obsolete versions once older guests can no longer load them. */ public static synchronized void pruneUnused(Context context, boolean guestsStopped) throws IOException { + if (!AddonPack.POWERVR.installed(context)) return; pruneUnused(runtimeDirectory(context), guestsStopped); } diff --git a/app/src/test/java/com/droiddeck/launcher/gpu/SystemVulkanPruneAbsentRuntimeTest.kt b/app/src/test/java/com/droiddeck/launcher/gpu/SystemVulkanPruneAbsentRuntimeTest.kt new file mode 100644 index 0000000000..8a740f1681 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/gpu/SystemVulkanPruneAbsentRuntimeTest.kt @@ -0,0 +1,26 @@ +package com.droiddeck.launcher.gpu + +import android.content.Context +import java.io.File +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class SystemVulkanPruneAbsentRuntimeTest { + @Test fun pruningWithoutTheRuntimeDoesNotThrowAndLeavesFilesAlone() { + val context: Context = RuntimeEnvironment.getApplication() + val base = File(context.filesDir, "system_vulkan").apply { mkdirs() } + val stage = File(base, ".stage-" + java.util.UUID.randomUUID()).apply { mkdir() } + val version = File(base, "a".repeat(64)).apply { mkdir() } + + SystemVulkanDriver.pruneUnused(context, true) + + assertTrue(stage.exists()) + assertTrue(version.exists()) + } +} From 29823bb1bf4c8ee7b99fecb7e2d892dd177b007d Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 22:22:22 -0500 Subject: [PATCH 11/16] fix(steam): Linux-only tools keep their native platform (#2313) * fix(steam): reconcile tool dependencies by supported platform * fix(steam): refresh tool metadata and clear stale GE mappings * fix(steam): clear any Proton mapping from Linux-only tools * fix(steam): watch folders the client creates after the helper starts * Watch each missing directory level as it appears * Make the watcher level test wait on inotify readiness --- .../usr/local/bin/droiddeck-steam-compat | 46 +++- .../overlay/usr/local/bin/steam-compatibility | 22 +- tools/tests/test_steam_tool_platforms.py | 215 ++++++++++++++++++ 3 files changed, 273 insertions(+), 10 deletions(-) create mode 100644 tools/tests/test_steam_tool_platforms.py diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index 901caf2f44..e96ce1c553 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -760,18 +760,50 @@ class Watcher: def __init__(self, files): self.files = files self.fd = -1 + self.libc = None + wanted = {os.path.dirname(f) for f in files} + self.missing = {d for d in wanted if not os.path.isdir(d)} + self.watched = set() try: libc = ctypes.CDLL(None, use_errno=True) fd = libc.inotify_init1(os.O_NONBLOCK | os.O_CLOEXEC) - dirs = sorted({os.path.dirname(f) for f in files if os.path.isdir(os.path.dirname(f))}) + dirs = sorted((wanted - self.missing) | {self.existing_parent(d) for d in self.missing} - {""}) if fd >= 0 and dirs and all(libc.inotify_add_watch(fd, d.encode(), self.MASK) >= 0 for d in dirs): + self.watched = set(dirs) self.fd = fd + self.libc = libc elif fd >= 0: os.close(fd) except (OSError, AttributeError): self.fd = -1 self.stamp = self.snapshot() + @staticmethod + def existing_parent(path): + while path and not os.path.isdir(path): + parent = os.path.dirname(path) + if parent == path: + return "" + path = parent + return path + + def watch_new_dirs(self): + appeared = False + progressed = True + while progressed: + progressed = False + for d in sorted(self.missing): + parent = d if os.path.isdir(d) else self.existing_parent(d) + if not parent or parent in self.watched: + continue + if self.libc.inotify_add_watch(self.fd, parent.encode(), self.MASK) >= 0: + self.watched.add(parent) + progressed = True + appeared = appeared or parent == d + for d in [d for d in self.missing if d in self.watched]: + self.missing.discard(d) + return appeared + def snapshot(self): stamp = [] for f in self.files: @@ -803,8 +835,9 @@ class Watcher: at += 16 + size except BlockingIOError: pass + appeared = self.watch_new_dirs() if self.missing else False wanted = {os.path.basename(f) for f in self.files} - return any(n in wanted or n.startswith("appmanifest_") for n in names) + return appeared or any(n in wanted or n.startswith("appmanifest_") for n in names) class XMessage(ctypes.Structure): @@ -1084,6 +1117,7 @@ class Helper: installed = COMPAT["installed_apps"](self.steam_root) self.installed = installed picks = COMPAT["valve_picks"](self.steam_root) + tools = COMPAT["tool_platforms"](self.steam_root) prior_auto = state.get("auto", {}) if not isinstance(prior_auto, dict): prior_auto = {} @@ -1091,7 +1125,7 @@ class Helper: native_choices = set(prior_native if isinstance(prior_native, (list, tuple, set)) else ()) 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"]) + apps = sorted(set(installed) | set(picks) | set(prior_auto) | native_choices | set(tools), 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 {}) @@ -1105,6 +1139,7 @@ class Helper: if isinstance(state.get("auto"), dict): state["auto"] = prior_auto native_choices -= refused + tools = {app: platforms for app, platforms in tools.items() if app not in refused} current["0"] = top["selected"] native = COMPAT["native_targets"](self.steam_root, apps) raw_mapping = COMPAT["read_config_mapping"]( @@ -1137,7 +1172,7 @@ class Helper: changes, auto = COMPAT["plan_mapping"]( current, installed, listed, default, COMPAT["followers"](state, current), native, picks, overrides, - prior_auto.keys(), native_choices) + prior_auto.keys(), native_choices, tools) changes = dict(moved, **changes) for app, tool in sorted(changes.items(), key=lambda item: COMPAT["app_order"](item[0])): page.compat("set(%d, %s)" % (int(app), json.dumps(tool if tool is not None else ""))) @@ -1301,7 +1336,8 @@ def main(): 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")] + + watcher = Watcher([COMPAT["state_path"]("request.json"), COMPAT["state_path"]("games.json"), + os.path.join(steam_root, "appcache", "appinfo.vdf")] + [os.path.join(lib, "steamapps", "libraryfolders.vdf") for lib in (steam_root, COMPAT["LIBRARY"] + "-sd")]) steamos = os.environ.get("BL_STEAMDECK") == "1" and os.environ.get("BL_STEAM_UI") != "desktop" helper = Helper(steam_root, port, steamos) diff --git a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility index 071ff06814..5695bd0b1d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility +++ b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility @@ -734,6 +734,7 @@ def libraries(steam_root): def installed_apps(steam_root): + entries = appinfo_entries(os.path.join(steam_root, "appcache", "appinfo.vdf")) apps = set() for library in libraries(steam_root): steamapps = os.path.join(library, "steamapps") @@ -743,7 +744,7 @@ def installed_apps(steam_root): continue for name in names: m = re.fullmatch(r"appmanifest_(\d+)\.acf", name) - if m and m.group(1) not in NOT_GAMES: + if m and m.group(1) not in NOT_GAMES and entries.get(m.group(1), {}).get("type") != "tool": apps.add(m.group(1)) return sorted(apps, key=int) @@ -927,6 +928,12 @@ def valve_picks(steam_root): return sorted(picks, key=int) +def tool_platforms(steam_root): + entries = appinfo_entries(os.path.join(steam_root, "appcache", "appinfo.vdf")) + return {app: entry["oslist"] for app, entry in entries.items() + if entry["type"] == "tool" and entry["oslist"] & {"linux", "windows"}} + + def native_targets(steam_root, apps): wanted = {str(app) for app in apps if str(app) not in NOT_GAMES} if not wanted: @@ -1064,10 +1071,11 @@ NATIVE_CHOICE = object() def plan_mapping(current, installed, runnable, default, auto, native=None, picks=(), overrides=None, managed=None, - native_choices=()): + native_choices=(), tools=None): + tools = tools or {} runnable = {n.lower() for n in runnable} installed = set(installed) - picks = set(picks) + picks = set(picks) | {app for app, platforms in tools.items() if "linux" not in platforms} native = native or {} overrides = overrides or {} managed = set(auto) if managed is None else set(managed) @@ -1075,8 +1083,12 @@ def plan_mapping(current, installed, runnable, default, auto, native=None, picks changes, kept = {}, {} if current.get("0", "") != default: changes["0"] = default - for app in sorted((set(current) | installed | picks | set(auto) | set(overrides) | native_choices) - {"0"}, key=app_order): + for app in sorted((set(current) | installed | picks | set(auto) | set(overrides) | native_choices | set(tools)) - {"0"}, key=app_order): name = current.get(app, "") + if app in tools and "linux" in tools[app] and "windows" not in tools[app]: + if name and (name.lower() in runnable or "proton" in name.lower()): + changes[app] = None + continue if app in overrides: target = overrides[app] if target is DEFERRED_GAME_TOOL: @@ -1560,7 +1572,7 @@ def register_default(config_path, apps=(), protect=(), default=None, catalog=Non current.setdefault(app, "") changes, auto = plan_mapping( current, apps, names, default, followers(state, current), native, picks, - overrides, managed, native_choices) + overrides, managed, native_choices, tool_platforms(steam_root)) set_mappings(tokens, mapping, changes) text = serialize(tokens) if text != serialize(tokenize(original)): diff --git a/tools/tests/test_steam_tool_platforms.py b/tools/tests/test_steam_tool_platforms.py new file mode 100644 index 0000000000..899b0b07e9 --- /dev/null +++ b/tools/tests/test_steam_tool_platforms.py @@ -0,0 +1,215 @@ +import json +import os +from pathlib import Path +import select +import tempfile +import unittest +from unittest import mock + +from tools.tests import test_droiddeck_fex as fixtures +from tools.tests import test_steam_compat_live as live +from tools.tests.test_steam_compat_mapping import config_text + + +COMPAT = live.COMPAT +TOOL = COMPAT["TOOL"] + + +class ToolPlatformsTest(unittest.TestCase): + def setUp(self): + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.root = Path(temporary.name) + self.steam = self.root / "Steam" + self.state = self.root / "state" + self.config = self.steam / "config/config.vdf" + self.config.parent.mkdir(parents=True) + self.state.mkdir() + (self.steam / "appcache").mkdir() + (self.steam / "steamapps").mkdir() + self.entries = { + 976730: ("windows", "64", "game"), + 1826330: ("linux", "", "tool"), + 1161040: ("linux", "", "tool"), + 900001: ("windows", "64", "tool"), + 900002: ("linux", "arm64", "tool"), + 900003: ("osx", "64", "tool"), + 900004: ("", "", "tool"), + 900005: ("linux,windows", "64", "tool"), + } + self.write_appinfo() + self.catalog = [{"name": TOOL, "display": "Proton", "dir": "Proton", "valve": True}] + self.config.write_text(config_text('"0" { "name" "%s" }' % TOOL)) + patcher = mock.patch.dict(COMPAT["register_default"].__globals__, COMPAT_DIR=str(self.state)) + patcher.start() + self.addCleanup(patcher.stop) + + def write_appinfo(self, magic=0x07564429): + (self.steam / "appcache/appinfo.vdf").write_bytes(fixtures.AppInfoTest.appinfo(self.entries, magic)) + + def platforms(self): + return COMPAT["tool_platforms"](str(self.steam)) + + def plan(self, current, auto=None, **kwargs): + return COMPAT["plan_mapping"](current, ["976730"], [TOOL], TOOL, auto or {}, + tools=self.platforms(), **kwargs) + + def test_metadata_selects_tools_across_cache_formats(self): + for magic in (0x07564427, 0x07564428, 0x07564429): + with self.subTest(magic=magic): + self.write_appinfo(magic) + self.assertEqual(set(self.platforms()), {"1826330", "1161040", "900001", "900002", "900005"}) + + def test_tools_are_not_installed_games(self): + for app in self.entries: + (self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("") + self.assertEqual(COMPAT["installed_apps"](str(self.steam)), ["976730"]) + + def test_linux_tools_clear_proton_and_windows_tools_get_default_before_install(self): + current = {"0": TOOL, "976730": TOOL, "1826330": TOOL, "1161040": "proton_experimental"} + changes, auto = self.plan(current, {"1826330": TOOL, "976730": TOOL}) + self.assertEqual(changes, {"1826330": None, "1161040": None, "900001": TOOL}) + self.assertNotIn("1826330", auto) + self.assertEqual(auto["900001"], TOOL) + self.assertEqual(auto["976730"], TOOL) + + def test_removed_ge_proton_is_cleared_with_or_without_saved_ownership(self): + for saved in ({}, {"1826330": "GE-Proton11-7"}): + with self.subTest(saved=saved): + changes, auto = self.plan({"0": TOOL, "1826330": "GE-Proton11-7"}, saved) + self.assertIsNone(changes["1826330"]) + self.assertNotIn("1826330", auto) + + def test_removed_ge_proton_game_selection_survives(self): + changes, auto = self.plan({"0": TOOL, "976730": "GE-Proton11-7"}) + self.assertNotIn("976730", changes) + self.assertNotIn("976730", auto) + + def test_saved_native_selections_survive(self): + for name in (COMPAT["FEX_TOOL"], "custom-native"): + with self.subTest(name=name): + changes, auto = self.plan({"0": TOOL, "1826330": name}, {"1826330": name}) + self.assertNotIn("1826330", changes) + self.assertNotIn("1826330", auto) + + def test_main_watches_cache_updates_and_replacements(self): + class StopWatching(BaseException): + pass + + watchers = [] + + def capture(files): + watcher = live.LIVE["Watcher"](files) + watchers.append(watcher) + raise StopWatching() + + namespace = live.LIVE["main"].__globals__ + with mock.patch.dict(namespace, Watcher=capture), mock.patch.dict(os.environ, BL_CDP_PORT="1"), \ + mock.patch.object(live.LIVE["sys"], "argv", ["compat", str(self.steam)]): + with self.assertRaises(StopWatching): + live.LIVE["main"]() + watcher = watchers[0] + if watcher.fd >= 0: + self.addCleanup(os.close, watcher.fd) + self.assertFalse(watcher.changed()) + self.entries[900006] = ("linux", "", "tool") + self.write_appinfo() + self.assertTrue(watcher.changed()) + self.assertIn("900006", self.platforms()) + cache = self.steam / "appcache/appinfo.vdf" + replacement = cache.with_suffix(".tmp") + replacement.write_bytes(cache.read_bytes()) + replacement.replace(cache) + self.assertTrue(watcher.changed()) + + def test_watcher_follows_an_appcache_created_after_startup(self): + root = self.root / "late" + (root / "state").mkdir(parents=True) + watcher = live.LIVE["Watcher"]([str(root / "state/request.json"), str(root / "appcache/appinfo.vdf")]) + self.assertGreaterEqual(watcher.fd, 0) + self.addCleanup(os.close, watcher.fd) + self.assertFalse(watcher.changed()) + (root / "appcache").mkdir() + self.assertTrue(watcher.changed()) + (root / "appcache/appinfo.vdf").write_bytes(b"x") + self.assertTrue(watcher.changed()) + + def test_watcher_follows_each_missing_directory_level(self): + root = self.root / "levels" + root.mkdir() + target = root / "sd/steamapps/appmanifest_1.acf" + watcher = live.LIVE["Watcher"]([str(target)]) + self.assertGreaterEqual(watcher.fd, 0) + self.addCleanup(os.close, watcher.fd) + (root / "sd").mkdir() + self.assertTrue(select.select([watcher.fd], [], [], 1)[0]) + self.assertFalse(watcher.changed()) + (root / "sd/steamapps").mkdir() + self.assertTrue(select.select([watcher.fd], [], [], 1)[0]) + self.assertTrue(watcher.changed()) + target.write_bytes(b"x") + self.assertTrue(watcher.changed()) + + def test_linux_tool_requests_cannot_restore_windows_platform(self): + changes, auto = self.plan({"0": TOOL, "1826330": TOOL}, overrides={"1826330": TOOL}) + self.assertIsNone(changes["1826330"]) + self.assertNotIn("1826330", auto) + + def test_linux_execution_tools_and_custom_selections_survive(self): + current = {"0": TOOL, "1826330": COMPAT["FEX_TOOL"], "900002": "custom-native", + "900001": "custom-windows", "900005": TOOL} + changes, auto = self.plan(current) + self.assertEqual(changes, {"976730": TOOL}) + self.assertNotIn("1826330", auto) + + def test_missing_or_malformed_cache_does_not_invent_platforms(self): + cache = self.steam / "appcache/appinfo.vdf" + cache.unlink() + self.assertEqual(self.platforms(), {}) + cache.write_bytes(b"invalid") + self.assertEqual(self.platforms(), {}) + + def test_offline_repair_is_idempotent_and_preserves_game_and_neighbor_fields(self): + self.config.write_text(config_text( + '"0" { "name" "%s" } "976730" { "name" "custom-game" } ' + '"1826330" { "name" "%s" }' % (TOOL, TOOL))) + for _ in range(2): + COMPAT["register_default"](str(self.config), ["976730"], catalog=self.catalog, + directory=str(self.state), default=TOOL) + self.assertEqual(COMPAT["read_config_mapping"](str(self.config)), + {"0": TOOL, "976730": "custom-game", "900001": TOOL}) + self.assertIn('"outside"', self.config.read_text()) + state = json.loads((self.state / "state.json").read_text()) + self.assertNotIn("1826330", state["auto"]) + + def reconcile(self, page): + helper = live.LIVE["Helper"](str(self.steam), 1) + helper.page = page + with mock.patch.dict(COMPAT, tool_catalog=lambda root: self.catalog): + helper.reconcile() + return json.loads((self.state / "state.json").read_text()) + + def test_live_repair_covers_uninstalled_dependencies_and_stays_idempotent(self): + page = live.FakePage({"0": TOOL, "1826330": TOOL, "976730": "custom-game"}, [TOOL]) + state = self.reconcile(page) + self.assertEqual(page.sets, [("900001", TOOL), ("1826330", "")]) + self.assertNotIn("1826330", state["auto"]) + page.sets.clear() + self.reconcile(page) + self.assertEqual(page.sets, []) + self.assertEqual(page.mapping["976730"], "custom-game") + + def test_live_removed_ge_proton_is_cleared_and_stays_cleared(self): + page = live.FakePage({"0": TOOL, "1826330": "GE-Proton11-7"}, [TOOL]) + (self.state / "state.json").write_text(json.dumps({"auto": {"1826330": "GE-Proton11-7"}})) + state = self.reconcile(page) + self.assertIn(("1826330", ""), page.sets) + self.assertNotIn("1826330", state["auto"]) + page.sets.clear() + self.reconcile(page) + self.assertEqual(page.sets, []) + + def test_live_refused_tools_are_not_written(self): + page = live.FakePage({"0": TOOL, "1826330": TOOL}, [TOOL], refused={"1826330", "900001"}) + self.reconcile(page) + self.assertEqual(page.sets, []) From 88d6b70881a9e53eee53ac5ee4d38ba711304788 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 9 Nov 2026 00:00:20 -0500 Subject: [PATCH 12/16] fix(ctl): reach the agent bridge by broadcast when the shell has no content command (#2321) --- app/src/main/AndroidManifest.xml | 8 ++++ .../launcher/agent/AgentCallReceiver.kt | 39 +++++++++++++++++++ tools/droiddeckctl | 26 +++++++++++++ tools/tests/test_droiddeckctl.py | 22 +++++++++++ 4 files changed, 95 insertions(+) create mode 100644 app/src/main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 5f010b48d3..968aed7d04 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -352,6 +352,14 @@ + + + + + str: return encoded +def receiver_call(adb: str, serial: str, method: str, arg: str | None, request: dict | None, timeout: float) -> dict: + """The agent bridge through a broadcast, for shells without the `content` command.""" + call_id = uuid.uuid4().hex[:16] + remote = f"/sdcard/Android/data/{PACKAGE}/files/agent-calls/{call_id}.json" + command = ["shell", "am", "broadcast", "-a", f"{PACKAGE}.AGENT_CALL", "-p", PACKAGE, + "--es", "method", method, "--es", "id", call_id] + if arg is not None: + command += ["--es", "arg", shlex.quote(arg)] + if request is not None: + command += ["--es", "request", encode_request(request)] + started = run_adb(adb, serial, *command, timeout=timeout + 30) + if started.returncode != 0: + raise ControlError((started.stdout + started.stderr).decode(errors="replace").strip() or "ADB broadcast failed", "ADB_FAILED") + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + result = run_adb(adb, serial, "shell", f"cat {remote} 2>/dev/null && rm -f {remote}", timeout=30) + text = result.stdout.decode(errors="replace").strip() + if result.returncode == 0 and text: + return json.loads(text) + time.sleep(0.25) + raise ControlError(f"No answer to {method} within {timeout:g} s", "TIMEOUT") + + def provider_call(adb: str, serial: str, method: str, arg: str | None = None, request: dict | None = None, timeout: float = 30) -> dict: command = ["shell", "content", "call", "--uri", AUTHORITY, "--method", method] @@ -108,6 +132,8 @@ def provider_call(adb: str, serial: str, method: str, arg: str | None = None, re command.extend(["--extra", f"request:s:{encoded}"]) result = run_adb(adb, serial, *command, timeout=timeout) output = (result.stdout + result.stderr).decode(errors="replace") + if "content: inaccessible or not found" in output: + return receiver_call(adb, serial, method, arg, request, timeout) response = _content_result(output) if result.returncode != 0 and response.get("ok") is not False: raise ControlError(output.strip() or "ADB content call failed", "ADB_FAILED") diff --git a/tools/tests/test_droiddeckctl.py b/tools/tests/test_droiddeckctl.py index ad434989a8..a626c7868d 100644 --- a/tools/tests/test_droiddeckctl.py +++ b/tools/tests/test_droiddeckctl.py @@ -398,6 +398,28 @@ class DroiddeckctlTest(FakeAdbTest): self.assertEqual(4, code) self.assertEqual("NO_FRAMES", out["error"]["code"]) + def test_provider_call_falls_back_to_a_broadcast_without_content(self): + calls = [] + answers = iter([b"", b'{"ok": true, "command": "state"}']) + + def adb(_adb, _serial, *args, timeout=30): + calls.append(args) + if args[:2] == ("shell", "content"): + return ctl.subprocess.CompletedProcess(args, 127, b"", b"/system/bin/sh: content: inaccessible or not found") + if args[:2] == ("shell", "am"): + return ctl.subprocess.CompletedProcess(args, 0, b"Broadcast completed: result=0", b"") + return ctl.subprocess.CompletedProcess(args, 0, next(answers), b"") + + with unittest.mock.patch.object(ctl, "run_adb", adb), unittest.mock.patch.object(ctl.time, "sleep"): + answer = ctl.provider_call("adb", "fake-1", "state", arg="a b", request={"x": 1}) + self.assertEqual({"ok": True, "command": "state"}, answer) + broadcast = calls[1] + self.assertEqual(("shell", "am", "broadcast", "-a", ctl.PACKAGE + ".AGENT_CALL", "-p", ctl.PACKAGE), broadcast[:7]) + self.assertIn("'a b'", broadcast) + self.assertEqual(ctl.encode_request({"x": 1}), broadcast[broadcast.index("request") + 1]) + call_id = broadcast[broadcast.index("id") + 1] + self.assertIn("agent-calls/%s.json" % call_id, calls[-1][1]) + def test_pacing_turns_timestats_off_when_the_dump_fails(self): calls = [] From 96a12465e01f50b88a617f72b4fadacc34f7938f Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Mon, 9 Nov 2026 02:08:40 -0500 Subject: [PATCH 13/16] fix(session): stop re-compressing game memory every 30 s when the game reads it straight back (#2312) * fix(session): stop re-compressing game memory every 30 s when the game reads it straight back On devices with 13 GB or less, the low-memory page-out skipped its read-back backoff whenever memory was nearly exhausted. When the game was actively using what was compressed, it read it straight back, so the session pushed and re-read gigabytes every 30 seconds, pinning all cores and freezing the game for 5-10 s each time. The read-back check now applies on that path too: an effective page-out still repeats every 30 s, an ineffective one backs off as on the normal path. * zRAM: keep the read-back backoff on the nearly-out-of-memory path * zRAM: retry a skipped page-out after 30 s when nearly out of memory --- .../overlay/usr/local/bin/droiddeck-session | 10 +++---- tools/tests/test_memory_pressure.py | 27 ++++++++++++++++++- 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 415f9472fe..9073645722 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -902,21 +902,21 @@ case $mode in bl_session_pressure() { bl_memory_read [ "$_bl_game" = 1 ] && bl_low_ram && bl_memory_critical || return 0 - local _wait=$_bl_tier_backoff _urgent=0 _before _pids _targets - [ "$_bl_available" -ge $((_bl_headroom / 2)) ] || _urgent=1 _wait=30 + local _wait=$_bl_tier_backoff _before _pids _targets + [ "$_bl_available" -ge $((_bl_headroom / 2)) ] || [ "$_bl_tier_pushed" -lt 0 ] || _wait=30 [ "$_bl_tier_at" -lt 0 ] || [ $((SECONDS - _bl_tier_at)) -ge "$_wait" ] || return 0 if [ "$_bl_tier_at" -ge 0 ] && [ "$_bl_tier_pushed" -gt 0 ]; then bl_tier_readback if [ "$_bl_tier_back" -le $((_bl_tier_pushed / 2)) ]; then _bl_tier_backoff=30 - elif [ "$_urgent" = 0 ]; then + else _bl_tier_backoff=$((_bl_tier_backoff * 2 > 300 ? 300 : _bl_tier_backoff * 2)) - _bl_tier_at=$SECONDS _bl_tier_pushed=0 + _bl_tier_at=$SECONDS _bl_tier_pushed=-1 step "zRAM: the game read back most of its last page-out, next try in ${_bl_tier_backoff} s" return 0 fi fi - _bl_tier_at=$SECONDS + _bl_tier_at=$SECONDS _bl_tier_pushed=0 bl_zram_pick game bl_zram_usage "${_pids[@]}" > /dev/null [ "$_bl_rss" -ge $((256 * 1024)) ] || return 0 diff --git a/tools/tests/test_memory_pressure.py b/tools/tests/test_memory_pressure.py index 8aa2d1f2c5..2c852a7af5 100644 --- a/tools/tests/test_memory_pressure.py +++ b/tools/tests/test_memory_pressure.py @@ -229,9 +229,34 @@ echo "backoff:$_bl_tier_backoff" self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy(''' _bl_tier_backoff=300 SECONDS=0; bl_session_pressure -swap=0 SECONDS=20; bl_session_pressure SECONDS=30; bl_session_pressure +''')) + + def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self): + self.memory(available=512) + self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game'], self.run_policy(''' +SECONDS=0; bl_session_pressure +swap=0 +SECONDS=30; bl_session_pressure +echo "backoff:$_bl_tier_backoff" +SECONDS=59; bl_session_pressure +SECONDS=60; bl_session_pressure +SECONDS=90; bl_session_pressure +''')) + + def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self): + self.memory(available=512) + self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy(''' +SECONDS=0; bl_session_pressure +swap=0 +SECONDS=30; bl_session_pressure +_bl_tier_backoff=300 +saved=$rss; rss=$((128 * 1024)) +SECONDS=330; bl_session_pressure +rss=$saved +SECONDS=359; bl_session_pressure +SECONDS=360; bl_session_pressure ''')) def test_small_swap_headroom_skips_the_pageout(self): From 35941bb9e732311c37907318d8fc73d74f08aeea Mon Sep 17 00:00:00 2001 From: GiovanniCarbinatti <83474533+GiovanniCarbinatti@users.noreply.github.com> Date: Mon, 9 Nov 2026 08:45:24 -0300 Subject: [PATCH 14/16] chore: update README.md (#2311) --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 3139abd284..5b329368c4 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ DroidDeck brings the SteamOS experience to Android: Steam Gaming Mode, full Linu

100% open source. No ads. No telemetry. No proprietary components. No source withheld.

- Download DroidDeck 0.6.9 + Download DroidDeck 0.7.0 Join the DroidDeck Discord

@@ -36,9 +36,9 @@ DroidDeck brings the SteamOS experience to Android: Steam Gaming Mode, full Linu ## Install -1. Android 9 or newer on Adreno 730 or newer, or any 8xx. Adreno 6xx is experimental. Mali, Xclipse, PowerVR and Adreno 710 are unsupported. No root needed. +1. Android 9 or newer on Adreno 730 or newer, or any 8xx. Adreno 6xx, Mali, Xclipse and PowerVR are experimental. Adreno 710 is currently unsupported. No root needed. 2. About 3 GB free for the runtime, plus 1.1 GB for the desktop and emulators. -3. Install the [APK](https://github.com/Droid-Deck/DroidDeck/releases/download/0.6.9/DroidDeck-0.6.9.apk), install the Linux runtime, press **Play** and sign in to Steam. +3. Install the [APK](https://github.com/Droid-Deck/DroidDeck/releases/download/0.7.0/DroidDeck-0.7.0.apk), install the Linux runtime, press **Play** and sign in to Steam. 4. On Android 14 and newer, turn on **Disable child process restrictions** in Developer options. On Android 12 and 13, Steam's first launch shows a **Fix it for me** button that walks you through it. Smart glasses setup is in the [support matrix](docs/smart-glasses-support.md). Release notes are in [docs/releases](docs/releases). From bf434b2652f1eb36d5511e7130e4af6d8cd35177 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:30:41 -0500 Subject: [PATCH 15/16] fix(hud): steady frame graph on the bottom screen dashboard (#2345) --- .../com/droiddeck/launcher/hud/GameFrames.kt | 6 ++++- .../launcher/ui/BottomTelemetryPage.kt | 4 ++- .../com/droiddeck/launcher/ui/StatsHud.kt | 27 ++++++++++++------- 3 files changed, 26 insertions(+), 11 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/hud/GameFrames.kt b/app/src/main/java/com/droiddeck/launcher/hud/GameFrames.kt index 98dc35074f..2aba209ded 100644 --- a/app/src/main/java/com/droiddeck/launcher/hud/GameFrames.kt +++ b/app/src/main/java/com/droiddeck/launcher/hud/GameFrames.kt @@ -6,6 +6,7 @@ import kotlin.math.roundToInt internal class FrameStats { private val graph = FloatArray(GRAPH_FRAMES) private var graphHead = 0 + private var graphFrames = 0L private var lastPresentNs = 0L private var lastFpsUpdateNs = 0L private var framesSinceUpdate = 0 @@ -38,6 +39,7 @@ internal class FrameStats { if (lastPresentNs != 0L) { graph[graphHead] = frametimeNs / 1e6f graphHead = (graphHead + 1) % GRAPH_FRAMES + graphFrames++ } val elapsed = timeNs - lastFpsUpdateNs if (elapsed >= FPS_PERIOD_NS) { @@ -68,6 +70,7 @@ internal class FrameStats { fun reset() { graph.fill(0f) graphHead = 0 + graphFrames = 0L lastPresentNs = 0L lastFpsUpdateNs = 0L framesSinceUpdate = 0 @@ -86,8 +89,9 @@ internal class FrameStats { fun frametimeMs(): Float = 1000f / maxOf(fps, 1f) @Synchronized - fun graph(out: FloatArray) { + fun graph(out: FloatArray): Long { for (i in 0 until GRAPH_FRAMES) out[i] = graph[(graphHead + i) % GRAPH_FRAMES] + return graphFrames } @Synchronized diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt index 4aee7fc22f..08b4ae8ada 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt @@ -304,7 +304,8 @@ fun BottomTelemetryPage(fps: () -> Float?, runningGame: () -> String? = { null } val now = System.nanoTime() val live = frames.live val stats = frames.stats - val graph = FloatArray(FrameStats.GRAPH_FRAMES).also { if (live) stats.graph(it) } + val graph = FloatArray(FrameStats.GRAPH_FRAMES) + val graphEnd = if (live) stats.graph(graph) else 0L val hz = (frames.refreshMilliHz + 499) / 1000 val data = HudData( fps = fpsNow, avgFps = if (live) stats.averageFps() else null, lows = if (live) stats.lows(now) else FrameStats.Lows.EMPTY, @@ -317,6 +318,7 @@ fun BottomTelemetryPage(fps: () -> Float?, runningGame: () -> String? = { null } title = title, cover = cover, played = playedSeconds?.let(::playedText), clock = clock, fpsHistory = fpsHistory.snapshot(), cpuHistory = cpuHistory.snapshot(), gpuHistory = gpuHistory.snapshot(), historySeconds = maxOf(fpsHistory.spanSeconds(), cpuHistory.spanSeconds(), gpuHistory.spanSeconds()), + graphEnd = graphEnd, coreGroups = coreGroups, gameCores = gameCores, fahrenheit = tempDisplay.fahrenheit, tempColor = { sensor, c -> thresholds[sensor]?.let { Color(HudMetrics.tempColor(c.toFloat(), it, tempDisplay, TEMP_PLAIN)) } ?: Color(TEMP_PLAIN) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StatsHud.kt b/app/src/main/java/com/droiddeck/launcher/ui/StatsHud.kt index b14dd39dc3..0ed81319c1 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StatsHud.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StatsHud.kt @@ -98,6 +98,7 @@ internal class HudData( val tempColor: (HudMetrics.TempSensor, Int) -> Color, val redC: (HudMetrics.TempSensor) -> Int?, val historySeconds: Int = 0, + val graphEnd: Long = 0L, ) { val frametimeMs: Float? get() = fps?.takeIf { it > 0f }?.let { 1000f / it } val hz: Int get() = if (refreshHz > 0) refreshHz else 60 @@ -268,18 +269,26 @@ private fun lowsText(d: HudData, size: TextUnit, accent: Color, deep: Boolean = private val GRAPH_MIN_GAP = 3.dp @Composable -private fun Graph(values: List, lo: Float, hi: Float, color: Color, modifier: Modifier) { +private fun Graph(values: List, lo: Float, hi: Float, color: Color, modifier: Modifier, end: Long = 0L) { Canvas(modifier) { if (values.size < 2 || hi <= lo) return@Canvas val stride = ceil(GRAPH_MIN_GAP.toPx() * (values.size - 1) / size.width).toInt().coerceAtLeast(1) - val points = if (stride == 1) values else values.chunked(stride) { it.average().toFloat() } - if (points.size < 2) return@Canvas + // Buckets start at multiples of stride counted from the first sample ever drawn, so a sample keeps + // its bucket as the window scrolls; counted from the window's start, every new frame re-paired them. + val skip = Math.floorMod(values.size.toLong() - end, stride.toLong()).toInt() val path = Path() - points.forEachIndexed { i, v -> - val x = i / (points.size - 1f) * size.width - val y = size.height - ((v - lo) / (hi - lo)).coerceIn(0f, 1f) * size.height - if (i == 0) path.moveTo(x, y) else path.lineTo(x, y) + var drawn = 0 + var start = skip + while (start < values.size) { + val stop = minOf(start + stride, values.size) + var sum = 0f + for (i in start until stop) sum += values[i] + val x = (start + stop - 1) / 2f / (values.size - 1f) * size.width + val y = size.height - ((sum / (stop - start) - lo) / (hi - lo)).coerceIn(0f, 1f) * size.height + if (drawn++ == 0) path.moveTo(x, y) else path.lineTo(x, y) + start = stop } + if (drawn < 2) return@Canvas drawPath(path, color.copy(alpha = 0.22f), style = Stroke(width = 6.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round)) drawPath(path, color, style = Stroke(width = 2.2f.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round)) } @@ -287,7 +296,7 @@ private fun Graph(values: List, lo: Float, hi: Float, color: Color, modif @Composable private fun FrameGraph(d: HudData, accent: Color, height: Dp) { - Graph(d.graph.toList(), 0f, FrameStats.GRAPH_MAX_MS, lerp(accent, Color.White, 0.3f), Modifier.fillMaxWidth().height(height)) + Graph(d.graph.toList(), 0f, FrameStats.GRAPH_MAX_MS, lerp(accent, Color.White, 0.3f), Modifier.fillMaxWidth().height(height), d.graphEnd) } @Composable @@ -589,7 +598,7 @@ private fun ColumnScope.Pacing(d: HudData, accent: Color) { drawLine(color, Offset(0f, y), Offset(size.width, y), 1.dp.toPx(), pathEffect = dash) } } - Graph(d.graph.toList(), 0f, FrameStats.GRAPH_MAX_MS, graphColor, Modifier.fillMaxSize()) + Graph(d.graph.toList(), 0f, FrameStats.GRAPH_MAX_MS, graphColor, Modifier.fillMaxSize(), d.graphEnd) for ((ms, color) in listOf(target to HudInk.dim, target * 2 to HudInk.amber)) { Small("%.1f ms · %d fps".format(ms, (1000f / ms).roundToInt()), 11.sp, color, Modifier.align(Alignment.TopEnd).offset(y = maxHeight * (1f - ms / FrameStats.GRAPH_MAX_MS) - 17.dp)) From b837611efe543336bc3848b4a73e1ac98be3c293 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:33:26 -0500 Subject: [PATCH 16/16] fix(ctl): a full disk no longer crashes the app when an agent call cannot write its answer (#2325) --- .../main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/app/src/main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt b/app/src/main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt index d457bc2143..6ef8b2d4ba 100644 --- a/app/src/main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt +++ b/app/src/main/java/com/droiddeck/launcher/agent/AgentCallReceiver.kt @@ -31,6 +31,8 @@ class AgentCallReceiver : BroadcastReceiver() { val dir = File(context.getExternalFilesDir(null), "agent-calls").apply { mkdirs() } File(dir, "$id.json.part").writeText(json) File(dir, "$id.json.part").renameTo(File(dir, "$id.json")) + } catch (e: Exception) { + android.util.Log.w("AgentCallReceiver", "could not write the answer to $method: ${e.message}") } finally { pending.finish() }