mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 22:36:00 +00:00
* feat(display): zero-copy presentation toggle and compositor display buffers Adds a Zero-copy presentation switch under Steam Settings, Display, Session Display (on by default), and a display-buffer allocator in the compositor: a Vulkan driver that states displayBuffers asks it for the memory of the images it exports, so frames presented through the nested compositor are gralloc buffers that go on the display layer without a copy. Compressed buffers are offered only where the device's allocator matches the layout the drivers render to; everything else stays on the copy path. The private buffer protocol is renamed to droiddeck-ahb-v1. * fix(display): zero-copy frames keep the full refresh rate Two buffers set on the game layer inside one refresh replaced each other, and a frame that slipped into the next refresh made the compositor hold and drop the on-time frame behind it. The layer now queues buffers, and a refresh takes a second frame when the one before it took none. The pacing tool no longer counts its dump time in the frame rate. * Keep cropped scenes on the display layer and pace layer frames evenly Accept any in-bounds source crop for the display layer and map the draw geometry the same way the copy path does. Time layer frames against the display's frame timeline, and when the game's rate is a steady whole fraction of the refresh rate show each frame a fixed number of refreshes after the last so uneven arrivals no longer reach the screen. * List zero-copy in the settings map * Hold display buffers until the display releases them A buffer the game or gamescope rendered straight into went back to its client as soon as the next one was latched, with the display's release fence attached to the dma-buf. The KGSL driver does not wait on that fence, so the client could draw into a buffer the panel was still reading. Display buffers now wait for the release fence before the release event, and gamescope composites only into output images the host has released. * Keep the game picture copy-free when an overlay has no display layer When the display cannot give a second layer of its own to an overlay, the compositor tells gamescope how many planes it can show directly. gamescope then composes its overlays into the game picture, which still reaches the display without a copy. * feat(session): the panel refresh rate follows the session's frame rate The session learns the panel's refresh rates and reports the refresh rate and frame rate it wants. The panel moves to the highest rate the frame rate divides evenly, frame generation counts at its output rate, and a panel whose rate the system holds offers only that rate. * feat(session): the panel follows a frame rate the game holds on its own The compositor reports the game's frame rate once a second. A rate that holds for three seconds and divides a panel rate becomes the content rate when neither the app's limit nor the session's limiter is setting the pace, so a game capped in its own settings gets a panel rate its frames divide into. A rate that was dropped has to hold twice as long before it is used again. * Show generated frames on the game's display layer With frame generation on, the game's own frames stay on their display layer untouched and each generated frame is placed on the same layer between them, timed across the game's frame interval. The compositor pass is kept when effects, HDR routing or a cursor need it, or when the panel cannot show the multiplied rate. * Keep scaling, generated frames and HDR on the display layer A scaler or frame generation with zero-copy on now draws once into the display layer instead of falling back to the copied surface. HDR output goes to the layer when the panel supports it; on a panel without HDR the picture is tone-mapped on the same path, and the toggle is labelled to match what the panel can do. * Spread a frame limit the refresh rate does not divide evenly across refreshes * Cover the spare-tick and panel-rate paths in the compositor source tests * Pin the gamescope build with the display-plane, release, refresh and limiter patches * Give the layer and terminal-caller harnesses the black fill state they compile against * feat(display): switch HDR during a session without restarting the app The compositor now offers HDR whenever the device can present it, and the HDR setting only decides whether the session uses it. Both HDR switches set gamescope's hdr_enabled, the compositor's HDR output and zero-copy for the running session. gamescope patch 0139 lets hdr_enabled change after start. The 'Restart the app to apply.' hint is removed from every locale. * Remake the output images in the new format when HDR is switched during a session * Pin the gamescope build that switches HDR during a session * Apply a saved HDR opt-out at session start and keep HDR retries with their session * Serialise the HDR output switch with the gate opening * feat(display): keep the client's HDR setting and the session's in step The session publishes its HDR state with the other device controls and the client helper applies it to the client's own display setting. A change made in the client is reported back and goes through the same switch the drawer and Session Display use, so all three always show one value. * fix(desktop): keep the display-buffer socket when the runtime directory is cleared The desktop launcher removed everything in the runtime directory except the compositor's Wayland socket, which took the display-buffer socket with it, so no desktop program could ask for display buffers and every frame was copied. * fix(display): the client's HDR setting follows the session in every client mode The bridge only ran when a variable nothing sets was present, so the client's HDR setting and the session's never met. It now runs whenever the session publishes an HDR state, and a client that has no such setting is asked again only every ten seconds. * fix(display): harden display-buffer hand-off, layer fallbacks and HDR sync - Stop closing a buffer handle's descriptor the allocator still owns, and free an allocation whose reply could not be sent. - Rebuild the advertised buffer formats when zero-copy is switched during a session. - Fall back to the copy path when a layer buffer cannot be allocated, and hide the game layer when it is skipped for a frame. - Keep a release fence that has not signalled instead of rendering into a buffer the display still reads. - Ignore a refresh-target reset from a client that does not own the target. - Restart the content-rate measurement after a pause, clear it when the game stops, and lengthen engagement only for a rate that was released before. - Compare colour conversions by their values, and read padded cursor buffers at their row width. - Use the running session's mode for the HDR and zero-copy settings, probe the display before screen effects are pushed, retry a held panel mode, and ignore callbacks after the activity is destroyed. - Write a newer HDR value while an earlier write is settling, and reapply the value after the bridge is reinstalled.
1456 lines
60 KiB
Python
Executable File
1456 lines
60 KiB
Python
Executable File
#!/usr/bin/python3
|
|
import base64
|
|
import ctypes
|
|
import json
|
|
import math
|
|
import os
|
|
import runpy
|
|
import select
|
|
import signal
|
|
import socket
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
HERE = os.path.dirname(os.path.realpath(__file__))
|
|
COMPAT = runpy.run_path(os.path.join(HERE, "steam-compatibility"))
|
|
BINDING = "droiddeckCompatChanged"
|
|
BRIGHTNESS_BINDING = "droiddeckBrightnessChanged"
|
|
CONTROLS_DIR = "/etc/droiddeck-device-controls"
|
|
LIBRARY_ART_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckLibraryArt) return "present";
|
|
const store = typeof appStore === "object" ? appStore : null;
|
|
if (typeof store?.BHasCachedLibraryAsset !== "function") return "unavailable";
|
|
// The client reports which cached assets exist only after a logon that reaches Steam; before that every app reads as
|
|
// uncached and the UI asks the CDN, which is blank offline. The native check still runs, so misses are still reported.
|
|
const native = store.BHasCachedLibraryAsset.bind(store);
|
|
store.BHasCachedLibraryAsset = (appid, version, type) => native(appid, version, type) || !version;
|
|
window.__droiddeckLibraryArt = true;
|
|
return "installed";
|
|
})()
|
|
"""
|
|
BRIGHTNESS_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckBrightness) return "present";
|
|
const display = SteamClient.System?.Display;
|
|
if (!display?.RegisterForBrightnessChanges || !display?.SetBrightness) return "unavailable";
|
|
const self = { expected: null, updating: true, revision: 0, localAt: -Infinity };
|
|
// A held stick steps Steam faster than Android's readback returns; those stale readbacks would snap the slider back.
|
|
const HOLD_MS = 750;
|
|
// Returns "held" while a readback is being ignored, so the caller retries it after the hold.
|
|
self.set = value => {
|
|
if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return true;
|
|
if (performance.now() - self.localAt < HOLD_MS) return "held";
|
|
if (!self.updating && self.expected !== null && Math.abs(value - self.expected) < 0.0001) return true;
|
|
self.expected = value;
|
|
self.updating = true;
|
|
const revision = ++self.revision;
|
|
setTimeout(() => { if (self.revision === revision) self.updating = false; }, 500);
|
|
display.SetBrightness(value);
|
|
return true;
|
|
};
|
|
self.subscription = display.RegisterForBrightnessChanges(state => {
|
|
const value = state?.flBrightness;
|
|
if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1 || self.expected === null) return;
|
|
if (Math.abs(value - self.expected) < 0.0001) { self.updating = false; return; }
|
|
if (self.updating) { self.updating = false; return; }
|
|
self.expected = value;
|
|
self.localAt = performance.now();
|
|
if (typeof window.__BINDING__ === "function") window.__BINDING__(String(value));
|
|
});
|
|
window.__droiddeckBrightness = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", BRIGHTNESS_BINDING)
|
|
|
|
|
|
def control_request(name, text, directory):
|
|
path = os.path.join(directory, name)
|
|
with open(path + ".tmp", "w") as target:
|
|
target.write(text + "\n")
|
|
os.replace(path + ".tmp", path)
|
|
|
|
|
|
def brightness_request(payload, directory=CONTROLS_DIR):
|
|
try:
|
|
value = float(payload)
|
|
if not math.isfinite(value) or not 0 <= value <= 1:
|
|
return
|
|
control_request("brightness.request", str(value), directory)
|
|
except (ValueError, TypeError, OSError):
|
|
return
|
|
|
|
|
|
def hdr_request(payload, directory=CONTROLS_DIR):
|
|
if payload not in ("0", "1"):
|
|
return
|
|
try:
|
|
control_request("hdr.request", payload, directory)
|
|
except OSError:
|
|
return
|
|
|
|
|
|
INSTALL_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckCompat) return "present";
|
|
const enc = new TextEncoder(), dec = new TextDecoder();
|
|
const varint = (value, out) => { let n = BigInt(value); do { let b = Number(n & 0x7fn); n >>= 7n; if (n) b |= 0x80; out.push(b); } while (n); };
|
|
const key = (field, wire, out) => varint(field * 8 + wire, out);
|
|
const str = (field, s, out) => { const b = enc.encode(s); key(field, 2, out); varint(b.length, out); for (const x of b) out.push(x); };
|
|
const uint = (field, v, out) => { key(field, 0, out); varint(v, out); };
|
|
const fixed64 = (field, v, out) => { key(field, 1, out); let n = BigInt(v); for (let i = 0; i < 8; i++) { out.push(Number(n & 0xffn)); n >>= 8n; } };
|
|
const parse = (bytes) => {
|
|
const fields = {};
|
|
let i = 0;
|
|
const read = () => { let r = 0n, s = 0n, b; do { b = bytes[i++]; r |= BigInt(b & 0x7f) << s; s += 7n; } while (b & 0x80); return r; };
|
|
while (i < bytes.length) {
|
|
const k = Number(read()), field = k >> 3, wire = k & 7;
|
|
let v;
|
|
if (wire === 0) v = read();
|
|
else if (wire === 1) { v = 0n; for (let j = 0; j < 8; j++) v |= BigInt(bytes[i + j]) << BigInt(8 * j); i += 8; }
|
|
else if (wire === 2) { const n = Number(read()); v = bytes.subarray(i, i + n); i += n; }
|
|
else if (wire === 5) { v = bytes.subarray(i, i + 4); i += 4; }
|
|
else throw new Error("unexpected wire type " + wire);
|
|
(fields[field] = fields[field] || []).push(v);
|
|
}
|
|
return fields;
|
|
};
|
|
const text = (f, n) => f[n] ? dec.decode(f[n][0]) : "";
|
|
const self = { seq: 0, pending: new Map(), ws: null, opening: null, changes: 0 };
|
|
const frame = (method, body, auth) => {
|
|
const h = [];
|
|
fixed64(10, ++self.seq, h);
|
|
str(12, method, h);
|
|
if (auth) str(40, auth, h);
|
|
const out = new Uint8Array(8 + h.length + body.length);
|
|
const view = new DataView(out.buffer);
|
|
view.setUint32(0, (0x80000000 | 146) >>> 0, true);
|
|
view.setUint32(4, h.length, true);
|
|
out.set(h, 8);
|
|
out.set(body, 8 + h.length);
|
|
return [self.seq, out];
|
|
};
|
|
const onMessage = (event) => {
|
|
const bytes = new Uint8Array(event.data);
|
|
const length = new DataView(event.data).getUint32(4, true);
|
|
const header = parse(bytes.subarray(8, 8 + length));
|
|
const target = header[11] ? Number(header[11][0] & 0xffffffffn) : -1;
|
|
if (self.pending.has(target)) {
|
|
const done = self.pending.get(target);
|
|
self.pending.delete(target);
|
|
const result = header[13] ? Number(header[13][0]) : 2;
|
|
done(result === 1 ? { ok: true, body: parse(bytes.subarray(8 + length)) } : { ok: false, eresult: result, error: text(header, 14) });
|
|
return;
|
|
}
|
|
if (text(header, 12).startsWith("CompatManager.NotifyStateChanged")) {
|
|
self.changes++;
|
|
if (typeof window.__BINDING__ === "function") window.__BINDING__(String(self.changes));
|
|
}
|
|
};
|
|
const send = (method, body, auth) => new Promise((resolve, reject) => {
|
|
const [id, out] = frame(method, Uint8Array.from(body), auth);
|
|
const timer = setTimeout(() => { self.pending.delete(id); reject(new Error(method + " timed out")); }, 10000);
|
|
self.pending.set(id, (r) => { clearTimeout(timer); resolve(r); });
|
|
self.ws.send(out);
|
|
});
|
|
const open = async () => {
|
|
const info = await SteamClient.WebUITransport.GetTransportInfo();
|
|
const ws = new WebSocket("ws://127.0.0.1:" + info.portClientdll + "/transportsocket/");
|
|
ws.binaryType = "arraybuffer";
|
|
await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = () => reject(new Error("the client's transport refused the connection")); });
|
|
ws.onmessage = onMessage;
|
|
ws.onclose = () => {
|
|
if (self.ws === ws) self.ws = null;
|
|
for (const done of self.pending.values()) done({ ok: false, eresult: 0, error: "connection closed" });
|
|
self.pending.clear();
|
|
};
|
|
self.ws = ws;
|
|
const body = [];
|
|
str(1, info.authKeyClientdll, body);
|
|
const r = await send("TransportAuth.Authenticate#1", body, info.authKeyClientdll);
|
|
if (!r.ok) { ws.close(); throw new Error("the client's transport refused authentication (" + r.eresult + ")"); }
|
|
};
|
|
const ready = async () => {
|
|
if (self.ws && self.ws.readyState === 1) return;
|
|
if (!self.opening) self.opening = open().finally(() => { self.opening = null; });
|
|
await self.opening;
|
|
};
|
|
self.get = async (appid) => {
|
|
await ready();
|
|
const body = [];
|
|
uint(1, appid, body);
|
|
const r = await send("CompatManager.GetCompatTools#1", body);
|
|
if (!r.ok) throw Object.assign(new Error("GetCompatTools " + appid + " failed (" + r.eresult + " " + r.error + ")"), { eresult: r.eresult });
|
|
return { selected: text(r.body, 3), fallback: text(r.body, 4), tools: (r.body[1] || []).map((t) => text(parse(t), 1)) };
|
|
};
|
|
self.set = async (appid, name) => {
|
|
await ready();
|
|
const body = [];
|
|
uint(1, appid, body);
|
|
str(2, name, body);
|
|
const r = await send("CompatManager.SpecifyCompatTool#1", body);
|
|
if (!r.ok) throw new Error("SpecifyCompatTool " + appid + " " + name + " failed (" + r.eresult + " " + r.error + ")");
|
|
return true;
|
|
};
|
|
self.many = async (apps) => {
|
|
const out = {};
|
|
for (const app of apps) {
|
|
try {
|
|
out[app] = (await self.get(Number(app))).selected;
|
|
} catch (e) {
|
|
if (e.eresult !== 128) throw e;
|
|
}
|
|
}
|
|
return out;
|
|
};
|
|
window.__droiddeckCompat = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", BINDING)
|
|
TOOLS_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckTools) return "present";
|
|
const installs = SteamClient.Installs, downloads = SteamClient.Downloads;
|
|
if (typeof installs?.OpenInstallWizard !== "function" || typeof installs?.RegisterForShowInstallWizard !== "function" ||
|
|
typeof installs?.ContinueInstall !== "function" || typeof downloads?.QueueAppUpdate !== "function")
|
|
throw new Error("the client's install calls are not ready");
|
|
const self = { asked: new Map() };
|
|
installs.RegisterForShowInstallWizard((state) => {
|
|
const app = Number(state?.currentAppID);
|
|
if (state?.eInstallState === 7 && Date.now() - (self.asked.get(app) || 0) < 120000) {
|
|
self.asked.delete(app);
|
|
installs.ContinueInstall();
|
|
}
|
|
});
|
|
self.install = (app) => { self.asked.set(app, Date.now()); installs.OpenInstallWizard([app], "0"); return true; };
|
|
self.update = (app) => { downloads.QueueAppUpdate(app, "0"); return true; };
|
|
window.__droiddeckTools = self;
|
|
return "installed";
|
|
})()
|
|
"""
|
|
TOOL_CHECK_SECONDS = 60
|
|
TOOL_RETRY_SECONDS = 300
|
|
SWITCH_BINDING = "droiddeckSwitchToDesktop"
|
|
SWITCH_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckSwitch) return "present";
|
|
const name = new TextEncoder().encode("SteamOSManager.SwitchToDesktop#");
|
|
const send = WebSocket.prototype.send;
|
|
const asks = (data) => {
|
|
const bytes = data instanceof ArrayBuffer ? new Uint8Array(data)
|
|
: ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : null;
|
|
if (!bytes) return false;
|
|
const end = Math.min(bytes.length, 256) - name.length;
|
|
for (let i = 8; i <= end; i++) {
|
|
let j = 0;
|
|
while (j < name.length && bytes[i + j] === name[j]) j++;
|
|
if (j === name.length) return true;
|
|
}
|
|
return false;
|
|
};
|
|
WebSocket.prototype.send = function (data) {
|
|
if (typeof window.__BINDING__ === "function" && asks(data)) window.__BINDING__("");
|
|
return send.call(this, data);
|
|
};
|
|
window.__droiddeckSwitch = true;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", SWITCH_BINDING)
|
|
SESSION_SELECT = "/usr/bin/steamos-session-select"
|
|
TOUR_JS = r"""
|
|
(() => {
|
|
let key = 140014 * 8;
|
|
const bytes = [];
|
|
while (key > 127) { bytes.push((key & 127) | 128); key = Math.floor(key / 128); }
|
|
bytes.push(key, 0);
|
|
SteamClient.Settings.SetSetting(btoa(String.fromCharCode(...bytes)));
|
|
return "off";
|
|
})()
|
|
"""
|
|
SET_SETTING_JS = r"""(field, value) => {
|
|
const bytes = [];
|
|
for (let n of [field * 8, value]) {
|
|
while (n > 127) { bytes.push((n & 127) | 128); n = Math.floor(n / 128); }
|
|
bytes.push(n);
|
|
}
|
|
return SteamClient.Settings.SetSetting(btoa(String.fromCharCode(...bytes)));
|
|
}"""
|
|
HDR_BINDING = "droiddeckHdrChanged"
|
|
HDR_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckHdr) return "present";
|
|
const settings = window.settingsStore;
|
|
if (typeof settings?.clientSettings?.gamescope_hdr_enabled !== "boolean" ||
|
|
typeof SteamClient.Settings?.SetSetting !== "function") return "unavailable";
|
|
const write = __SET_SETTING__;
|
|
const HOLD_MS = 3000;
|
|
const self = { known: settings.clientSettings.gamescope_hdr_enabled, pending: null, until: 0 };
|
|
self.set = value => {
|
|
if (typeof value !== "boolean") return true;
|
|
self.known = value;
|
|
if (settings.clientSettings.gamescope_hdr_enabled === value && self.pending === null) return true;
|
|
self.pending = value;
|
|
self.until = performance.now() + HOLD_MS;
|
|
write(21015, value ? 1 : 0);
|
|
return true;
|
|
};
|
|
self.check = () => {
|
|
const value = settings.clientSettings.gamescope_hdr_enabled;
|
|
if (typeof value !== "boolean") return;
|
|
if (self.pending !== null) {
|
|
if (value !== self.pending && performance.now() < self.until) return;
|
|
self.pending = null;
|
|
}
|
|
if (value === self.known) return;
|
|
self.known = value;
|
|
if (typeof window.__BINDING__ === "function") window.__BINDING__(value ? "1" : "0");
|
|
};
|
|
self.interval = setInterval(self.check, 500);
|
|
window.__droiddeckHdr = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", HDR_BINDING).replace("__SET_SETTING__", SET_SETTING_JS)
|
|
FRAME_LIMIT_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckFrameLimit) return "present";
|
|
const settings = window.settingsStore;
|
|
let service = null;
|
|
try {
|
|
// Steam's webpack does not expose its module cache; the gamescope service client is found by
|
|
// the calls its module makes and loaded by id.
|
|
let require;
|
|
window.webpackChunksteamui.push([[Symbol("droiddeck-frame-limit")], {}, r => { require = r; }]);
|
|
for (const id of Object.keys(require.m || {})) {
|
|
const source = String(require.m[id]);
|
|
if (!source.includes("SetBlurParams") || !source.includes("RegisterForNotifyStateChanged")) continue;
|
|
let exports;
|
|
try { exports = require(id); } catch (e) { continue; }
|
|
if (!exports || typeof exports !== "object") continue;
|
|
service = Object.values(exports).find(value => value && typeof value.GetState === "function" &&
|
|
typeof value.RegisterForNotifyStateChanged === "function" && typeof value.SetBlurParams === "function");
|
|
if (service) break;
|
|
}
|
|
} catch (e) {
|
|
service = null;
|
|
}
|
|
if (!service || !settings?.clientSettings || typeof SteamClient.Settings?.SetSetting !== "function") return "unavailable";
|
|
const self = { timer: null };
|
|
const write = value => (__SET_SETTING__)(21002, value);
|
|
self.check = async () => {
|
|
let rates;
|
|
try {
|
|
const reply = await service.GetState({});
|
|
if (!reply.BSuccess()) return;
|
|
rates = reply.Body().toObject().state?.active_display_info?.supported_frame_rates;
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
if (!Array.isArray(rates) || rates.length === 0) return;
|
|
const current = settings.clientSettings;
|
|
if (!current.gamescope_enable_app_target_framerate || rates.includes(current.gamescope_app_target_framerate)) return;
|
|
try {
|
|
await write(Math.max(...rates));
|
|
} catch (e) {
|
|
}
|
|
};
|
|
self.schedule = () => {
|
|
clearTimeout(self.timer);
|
|
self.timer = setTimeout(self.check, 1500);
|
|
};
|
|
self.subscription = service.RegisterForNotifyStateChanged(self.schedule);
|
|
self.interval = setInterval(self.schedule, 5000);
|
|
self.schedule();
|
|
window.__droiddeckFrameLimit = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__SET_SETTING__", SET_SETTING_JS)
|
|
WINDOW_BINDING = "droiddeckWindowAction"
|
|
WINDOW_TARGET = "createflags=18"
|
|
WINDOW_MOVES = {"nw": 0, "n": 1, "ne": 2, "e": 3, "se": 4, "s": 5, "sw": 6, "w": 7, "move": 8}
|
|
WINDOW_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckWindow) return "present";
|
|
const EDGE = 5, CORNER = 10, THRESHOLD = 3;
|
|
const CURSORS = { n: "ns-resize", s: "ns-resize", e: "ew-resize", w: "ew-resize",
|
|
ne: "nesw-resize", sw: "nesw-resize", nw: "nwse-resize", se: "nwse-resize" };
|
|
const send = action => window.droiddeckWindowAction(action);
|
|
const filled = () => innerWidth >= screen.availWidth && innerHeight >= screen.availHeight - 60;
|
|
const side = e => {
|
|
if (filled()) return "";
|
|
const right = innerWidth - e.clientX, bottom = innerHeight - e.clientY;
|
|
const near = (a, b) => a < EDGE || (a < CORNER && b < CORNER);
|
|
const across = Math.min(e.clientX, right), along = Math.min(e.clientY, bottom);
|
|
const v = near(e.clientY, across) ? "n" : near(bottom, across) ? "s" : "";
|
|
const h = near(e.clientX, along) ? "w" : near(right, along) ? "e" : "";
|
|
return v + h;
|
|
};
|
|
const dragging = (x, y) => {
|
|
for (const node of document.elementsFromPoint(x, y)) {
|
|
const region = getComputedStyle(node).webkitAppRegion;
|
|
if (region === "drag") return true;
|
|
if (region === "no-drag") return false;
|
|
}
|
|
return [...document.querySelectorAll("*")].some(node => {
|
|
if (getComputedStyle(node).webkitAppRegion !== "drag") return false;
|
|
const box = node.getBoundingClientRect();
|
|
return x >= box.left && x < box.right && y >= box.top && y < box.bottom;
|
|
});
|
|
};
|
|
const style = document.createElement("style");
|
|
document.documentElement.append(style);
|
|
let press = null, shown = "";
|
|
addEventListener("pointermove", e => {
|
|
if (press) {
|
|
if (Math.hypot(e.clientX - press.x, e.clientY - press.y) >= THRESHOLD) {
|
|
const hit = dragging(press.x, press.y);
|
|
press = null;
|
|
if (hit) send("move");
|
|
}
|
|
return;
|
|
}
|
|
const cursor = e.buttons ? shown : side(e);
|
|
if (cursor !== shown) {
|
|
shown = cursor;
|
|
style.textContent = cursor ? `* { cursor: ${CURSORS[cursor]} !important; }` : "";
|
|
}
|
|
}, true);
|
|
addEventListener("pointerdown", e => {
|
|
if (e.button !== 0) return;
|
|
const edge = side(e);
|
|
if (edge) {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
send(edge);
|
|
} else {
|
|
press = { x: e.clientX, y: e.clientY };
|
|
}
|
|
}, true);
|
|
addEventListener("pointerup", () => { press = null; }, true);
|
|
addEventListener("dblclick", e => { if (dragging(e.clientX, e.clientY) && !side(e)) send("maximize"); }, true);
|
|
SteamClient.Window.ToggleMaximize = () => send("maximize");
|
|
window.__droiddeckWindow = true;
|
|
return "installed";
|
|
})()
|
|
"""
|
|
FILE_BINDING = "droiddeckOpenFileDialog"
|
|
FILE_JS = r"""
|
|
(() => {
|
|
const cancelled = () => ({ result: 2, message: "" });
|
|
if (window.__droiddeckFiles) {
|
|
window.__droiddeckFiles.cancelAll();
|
|
return "present";
|
|
}
|
|
const self = { next: 0, pending: new Map() };
|
|
const open = function (options) {
|
|
return new Promise((resolve, reject) => {
|
|
if (typeof window.__BINDING__ !== "function") { reject(cancelled()); return; }
|
|
const id = ++self.next;
|
|
self.pending.set(id, { resolve, reject });
|
|
try { window.__BINDING__(JSON.stringify({ id, options: options || {} })); }
|
|
catch (e) { self.pending.delete(id); reject(cancelled()); }
|
|
});
|
|
};
|
|
self.done = (id, path) => {
|
|
const item = self.pending.get(id);
|
|
if (!item) return false;
|
|
self.pending.delete(id);
|
|
if (typeof path === "string" && path) item.resolve(path); else item.reject(cancelled());
|
|
return true;
|
|
};
|
|
self.cancelAll = () => {
|
|
const items = Array.from(self.pending.values());
|
|
self.pending.clear();
|
|
for (const item of items) item.reject(cancelled());
|
|
};
|
|
const patch = (w) => {
|
|
const system = w?.SteamClient?.System;
|
|
if (system && system.OpenFileDialog !== open) system.OpenFileDialog = open;
|
|
};
|
|
patch(window);
|
|
if (SteamClient.System.OpenFileDialog !== open) throw new Error("Steam OpenFileDialog could not be redirected");
|
|
const popups = window.g_PopupManager;
|
|
if (popups) {
|
|
for (const popup of popups.GetPopups?.() || []) patch(popup.window);
|
|
popups.AddPopupCreatedCallback?.((popup) => patch(popup.window));
|
|
}
|
|
window.__droiddeckFiles = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", FILE_BINDING)
|
|
VR_BINDING = "droiddeckLaunchSteamVr"
|
|
VR_HELPER = "/usr/local/bin/droiddeck-steamvr"
|
|
VR_JS = r"""
|
|
(() => {
|
|
if (window.__droiddeckSteamVr) return "present";
|
|
const apps = SteamClient.Apps;
|
|
if (!apps || typeof apps.RunGame !== "function") throw new Error("Steam RunGame is not ready");
|
|
const run = apps.RunGame;
|
|
const self = { running: false, pending: new Map(), lastError: null };
|
|
const flush = () => {
|
|
if (!self.running) return;
|
|
const queued = Array.from(self.pending.values());
|
|
self.pending.clear();
|
|
for (const item of queued) {
|
|
clearTimeout(item.timer);
|
|
run.call(item.receiver, item.id, ...item.args);
|
|
}
|
|
};
|
|
if (typeof SteamClient.OpenVR?.RegisterForVRModeChange === "function") {
|
|
self.subscription = SteamClient.OpenVR.RegisterForVRModeChange(running => {
|
|
self.running = !!running;
|
|
flush();
|
|
});
|
|
}
|
|
const wrapped = function (id, ...args) {
|
|
const gameid = String(id);
|
|
if (typeof window.__BINDING__ !== "function") return run.call(this, id, ...args);
|
|
if (gameid === "250820") {
|
|
window.__BINDING__(gameid);
|
|
return;
|
|
}
|
|
const overview = window.appStore?.GetAppOverviewByGameID?.(gameid);
|
|
const vr = overview?.vr_only === true;
|
|
if (vr && self.subscription && /^[1-9][0-9]{0,19}$/.test(gameid)) {
|
|
if (self.pending.has(gameid)) return;
|
|
self.lastError = null;
|
|
const item = { receiver: this, id, args, timer: null };
|
|
item.timer = setTimeout(() => {
|
|
self.pending.delete(gameid);
|
|
self.lastError = "SteamVR did not become ready. Start SteamVR from DroidDeck and try the game again.";
|
|
console.error("DroidDeck: " + self.lastError);
|
|
}, 600000);
|
|
self.pending.set(gameid, item);
|
|
try { window.__BINDING__(gameid); }
|
|
catch (e) { clearTimeout(item.timer); self.pending.delete(gameid); throw e; }
|
|
flush();
|
|
return;
|
|
}
|
|
return run.call(this, id, ...args);
|
|
};
|
|
apps.RunGame = wrapped;
|
|
if (apps.RunGame !== wrapped) throw new Error("Steam RunGame could not be redirected");
|
|
if (typeof SteamClient.OpenVR?.StartVR === "function") {
|
|
const start = SteamClient.OpenVR.StartVR;
|
|
SteamClient.OpenVR.StartVR = function (...args) {
|
|
if (typeof window.__BINDING__ === "function") return window.__BINDING__("250820");
|
|
return start.apply(this, args);
|
|
};
|
|
}
|
|
window.__droiddeckSteamVr = self;
|
|
return "installed";
|
|
})()
|
|
""".replace("__BINDING__", VR_BINDING)
|
|
|
|
|
|
def launch_steamvr():
|
|
say("SteamVR library launch: using the DroidDeck ARM64 helper")
|
|
state = os.path.join(os.environ.get("XDG_RUNTIME_DIR", "/tmp"), "droiddeck-steamvr")
|
|
try:
|
|
os.makedirs(state, exist_ok=True)
|
|
with open(os.path.join(state, "library-launch.log"), "a") as log:
|
|
return subprocess.Popen([VR_HELPER, "launch"], stdin=subprocess.DEVNULL,
|
|
stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
|
|
except OSError as e:
|
|
say("SteamVR library launch failed: %s" % e)
|
|
|
|
|
|
def choose_file(options):
|
|
import gi
|
|
gi.require_version("Gdk", "3.0")
|
|
gi.require_version("Gtk", "3.0")
|
|
from gi.repository import Gdk, Gtk
|
|
directory = bool(options.get("bChooseDirectory"))
|
|
save = bool(options.get("bSaveMode")) and not directory
|
|
action = (Gtk.FileChooserAction.SELECT_FOLDER if directory else
|
|
Gtk.FileChooserAction.SAVE if save else Gtk.FileChooserAction.OPEN)
|
|
dialog = Gtk.FileChooserDialog(title=str(options.get("strTitle") or ""), action=action)
|
|
dialog.add_buttons("gtk-cancel", Gtk.ResponseType.CANCEL,
|
|
"gtk-save" if save else "gtk-open", Gtk.ResponseType.ACCEPT)
|
|
dialog.set_default_response(Gtk.ResponseType.ACCEPT)
|
|
dialog.set_local_only(True)
|
|
dialog.set_do_overwrite_confirmation(True)
|
|
for folder in ("/root/Storage", "/mnt/droiddeck-sd"):
|
|
if os.path.isdir(folder):
|
|
try:
|
|
dialog.add_shortcut_folder(folder)
|
|
except Exception:
|
|
pass
|
|
if not directory:
|
|
for entry in options.get("rgFilters") or []:
|
|
patterns = [str(p) for p in entry.get("rFilePatterns") or [] if p]
|
|
if not patterns:
|
|
continue
|
|
chosen = Gtk.FileFilter()
|
|
chosen.set_name(str(entry.get("strFileTypeName") or ", ".join(patterns)))
|
|
for pattern in patterns:
|
|
pattern = "*" if pattern == "*.*" else pattern
|
|
chosen.add_pattern(pattern)
|
|
if pattern.lower() != pattern.upper():
|
|
chosen.add_pattern(pattern.upper())
|
|
dialog.add_filter(chosen)
|
|
if entry.get("bUseAsDefault"):
|
|
dialog.set_filter(chosen)
|
|
initial = str(options.get("strInitialFile") or "").strip('"')
|
|
if initial:
|
|
if os.path.isdir(initial):
|
|
dialog.set_current_folder(initial)
|
|
elif save:
|
|
if os.path.isdir(os.path.dirname(initial)):
|
|
dialog.set_current_folder(os.path.dirname(initial))
|
|
dialog.set_current_name(os.path.basename(initial))
|
|
elif os.path.exists(initial):
|
|
dialog.set_filename(initial)
|
|
elif os.path.isdir(os.path.dirname(initial)):
|
|
dialog.set_current_folder(os.path.dirname(initial))
|
|
screen = Gdk.Screen.get_default()
|
|
if screen is not None:
|
|
dialog.set_default_size(screen.get_width(), screen.get_height())
|
|
chosen_path = dialog.get_filename() if dialog.run() == Gtk.ResponseType.ACCEPT else None
|
|
dialog.destroy()
|
|
return chosen_path
|
|
|
|
|
|
class Closed(Exception):
|
|
pass
|
|
|
|
|
|
def say(message):
|
|
print("droiddeck-steam-compat: %s" % message, flush=True)
|
|
|
|
|
|
def called(event, name):
|
|
return event.get("method") == "Runtime.bindingCalled" and event.get("params", {}).get("name") == name
|
|
|
|
|
|
def switch_to_desktop():
|
|
say("Switch to Desktop: asking for the desktop")
|
|
try:
|
|
subprocess.call([SESSION_SELECT, "plasma"])
|
|
except OSError as e:
|
|
say("Switch to Desktop failed: %s" % e)
|
|
|
|
|
|
def connect(port, timeout=5):
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock.settimeout(timeout)
|
|
try:
|
|
sock.bind(("127.0.0.1", 0))
|
|
sock.connect(("127.0.0.1", port))
|
|
except OSError:
|
|
sock.close()
|
|
raise
|
|
return sock
|
|
|
|
|
|
def http_get(port, path):
|
|
sock = connect(port)
|
|
try:
|
|
sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nConnection: close\r\n\r\n" % (path, port)).encode())
|
|
data = b""
|
|
length = None
|
|
while length is None or len(data) < length:
|
|
chunk = sock.recv(65536)
|
|
if not chunk:
|
|
break
|
|
data += chunk
|
|
if length is None and b"\r\n\r\n" in data:
|
|
head, _, rest = data.partition(b"\r\n\r\n")
|
|
for line in head.split(b"\r\n")[1:]:
|
|
name, _, value = line.partition(b":")
|
|
if name.strip().lower() == b"content-length":
|
|
length = int(value.strip())
|
|
if length is None:
|
|
length = float("inf")
|
|
data = rest
|
|
if not head.startswith(b"HTTP/1.1 200"):
|
|
raise OSError("devtools answered %r" % head[:40])
|
|
finally:
|
|
sock.close()
|
|
return json.loads(data.decode("utf-8", "replace"))
|
|
|
|
|
|
class WebSocket:
|
|
def __init__(self, port, path):
|
|
self.sock = connect(port)
|
|
key = base64.b64encode(os.urandom(16)).decode()
|
|
self.sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n"
|
|
"Sec-WebSocket-Key: %s\r\nSec-WebSocket-Version: 13\r\n\r\n" % (path, port, key)).encode())
|
|
self.buffer = b""
|
|
while b"\r\n\r\n" not in self.buffer:
|
|
self.fill()
|
|
head, _, self.buffer = self.buffer.partition(b"\r\n\r\n")
|
|
if not head.startswith(b"HTTP/1.1 101"):
|
|
raise OSError("devtools refused the websocket: %r" % head[:60])
|
|
self.sock.settimeout(None)
|
|
|
|
def fileno(self):
|
|
return self.sock.fileno()
|
|
|
|
def fill(self):
|
|
chunk = self.sock.recv(65536)
|
|
if not chunk:
|
|
raise Closed("devtools closed the connection")
|
|
self.buffer += chunk
|
|
|
|
def take(self, n):
|
|
while len(self.buffer) < n:
|
|
self.fill()
|
|
data, self.buffer = self.buffer[:n], self.buffer[n:]
|
|
return data
|
|
|
|
def send(self, text, opcode=1):
|
|
payload = text.encode() if isinstance(text, str) else text
|
|
mask = os.urandom(4)
|
|
n = len(payload)
|
|
if n < 126:
|
|
head = struct.pack("!BB", 0x80 | opcode, 0x80 | n)
|
|
elif n < 65536:
|
|
head = struct.pack("!BBH", 0x80 | opcode, 0xFE, n)
|
|
else:
|
|
head = struct.pack("!BBQ", 0x80 | opcode, 0xFF, n)
|
|
self.sock.sendall(head + mask + bytes(b ^ mask[i % 4] for i, b in enumerate(payload)))
|
|
|
|
def pending(self):
|
|
return len(self.buffer) > 0
|
|
|
|
def recv(self):
|
|
message = b""
|
|
while True:
|
|
first, second = self.take(2)
|
|
n = second & 0x7F
|
|
if n == 126:
|
|
n = struct.unpack("!H", self.take(2))[0]
|
|
elif n == 127:
|
|
n = struct.unpack("!Q", self.take(8))[0]
|
|
mask = self.take(4) if second & 0x80 else None
|
|
payload = self.take(n)
|
|
if mask:
|
|
payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
|
|
opcode = first & 0x0F
|
|
if opcode == 8:
|
|
raise Closed("devtools closed the websocket")
|
|
if opcode == 9:
|
|
self.send(payload, 10)
|
|
continue
|
|
if opcode == 10:
|
|
continue
|
|
message += payload
|
|
if first & 0x80:
|
|
return message.decode("utf-8", "replace")
|
|
|
|
def close(self):
|
|
try:
|
|
self.sock.close()
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
class Page:
|
|
def __init__(self, port, path):
|
|
self.ws = WebSocket(port, path)
|
|
self.next_id = 0
|
|
self.events = []
|
|
|
|
def call(self, method, params=None, timeout=30):
|
|
self.next_id += 1
|
|
mine = self.next_id
|
|
self.ws.send(json.dumps({"id": mine, "method": method, "params": params or {}}))
|
|
deadline = time.monotonic() + timeout
|
|
while True:
|
|
if not self.ws.pending():
|
|
left = deadline - time.monotonic()
|
|
if left <= 0 or not select.select([self.ws], [], [], left)[0]:
|
|
raise TimeoutError("%s timed out" % method)
|
|
message = json.loads(self.ws.recv())
|
|
if message.get("id") == mine:
|
|
if "error" in message:
|
|
raise RuntimeError("%s: %s" % (method, message["error"].get("message")))
|
|
return message.get("result", {})
|
|
if "method" in message:
|
|
self.events.append(message)
|
|
|
|
def evaluate(self, expression, timeout=30):
|
|
result = self.call("Runtime.evaluate", {"expression": expression, "awaitPromise": True, "returnByValue": True}, timeout)
|
|
if "exceptionDetails" in result:
|
|
details = result["exceptionDetails"]
|
|
raise RuntimeError((details.get("exception") or {}).get("description") or details.get("text") or "script failed")
|
|
return result.get("result", {}).get("value")
|
|
|
|
def tools(self, call):
|
|
return self.evaluate("%s;\nwindow.__droiddeckTools.%s" % (TOOLS_JS, call))
|
|
|
|
def compat(self, call):
|
|
return self.evaluate("%s;\nwindow.__droiddeckCompat.%s" % (INSTALL_JS, call))
|
|
|
|
def drain(self):
|
|
while True:
|
|
if not self.ws.pending() and not select.select([self.ws], [], [], 0)[0]:
|
|
break
|
|
message = json.loads(self.ws.recv())
|
|
if "method" in message:
|
|
self.events.append(message)
|
|
events, self.events = self.events, []
|
|
return events
|
|
|
|
|
|
def shared_context(port):
|
|
for target in http_get(port, "/json/list"):
|
|
if target.get("title") == "SharedJSContext" and target.get("webSocketDebuggerUrl"):
|
|
path = target["webSocketDebuggerUrl"].split("/", 3)[3]
|
|
return "/" + path
|
|
return None
|
|
|
|
|
|
class Watcher:
|
|
MASK = 0x00000008 | 0x00000080 | 0x00000100 | 0x00000200
|
|
|
|
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((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:
|
|
for p in (f, os.path.dirname(f)):
|
|
try:
|
|
stamp.append(os.stat(p).st_mtime_ns)
|
|
except OSError:
|
|
stamp.append(0)
|
|
return stamp
|
|
|
|
def fileno(self):
|
|
return self.fd
|
|
|
|
def changed(self):
|
|
if self.fd < 0:
|
|
stamp = self.snapshot()
|
|
moved, self.stamp = stamp != self.stamp, stamp
|
|
return moved
|
|
names = set()
|
|
try:
|
|
while True:
|
|
data = os.read(self.fd, 65536)
|
|
if not data:
|
|
break
|
|
at = 0
|
|
while at + 16 <= len(data):
|
|
_, _, _, size = struct.unpack_from("iIII", data, at)
|
|
names.add(data[at + 16:at + 16 + size].split(b"\0", 1)[0].decode("utf-8", "replace"))
|
|
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 appeared or any(n in wanted or n.startswith("appmanifest_") for n in names)
|
|
|
|
|
|
class XMessage(ctypes.Structure):
|
|
_fields_ = [("type", ctypes.c_int), ("serial", ctypes.c_ulong), ("send_event", ctypes.c_int),
|
|
("display", ctypes.c_void_p), ("window", ctypes.c_ulong), ("message_type", ctypes.c_ulong),
|
|
("format", ctypes.c_int), ("data", ctypes.c_long * 5), ("pad", ctypes.c_long * 20)]
|
|
|
|
|
|
X_ERRORS = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(lambda display, error: 0)
|
|
|
|
|
|
def window_action(action):
|
|
if action != "maximize" and action not in WINDOW_MOVES:
|
|
return False
|
|
x11 = ctypes.CDLL("libX11.so.6")
|
|
x11.XOpenDisplay.restype = ctypes.c_void_p
|
|
x11.XOpenDisplay.argtypes = [ctypes.c_char_p]
|
|
x11.XDefaultRootWindow.restype = ctypes.c_ulong
|
|
x11.XDefaultRootWindow.argtypes = [ctypes.c_void_p]
|
|
x11.XInternAtom.restype = ctypes.c_ulong
|
|
x11.XInternAtom.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
|
|
x11.XGetWindowProperty.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_ulong, ctypes.c_long, ctypes.c_long,
|
|
ctypes.c_int, ctypes.c_ulong] + [ctypes.c_void_p] * 5
|
|
x11.XQueryPointer.argtypes = [ctypes.c_void_p, ctypes.c_ulong] + [ctypes.c_void_p] * 7
|
|
x11.XSendEvent.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_int, ctypes.c_long, ctypes.c_void_p]
|
|
x11.XFree.argtypes = [ctypes.c_void_p]
|
|
x11.XFlush.argtypes = [ctypes.c_void_p]
|
|
x11.XCloseDisplay.argtypes = [ctypes.c_void_p]
|
|
x11.XSetErrorHandler(X_ERRORS)
|
|
display = x11.XOpenDisplay(None)
|
|
if not display:
|
|
return False
|
|
try:
|
|
root = x11.XDefaultRootWindow(display)
|
|
atom = lambda name: x11.XInternAtom(display, name, 0)
|
|
kind, width, count, after = ctypes.c_ulong(), ctypes.c_int(), ctypes.c_ulong(), ctypes.c_ulong()
|
|
data = ctypes.c_void_p()
|
|
if x11.XGetWindowProperty(display, root, atom(b"_NET_ACTIVE_WINDOW"), 0, 1, 0, 33, ctypes.byref(kind),
|
|
ctypes.byref(width), ctypes.byref(count), ctypes.byref(after),
|
|
ctypes.byref(data)) != 0 or not data.value:
|
|
return False
|
|
window = ctypes.cast(data, ctypes.POINTER(ctypes.c_ulong))[0] if count.value else 0
|
|
x11.XFree(data)
|
|
if not window:
|
|
return False
|
|
if action == "maximize":
|
|
kind_name = b"_NET_WM_STATE"
|
|
values = [2, atom(b"_NET_WM_STATE_MAXIMIZED_VERT"), atom(b"_NET_WM_STATE_MAXIMIZED_HORZ"), 1, 0]
|
|
else:
|
|
ignored = ctypes.c_ulong()
|
|
x, y, inner, mask = ctypes.c_int(), ctypes.c_int(), ctypes.c_int(), ctypes.c_uint()
|
|
if not x11.XQueryPointer(display, root, ctypes.byref(ignored), ctypes.byref(ignored), ctypes.byref(x),
|
|
ctypes.byref(y), ctypes.byref(inner), ctypes.byref(inner), ctypes.byref(mask)):
|
|
return False
|
|
if not mask.value & 0x100:
|
|
return False
|
|
kind_name = b"_NET_WM_MOVERESIZE"
|
|
values = [x.value, y.value, WINDOW_MOVES[action], 1, 1]
|
|
message = XMessage(type=33, window=window, message_type=atom(kind_name), format=32)
|
|
message.data[:] = values
|
|
sent = x11.XSendEvent(display, root, 0, (1 << 19) | (1 << 20), ctypes.byref(message))
|
|
x11.XFlush(display)
|
|
return bool(sent)
|
|
finally:
|
|
x11.XCloseDisplay(display)
|
|
|
|
|
|
class Helper:
|
|
def __init__(self, steam_root, port, steamos=False, files_only=False):
|
|
self.steam_root = steam_root
|
|
self.port = port
|
|
self.steamos = steamos
|
|
self.files_only = files_only
|
|
self.page = None
|
|
self.known = set()
|
|
self.installed = None
|
|
self.fex_asked = set()
|
|
self.tools_asked = {}
|
|
self.tools_checked = None
|
|
self.vr_launch = None
|
|
self.chooser = None
|
|
self.controls_state = None
|
|
self.controls_installed = False
|
|
self.frame_limit_state = None
|
|
self.frame_limit_retry = 0
|
|
self.hdr_state = None
|
|
self.hdr_installed = False
|
|
self.hdr_retry = 0
|
|
self.windows = {}
|
|
self.windows_retry = 0
|
|
|
|
def sync_controls(self):
|
|
try:
|
|
with open(os.path.join(CONTROLS_DIR, "state.json")) as source:
|
|
state = json.load(source)
|
|
value = state.get("brightness")
|
|
if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or not 0 <= value <= 1:
|
|
return
|
|
if not self.controls_installed:
|
|
self.page.call("Runtime.addBinding", {"name": BRIGHTNESS_BINDING})
|
|
self.controls_installed = self.page.evaluate(BRIGHTNESS_JS) in ("installed", "present")
|
|
if not self.controls_installed:
|
|
return
|
|
if state != self.controls_state:
|
|
applied = self.page.evaluate("window.__droiddeckBrightness ? window.__droiddeckBrightness.set(%s) : false" % json.dumps(value))
|
|
if applied is True:
|
|
self.controls_state = state
|
|
elif applied != "held":
|
|
self.controls_installed = False
|
|
self.controls_state = None
|
|
except (OSError, ValueError, TypeError):
|
|
pass
|
|
|
|
def sync_windows(self):
|
|
if os.environ.get("XDG_CURRENT_DESKTOP") != "KDE":
|
|
return
|
|
if time.monotonic() >= self.windows_retry:
|
|
self.windows_retry = time.monotonic() + 2
|
|
try:
|
|
targets = http_get(self.port, "/json/list")
|
|
except (OSError, ValueError):
|
|
targets = []
|
|
seen = set()
|
|
for target in targets:
|
|
url = target.get("webSocketDebuggerUrl")
|
|
if WINDOW_TARGET not in target.get("url", "").split("&")[0] or not url:
|
|
continue
|
|
seen.add(target.get("id"))
|
|
try:
|
|
page = self.windows.get(target.get("id"))
|
|
if page is None:
|
|
page = Page(self.port, "/" + url.split("/", 3)[3])
|
|
page.call("Runtime.addBinding", {"name": WINDOW_BINDING}, timeout=5)
|
|
self.windows[target.get("id")] = page
|
|
page.evaluate(WINDOW_JS, timeout=5)
|
|
except (Closed, OSError, RuntimeError, ValueError) as e:
|
|
say("window controls: %s" % e)
|
|
self.windows.pop(target.get("id"), None)
|
|
for ident in set(self.windows) - seen:
|
|
del self.windows[ident]
|
|
for ident, page in list(self.windows.items()):
|
|
try:
|
|
for event in page.drain():
|
|
if called(event, WINDOW_BINDING):
|
|
window_action(event.get("params", {}).get("payload"))
|
|
except (Closed, OSError, ValueError):
|
|
del self.windows[ident]
|
|
|
|
def sync_hdr(self):
|
|
try:
|
|
with open(os.path.join(CONTROLS_DIR, "state.json")) as source:
|
|
value = json.load(source).get("hdr")
|
|
if not isinstance(value, bool):
|
|
return
|
|
if not self.hdr_installed:
|
|
if time.monotonic() < self.hdr_retry:
|
|
return
|
|
self.page.call("Runtime.addBinding", {"name": HDR_BINDING})
|
|
self.hdr_installed = self.page.evaluate(HDR_JS) in ("installed", "present")
|
|
if not self.hdr_installed:
|
|
self.hdr_retry = time.monotonic() + 10
|
|
return
|
|
if value != self.hdr_state:
|
|
if self.page.evaluate("window.__droiddeckHdr ? window.__droiddeckHdr.set(%s) : false" % json.dumps(value)) is True:
|
|
self.hdr_state = value
|
|
else:
|
|
self.hdr_state = None
|
|
self.hdr_installed = False
|
|
except (OSError, ValueError, TypeError, AttributeError):
|
|
pass
|
|
|
|
def sync_frame_limit(self):
|
|
if self.frame_limit_state in ("installed", "present") or time.monotonic() < self.frame_limit_retry:
|
|
return
|
|
try:
|
|
state = self.page.evaluate(FRAME_LIMIT_JS)
|
|
except RuntimeError as e:
|
|
state = "failed (%s)" % e
|
|
if state != self.frame_limit_state:
|
|
say("frame limit sync: %s" % state)
|
|
self.frame_limit_state = state
|
|
self.frame_limit_retry = time.monotonic() + 10
|
|
|
|
def open_chooser(self, payload):
|
|
try:
|
|
request = json.loads(payload)
|
|
ident = int(request["id"])
|
|
options = request.get("options", {})
|
|
if not isinstance(options, dict):
|
|
raise ValueError("options are not an object")
|
|
except (ValueError, KeyError, TypeError) as e:
|
|
say("ignored a file dialog request (%s)" % e)
|
|
return
|
|
if self.chooser is not None:
|
|
self.finish_chooser(ident, None)
|
|
return
|
|
command = [sys.executable, os.path.realpath(__file__), "--choose-file"]
|
|
data = os.environ.get("XDG_DATA_HOME") or os.path.join(os.path.expanduser("~"), ".local", "share")
|
|
for root in (self.steam_root, os.path.join(data, "Steam")):
|
|
reaper = os.path.join(root, "steamrtarm64", "reaper")
|
|
if os.access(reaper, os.X_OK):
|
|
command = [reaper, "SteamLaunch", "AppId=769", "--"] + command
|
|
break
|
|
try:
|
|
proc = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL, start_new_session=True)
|
|
proc.stdin.write(json.dumps(options).encode("utf-8"))
|
|
proc.stdin.close()
|
|
except OSError as e:
|
|
say("could not open a file dialog (%s)" % e)
|
|
self.finish_chooser(ident, None)
|
|
return
|
|
say("file dialog open: %s" % (options.get("strTitle") or "untitled"))
|
|
self.chooser = (ident, proc)
|
|
|
|
def chooser_done(self):
|
|
ident, proc = self.chooser
|
|
self.chooser = None
|
|
out = proc.stdout.read().decode("utf-8", "replace")
|
|
proc.stdout.close()
|
|
proc.wait()
|
|
if proc.returncode == 2:
|
|
say("file dialog needs GTK 3 and PyGObject, which come with the desktop")
|
|
try:
|
|
path = json.loads(out) if proc.returncode == 0 else None
|
|
except ValueError:
|
|
path = None
|
|
self.finish_chooser(ident, path if isinstance(path, str) and path else None)
|
|
|
|
def finish_chooser(self, ident, path):
|
|
say("file dialog %s" % ("chose " + path if path else "cancelled"))
|
|
self.page.evaluate("window.__droiddeckFiles?.done(%d, %s)" % (ident, json.dumps(path)))
|
|
|
|
def close_chooser(self):
|
|
if self.chooser is not None:
|
|
_, proc = self.chooser
|
|
self.chooser = None
|
|
try:
|
|
os.killpg(proc.pid, signal.SIGTERM)
|
|
except OSError:
|
|
pass
|
|
proc.stdout.close()
|
|
proc.wait()
|
|
|
|
def attach(self):
|
|
path = shared_context(self.port)
|
|
if path is None:
|
|
raise LookupError("no SharedJSContext yet")
|
|
page = Page(self.port, path)
|
|
try:
|
|
if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True:
|
|
raise LookupError("SteamClient is not ready")
|
|
if self.files_only:
|
|
page.call("Runtime.addBinding", {"name": FILE_BINDING})
|
|
page.evaluate(FILE_JS)
|
|
page.evaluate(LIBRARY_ART_JS)
|
|
self.page = page
|
|
self.controls_state = None
|
|
self.controls_installed = False
|
|
self.sync_controls()
|
|
return True
|
|
page.call("Runtime.addBinding", {"name": BINDING})
|
|
page.call("Runtime.addBinding", {"name": VR_BINDING})
|
|
page.evaluate(VR_JS)
|
|
page.call("Runtime.addBinding", {"name": FILE_BINDING})
|
|
page.evaluate(FILE_JS)
|
|
page.evaluate(LIBRARY_ART_JS)
|
|
try:
|
|
page.evaluate(TOUR_JS)
|
|
except RuntimeError:
|
|
pass
|
|
if not self.steamos:
|
|
page.call("Runtime.addBinding", {"name": SWITCH_BINDING})
|
|
page.evaluate(SWITCH_JS)
|
|
page.compat("get(0)")
|
|
except Exception:
|
|
page.ws.close()
|
|
raise
|
|
self.page = page
|
|
self.controls_state = None
|
|
self.controls_installed = False
|
|
self.frame_limit_state = None
|
|
self.frame_limit_retry = 0
|
|
self.hdr_state = None
|
|
self.hdr_installed = False
|
|
self.hdr_retry = 0
|
|
self.sync_controls()
|
|
return True
|
|
|
|
def reconcile(self):
|
|
page = self.page
|
|
with COMPAT["locked"]():
|
|
state_file = COMPAT["state_path"]("state.json")
|
|
state = COMPAT["read_json"](state_file)
|
|
request = COMPAT["read_json"](COMPAT["state_path"]("request.json"))
|
|
catalog = COMPAT["tool_catalog"](self.steam_root)
|
|
top = page.compat("get(0)")
|
|
self.known = set(top["tools"])
|
|
live = [t for t in catalog if t["name"] in self.known]
|
|
wanted = COMPAT["requested_tool"](request, catalog)
|
|
newer = isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0)
|
|
waiting = newer and wanted is not None and wanted not in self.known
|
|
listed = [t["name"] for t in live]
|
|
default, state = COMPAT["choose_default"](COMPAT["built_from"](top["selected"], catalog, listed) or top["selected"],
|
|
state, request, catalog, apply_request=not waiting, listed=listed)
|
|
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 = {}
|
|
prior_native = state.get("native_choices", ())
|
|
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 | 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 {})
|
|
refused = set(apps) - set(current)
|
|
refused_native = native_choices & refused
|
|
if refused:
|
|
apps = [app for app in apps if app not in refused]
|
|
installed = [app for app in installed if app not in refused]
|
|
picks = [app for app in picks if app not in refused]
|
|
prior_auto = {app: tool for app, tool in prior_auto.items() if app not in refused}
|
|
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"](
|
|
os.path.join(self.steam_root, "config", "config.vdf"))
|
|
if raw_mapping is None:
|
|
for app in native_choices:
|
|
current[app] = ""
|
|
for app in set(native) - native_choices:
|
|
if not current.get(app) and app not in picked:
|
|
current.pop(app, None)
|
|
else:
|
|
for app in set(native) | native_choices:
|
|
if app in raw_mapping:
|
|
if raw_mapping[app] == "" or current.get(app) not in self.known:
|
|
current[app] = raw_mapping[app]
|
|
elif app in prior_auto or app in native_choices or app in picked and (
|
|
not current.get(app) or COMPAT["unrunnable"](current[app], runnable)):
|
|
current[app] = ""
|
|
elif not current.get(app):
|
|
current.pop(app, None)
|
|
moved = COMPAT["rebuilt_picks"](current, catalog, set(prior_auto) | picked, listed)
|
|
if moved:
|
|
following = COMPAT["followers"](state, current)
|
|
state["auto"] = {app: name for app, name in following.items() if app not in moved} if isinstance(following, dict) else {}
|
|
prior_auto = {app: name for app, name in prior_auto.items() if app not in moved}
|
|
current.update(moved)
|
|
requests = COMPAT["settled_game_requests"](state, current, catalog)
|
|
overrides = COMPAT["requested_games"](requests or {}, catalog, listed)
|
|
overrides = {app: tool for app, tool in overrides.items() if app not in refused}
|
|
changes, auto = COMPAT["plan_mapping"](
|
|
current, installed, listed, default,
|
|
COMPAT["followers"](state, current), native, picks, overrides,
|
|
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 "")))
|
|
say("%s -> %s" % ("default" if app == "0" else "app %s" % app,
|
|
tool if tool is not None else "Steam native default"))
|
|
state.update(
|
|
auto={app: tool for app, tool in auto.items() if tool is not COMPAT["NATIVE_CHOICE"]},
|
|
native_choices=sorted(refused_native | {app for app, tool in auto.items() if tool is COMPAT["NATIVE_CHOICE"]}),
|
|
picked=COMPAT["picked_after"](current, changes), tools=catalog, live=True, written=default,
|
|
games_applied=COMPAT["applied_game_requests"](requests, overrides, state))
|
|
state.pop("native", None)
|
|
if waiting:
|
|
state["pending"] = wanted
|
|
say("%s is new to the running client; it applies when Steam next starts" % wanted)
|
|
else:
|
|
state.pop("pending", None)
|
|
COMPAT["write_json"](state_file, state)
|
|
|
|
def ensure_tools(self):
|
|
now = time.monotonic()
|
|
if self.tools_checked is not None and now - self.tools_checked < TOOL_CHECK_SECONDS:
|
|
return
|
|
self.tools_checked = now
|
|
if COMPAT["game_running"]():
|
|
return
|
|
for app, action in COMPAT["tool_downloads"](self.steam_root):
|
|
if now - self.tools_asked.get(app, -TOOL_RETRY_SECONDS) < TOOL_RETRY_SECONDS:
|
|
continue
|
|
self.tools_asked[app] = now
|
|
try:
|
|
self.page.tools("%s(%d)" % (action, int(app)))
|
|
say("asked the client to %s %s" % (action, app))
|
|
except Exception as e:
|
|
say("the client could not %s %s (%s)" % (action, app, e))
|
|
if action == "install":
|
|
for asked in COMPAT["request_fex"](self.steam_root, self.fex_asked):
|
|
say("asked the client to install %s through steam://install" % asked)
|
|
|
|
def request_waiting(self):
|
|
request = COMPAT["read_json"](COMPAT["state_path"]("request.json"))
|
|
state = COMPAT["read_json"](COMPAT["state_path"]("state.json"))
|
|
return isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0)
|
|
|
|
def drain(self):
|
|
events = self.page.drain()
|
|
if any(called(e, SWITCH_BINDING) for e in events):
|
|
switch_to_desktop()
|
|
vr_games = {e.get("params", {}).get("payload") for e in events if called(e, VR_BINDING) and
|
|
isinstance(e.get("params", {}).get("payload"), str)}
|
|
vr_games = {game for game in vr_games if isinstance(game, str) and game.isascii() and
|
|
game.isdecimal() and not game.startswith("0") and len(game) <= 20 and
|
|
int(game) <= 0xffffffffffffffff}
|
|
if vr_games and (self.vr_launch is None or self.vr_launch.poll() is not None):
|
|
say("preparing SteamVR for library app(s): " + ", ".join(sorted(vr_games)))
|
|
self.vr_launch = launch_steamvr()
|
|
for e in events:
|
|
if called(e, BRIGHTNESS_BINDING):
|
|
brightness_request(e.get("params", {}).get("payload"))
|
|
if called(e, HDR_BINDING):
|
|
hdr_request(e.get("params", {}).get("payload"))
|
|
if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str):
|
|
self.open_chooser(e["params"]["payload"])
|
|
return events
|
|
|
|
def serve_files(self):
|
|
say("attached to the client on port %d for its file dialogs" % self.port)
|
|
while True:
|
|
self.sync_controls()
|
|
self.sync_windows()
|
|
sources = [self.page.ws] + ([self.chooser[1].stdout] if self.chooser is not None else [])
|
|
sources += [page.ws for page in self.windows.values()]
|
|
queued = self.page.ws.pending() or bool(self.page.events)
|
|
ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0]
|
|
if self.chooser is not None and self.chooser[1].stdout in ready:
|
|
self.chooser_done()
|
|
if self.page.ws in ready or self.page.events:
|
|
self.drain()
|
|
|
|
def serve(self, watcher):
|
|
if self.files_only:
|
|
return self.serve_files()
|
|
with open(COMPAT["state_path"]("live.pid"), "w") as f:
|
|
f.write("%d\n" % os.getpid())
|
|
say("attached to the client on port %d" % self.port)
|
|
self.reconcile()
|
|
self.ensure_tools()
|
|
while True:
|
|
self.sync_controls()
|
|
self.sync_frame_limit()
|
|
self.sync_hdr()
|
|
self.sync_windows()
|
|
sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else [])
|
|
sources += [page.ws for page in self.windows.values()]
|
|
if self.chooser is not None:
|
|
sources.append(self.chooser[1].stdout)
|
|
queued = self.page.ws.pending() or bool(self.page.events)
|
|
ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0]
|
|
if self.chooser is not None and self.chooser[1].stdout in ready:
|
|
self.chooser_done()
|
|
due = False
|
|
if self.page.ws in ready:
|
|
due = any(called(e, BINDING) for e in self.drain())
|
|
if (watcher in ready or watcher.fileno() < 0) and watcher.changed():
|
|
due = True
|
|
if due:
|
|
time.sleep(0.3)
|
|
if watcher.fileno() >= 0 and select.select([watcher], [], [], 0)[0]:
|
|
watcher.changed()
|
|
self.drain()
|
|
self.reconcile()
|
|
self.ensure_tools()
|
|
|
|
|
|
def detach():
|
|
try:
|
|
os.unlink(COMPAT["state_path"]("live.pid"))
|
|
except OSError:
|
|
pass
|
|
with COMPAT["locked"]():
|
|
state_file = COMPAT["state_path"]("state.json")
|
|
state = COMPAT["read_json"](state_file)
|
|
if state.get("live"):
|
|
state["live"] = False
|
|
COMPAT["write_json"](state_file, state)
|
|
|
|
|
|
def chooser_main():
|
|
try:
|
|
options = json.load(sys.stdin)
|
|
except ValueError:
|
|
return 1
|
|
try:
|
|
path = choose_file(options if isinstance(options, dict) else {})
|
|
except (ImportError, ValueError):
|
|
return 2
|
|
if not path:
|
|
return 1
|
|
print(json.dumps(path))
|
|
return 0
|
|
|
|
|
|
def main():
|
|
files_only = sys.argv[1:2] == ["--files-only"]
|
|
steam_root = sys.argv[2 if files_only else 1]
|
|
try:
|
|
port = int(os.environ.get("DD_CDP_PORT", ""))
|
|
except ValueError:
|
|
say("no devtools port for this session; the client's mapping is kept through config.vdf")
|
|
return 0
|
|
if files_only:
|
|
helper = Helper(steam_root, port, files_only=True)
|
|
failures = 0
|
|
while True:
|
|
try:
|
|
helper.attach()
|
|
failures = 0
|
|
helper.serve(None)
|
|
except Exception as e:
|
|
helper.close_chooser()
|
|
if helper.page is not None:
|
|
say("lost the client (%s); reattaching" % e)
|
|
helper.page.ws.close()
|
|
helper.page = None
|
|
failures += 1
|
|
time.sleep(min(2 * max(failures, 1), 10))
|
|
os.makedirs(COMPAT["COMPAT_DIR"], exist_ok=True)
|
|
watcher = Watcher([COMPAT["state_path"]("request.json"), COMPAT["state_path"]("games.json"),
|
|
os.path.join(steam_root, "appcache", "appinfo.vdf")] +
|
|
[os.path.join(lib, "steamapps", "libraryfolders.vdf") for lib in (steam_root, COMPAT["LIBRARY"] + "-sd")])
|
|
steamos = os.environ.get("DD_STEAMDECK") == "1" and os.environ.get("DD_STEAM_UI") != "desktop"
|
|
helper = Helper(steam_root, port, steamos)
|
|
failures = 0
|
|
last = None
|
|
while True:
|
|
try:
|
|
helper.attach()
|
|
failures = 0
|
|
last = None
|
|
helper.serve(watcher)
|
|
except Exception as e:
|
|
helper.close_chooser()
|
|
if helper.page is not None:
|
|
say("lost the client (%s); reattaching" % e)
|
|
helper.page.ws.close()
|
|
helper.page = None
|
|
detach()
|
|
elif str(e) != last:
|
|
say("waiting for the client (%s)" % e)
|
|
last = str(e)
|
|
failures += 1
|
|
time.sleep(min(2 * max(failures, 1), 10))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if sys.argv[1:2] == ["--choose-file"]:
|
|
sys.exit(chooser_main())
|
|
signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
|
|
try:
|
|
sys.exit(main())
|
|
finally:
|
|
if sys.argv[1:2] != ["--files-only"]:
|
|
detach()
|