From 8d407aa1e80efc041ec86c181f603838389aea42 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 24 Oct 2026 20:04:54 -0400 Subject: [PATCH] Focus flatpak and other sandboxed shortcuts in gaming mode (#1524) --- .../overlay/usr/local/bin/droiddeck-agent | 81 +++++++++++++++++-- tools/tests/test_droiddeck_agent.py | 57 +++++++++++++ 2 files changed, 131 insertions(+), 7 deletions(-) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent b/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent index 8a0ba6a2c..162d7ebc2 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-agent @@ -259,24 +259,91 @@ def focus_snapshot(): STEAM_APP_CLASS = re.compile(r"steam_app_(\d+)$") -def tag_game_windows(snap): - if os.environ.get("BL_STEAM_CLIENT_ARCH") != "x86_64": - return False +def process_env(pid, proc=Path("/proc")): + try: + return dict(entry.split(b"=", 1) for entry in (proc / str(pid) / "environ").read_bytes().split(b"\0") if b"=" in entry) + except OSError: + return {} + + +def steam_app_id(env): + try: + app = int(env.get(b"SteamAppId", b"0")) + except ValueError: + return None + return app if 0 < app < 2**32 else None + + +def under_reaper(pid, proc=Path("/proc")): + for _ in range(64): + try: + if (proc / str(pid) / "comm").read_text().strip() == "reaper": + return True + stat = (proc / str(pid) / "stat").read_text() + pid = int(stat[stat.rindex(")") + 2:].split()[1]) + except (OSError, ValueError, IndexError): + return False + if pid <= 1: + return False + return False + + +def sandboxed_apps(proc=Path("/proc")): + apps = {} + try: + pids = [entry for entry in os.listdir(proc) if entry.isdigit()] + except OSError: + return apps + for pid in pids: + env = process_env(pid, proc) + flatpak, app = env.get(b"FLATPAK_ID"), steam_app_id(env) + if flatpak and app: + name = flatpak.decode(errors="replace").lower() + for key in {name, name.rsplit(".", 1)[-1]}: + apps[key] = app if apps.get(key, app) == app else None + return apps + + +def window_steam_app(win, flatpaks, proc=Path("/proc")): + match = STEAM_APP_CLASS.match(win.get("class") or "") + if match: + return match.group(1) if os.environ.get("BL_STEAM_CLIENT_ARCH") == "x86_64" else None + pid = win.get("pid") + if pid: + if under_reaper(pid, proc): + return None + app = steam_app_id(process_env(pid, proc)) + if app: + return str(app) + app = flatpaks().get((win.get("class") or "").lower()) + return str(app) if app else None + + +def tag_game_windows(snap, proc=Path("/proc")): tagged = False + found = [] + + def flatpaks(): + if not found: + found.append(sandboxed_apps(proc)) + return found[0] + for display, wins in snap.get("displays", {}).items(): if display == os.environ.get("DISPLAY"): continue for win in wins: - match = STEAM_APP_CLASS.match(win.get("class") or "") - if not match or win.get("appId") or win.get("map") != "viewable" or win.get("overrideRedirect"): + if win.get("appId") or win.get("map") != "viewable" or win.get("overrideRedirect") or win.get("inputOnly"): + continue + app = window_steam_app(win, flatpaks, proc) + if not app: continue try: done = subprocess.run(["xprop", "-display", display, "-id", str(win["window"]), "-f", "STEAM_GAME", "32c", - "-set", "STEAM_GAME", match.group(1)], + "-set", "STEAM_GAME", app], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5).returncode == 0 except (OSError, subprocess.TimeoutExpired): done = False - log("game window %s on %s tagged STEAM_GAME=%s: %s" % (win["window"], display, match.group(1), "ok" if done else "failed")) + log("game window %s on %s tagged STEAM_GAME=%s: %s" % (win["window"], display, app, "ok" if done else "failed")) tagged = tagged or done return tagged diff --git a/tools/tests/test_droiddeck_agent.py b/tools/tests/test_droiddeck_agent.py index 66744b6d5..e9fae8862 100644 --- a/tools/tests/test_droiddeck_agent.py +++ b/tools/tests/test_droiddeck_agent.py @@ -196,6 +196,63 @@ class AgentTest(unittest.TestCase): answer = self.ask({"kind": "vr", "action": "status"}) self.assertEqual("UNAVAILABLE", answer["error"]["code"]) + def fake_proc(self, pid, parent, comm, env): + root = self.dir / "proc" / str(pid) + root.mkdir(parents=True) + (root / "comm").write_text(comm + "\n") + (root / "stat").write_text("%d (%s) S %d 0 0" % (pid, comm, parent)) + (root / "environ").write_bytes(b"\0".join(b"%s=%s" % (k.encode(), v.encode()) for k, v in env.items()) + b"\0") + + def tag(self, wins, arch="arm64"): + snap = {"displays": {":0": [], ":1": wins}} + with patch.dict(os.environ, {"DISPLAY": ":0", "BL_STEAM_CLIENT_ARCH": arch}), \ + patch.object(agent.subprocess, "run") as run, patch.object(agent, "log"): + run.return_value.returncode = 0 + tagged = agent.tag_game_windows(snap, proc=self.dir / "proc") + return tagged, [call.args[0][-1] for call in run.call_args_list] + + def test_a_sandboxed_flatpak_window_is_tagged_with_its_shortcut(self): + self.fake_proc(40, 1, "gjs", {"FLATPAK_ID": "com.github.tchx84.Flatseal", "SteamAppId": "2166984148"}) + win = {"window": 7, "map": "viewable", "class": "com.github.tchx84.Flatseal", "pid": None} + self.assertEqual(self.tag([win]), (True, ["2166984148"])) + + def test_a_flatpak_window_named_after_the_app_is_matched(self): + self.fake_proc(40, 1, "vacuumtube", {"FLATPAK_ID": "rocks.shy.VacuumTube", "SteamAppId": "3000000001"}) + win = {"window": 7, "map": "viewable", "class": "VacuumTube", "pid": None} + self.assertEqual(self.tag([win]), (True, ["3000000001"])) + + def test_a_window_whose_process_has_no_app_id_falls_back_to_its_flatpak(self): + self.fake_proc(40, 1, "bwrap", {"FLATPAK_ID": "com.github.tchx84.Flatseal", "SteamAppId": "2166984148"}) + self.fake_proc(41, 1, "gjs", {}) + win = {"window": 7, "map": "viewable", "class": "com.github.tchx84.Flatseal", "pid": 41} + self.assertEqual(self.tag([win]), (True, ["2166984148"])) + + def test_a_flatpak_shared_by_two_shortcuts_is_not_guessed(self): + self.fake_proc(40, 1, "gjs", {"FLATPAK_ID": "com.github.tchx84.Flatseal", "SteamAppId": "2166984148"}) + self.fake_proc(42, 1, "gjs", {"FLATPAK_ID": "com.github.tchx84.Flatseal", "SteamAppId": "3000000003"}) + win = {"window": 7, "map": "viewable", "class": "com.github.tchx84.Flatseal", "pid": None} + self.assertEqual(self.tag([win]), (False, [])) + + def test_a_window_outside_the_reaper_takes_its_process_app_id(self): + self.fake_proc(30, 1, "proot", {}) + self.fake_proc(31, 30, "electron", {"SteamAppId": "3000000002"}) + win = {"window": 8, "map": "viewable", "class": "electron", "pid": 31} + self.assertEqual(self.tag([win]), (True, ["3000000002"])) + + def test_windows_gamescope_already_resolves_are_left_alone(self): + self.fake_proc(20, 1, "reaper", {}) + self.fake_proc(21, 20, "game", {"SteamAppId": "413150"}) + wins = [{"window": 9, "map": "viewable", "class": "game", "pid": 21}, + {"window": 10, "map": "viewable", "class": "tagged", "pid": None, "appId": 5}, + {"window": 11, "map": "viewable", "class": "other", "pid": None}, + {"window": 12, "map": "unmapped", "class": "game", "pid": 21}, + {"window": 13, "map": "viewable", "class": "steam_app_550", "pid": None}] + self.assertEqual(self.tag(wins), (False, [])) + + def test_the_x86_client_still_tags_its_game_classes(self): + win = {"window": 13, "map": "viewable", "class": "steam_app_550", "pid": None} + self.assertEqual(self.tag([win], arch="x86_64"), (True, ["550"])) + def test_exec_output_and_status(self): answer = self.ask({"kind": "exec", "argv": ["sh", "-c", "echo out; echo err >&2; exit 3"], "env": {"X": "1"}}) self.assertTrue(answer["ok"])