WEFT_OS/tests/frame/check_activation.py
Marco Allegretti aa67e7f190
fix(compositor): own stacking and focus, and activate app windows on request
The system shell's panel was an ordinary toplevel at winit's default
size, stacked by map order with the applications, and clicking or the
taskbar could never bring an application back to the front.

The compositor now sizes the panel to the output and keeps it beneath
every application window. A newly mapped, clicked or activated
application window is raised, marked activated and given keyboard
focus. weft-appd accepts ACTIVATE_APP for a running session and asks
the compositor to activate that session's window (AppFocusRequest),
and the system UI's taskbar entries send it when chosen.

check_activation.py runs the system shell with a solid panel page and
two test applications: the panel fills the output beneath them, each
launch comes to the front with keyboard focus, ACTIVATE_APP switches
between the sessions with focus, and activating a session that is not
running is refused.
2026-10-09 15:36:55 +00:00

227 lines
9.2 KiB
Python
Executable file

#!/usr/bin/env python3
"""Check that the compositor stacks, focuses and activates windows.
The harness runs weft-servo-shell with a solid green page as the system
panel, and weft-appd with two test applications, one red and one blue, on a
nested desktop (see session.py). Each application page turns a lighter shade
of its colour when it receives a key press. In the presented pixels:
- the panel fills the compositor output and stays beneath the applications;
- each newly launched application is shown on top and receives keys;
- ACTIVATE_APP, the request the taskbar sends, brings the other session's
window back to the front with keyboard focus;
- ACTIVATE_APP for a session that is not running is refused.
The applications are unsigned test packages, recorded as development content
in a private data home, using the Counter demo's component.
"""
import argparse
import shutil
import subprocess
import sys
import tempfile
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from check_counter import AppdClient, free_port, read_endpoint # noqa: E402
from session import ROOT, Desktop, SessionError, bounding_box, missing_tools, parse_ppm # noqa: E402
GREEN = (0, 160, 0)
APPS = {
"org.weft.test.red": ((200, 0, 0), (255, 120, 120)),
"org.weft.test.blue": ((0, 0, 200), (120, 120, 255)),
}
STARTUP_TIMEOUT = 120.0
PANEL_PAGE = ('<!DOCTYPE html><html><body style="margin:0;background:rgb(0,160,0);'
'width:100vw;height:100vh"></body></html>')
def app_page(color, pressed):
return ('<!DOCTYPE html><html><body style="margin:0;width:100vw;height:100vh;'
f'background:rgb{color}"><script>'
'addEventListener("keydown", function () {'
f'document.body.style.background = "rgb{pressed}"; }});'
'</script></body></html>')
def make_store(store, home):
for app_id, (color, pressed) in APPS.items():
package = store / app_id
(package / "ui").mkdir(parents=True)
(package / "wapp.toml").write_text(
f'[package]\nid = "{app_id}"\nname = "Test"\nversion = "0.1.0"\n'
'[runtime]\nmodule = "app.wasm"\n[ui]\nentry = "ui/index.html"\n')
shutil.copy(ROOT / "examples/org.weft.demo.counter/app.wasm", package / "app.wasm")
(package / "ui/index.html").write_text(app_page(color, pressed))
record = home / "share/weft/owners" / app_id
record.parent.mkdir(parents=True, exist_ok=True)
record.write_text("development\n")
def area(screenshot, color):
width, height, pixels = parse_ppm(screenshot)
box = bounding_box(width, height, pixels, color)
return box, width, height
def wait_for_color(desktop, color, timeout=20):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
shot = desktop.capture()
box, _, _ = area(shot, color)
if box is not None:
return shot, box
time.sleep(0.3)
return desktop.capture(), None
def wait_until_gone(desktop, color, timeout=10):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
box, _, _ = area(desktop.capture(), color)
if box is None:
return True
time.sleep(0.3)
return False
def run(args, desktop, store, home):
panel_page = desktop.runtime / "panel.html"
panel_page.write_text(PANEL_PAGE)
desktop.launch_client("shell", [args.shell], {"WEFT_SYSTEM_UI_HTML": str(panel_page)})
shot, panel = wait_for_color(desktop, GREEN, 60)
if panel is None:
raise AssertionError("the panel was not shown")
width, height, _ = parse_ppm(shot)
# The compositor sizes the panel to its whole output, which reaches the
# right and bottom edges of the nested desktop.
if panel[2] != width - 1 or panel[3] < height - 3:
raise AssertionError(f"the panel does not fill the output: {panel}")
t = Path(args.target)
desktop.launch_client("appd", [t / "weft-appd"], {
"WEFT_RUNTIME_BIN": str(t / "weft-runtime"),
"WEFT_APP_SHELL_BIN": str(t / "weft-app-shell"),
"WEFT_APP_STORE": str(store),
"WEFT_DISABLE_CGROUP": "1",
"WEFT_APPD_WS_PORT": str(free_port()),
"HOME": str(home),
"XDG_DATA_HOME": str(home / "share"),
})
port, token = read_endpoint(desktop.runtime, 30)
appd = AppdClient(port, token)
def key(name):
subprocess.run([args.xdotool, "search", "--class", "weft-compositor",
"windowfocus", "--sync"], env={"DISPLAY": desktop.display},
check=True, timeout=20)
subprocess.run([args.xdotool, "key", name], env={"DISPLAY": desktop.display},
check=True, timeout=20)
def shown(app_id, pressed=False):
"""Waits until `app_id` is the visible application, alone on top."""
color = APPS[app_id][1 if pressed else 0]
others = [c for other, cs in APPS.items() for c in cs if other != app_id]
deadline = time.monotonic() + 20
while time.monotonic() < deadline:
shot = desktop.capture()
box, _, _ = area(shot, color)
hidden = all(area(shot, c)[0] is None for c in others)
if box is not None and hidden:
# The panel stays visible beside the application window.
if area(shot, GREEN)[0] is None:
raise AssertionError("an application covered the panel")
return
time.sleep(0.3)
state = "pressed " if pressed else ""
raise AssertionError(f"{app_id} is not shown {state}on top")
sessions = {}
for app_id in APPS:
appd.send({"type": "LAUNCH_APP", "app_id": app_id, "surface_id": 0})
try:
ready = appd.wait_for(
lambda m, a=app_id: m.get("type") == "APP_READY" and m.get("app_id") == a,
STARTUP_TIMEOUT)
except TimeoutError:
raise AssertionError(f"{app_id} did not start")
sessions[app_id] = ready["session_id"]
# A newly launched application comes to the front.
shown(app_id)
red, blue = "org.weft.test.red", "org.weft.test.blue"
# The last launched application has keyboard focus.
key("a")
shown(blue, pressed=True)
def activate(app_id):
appd.send({"type": "ACTIVATE_APP", "session_id": sessions[app_id]})
reply = appd.wait_for(lambda m: m.get("type") in ("APP_STATE", "ERROR")
and m.get("session_id", sessions[app_id]) == sessions[app_id],
10)
if reply.get("type") != "APP_STATE":
raise AssertionError(f"activating {app_id} was refused: {reply}")
# Activation brings the other session back with keyboard focus.
activate(red)
shown(red)
key("a")
shown(red, pressed=True)
activate(blue)
shown(blue, pressed=True)
appd.send({"type": "ACTIVATE_APP", "session_id": 999})
reply = appd.wait_for(lambda m: m.get("type") == "ERROR", 10)
if reply.get("code") != 404:
raise AssertionError(f"activating a session that does not run: {reply}")
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--compositor", type=Path, default=ROOT / "target/debug/weft-compositor")
parser.add_argument("--shell", type=Path, default=ROOT / "target/debug/weft-servo-shell")
parser.add_argument("--target", type=Path, default=ROOT / "target/debug",
help="directory with weft-appd, weft-runtime and weft-app-shell")
parser.add_argument("--output", type=Path, default=ROOT / "target/activation-check")
parser.add_argument("--xdotool", default=shutil.which("xdotool"))
args = parser.parse_args(argv)
if not args.xdotool:
print("missing: xdotool", file=sys.stderr)
return 2
missing = missing_tools() + [str(p) for p in (args.compositor, args.shell,
args.target / "weft-appd",
args.target / "weft-runtime",
args.target / "weft-app-shell")
if not p.is_file()]
if missing:
print("missing: " + ", ".join(missing), file=sys.stderr)
return 2
store = Path(tempfile.mkdtemp(prefix="weft-store-"))
home = Path(tempfile.mkdtemp(prefix="weft-home-"))
try:
make_store(store, home)
with Desktop(args.compositor, args.output, outputs=["appd.log", "activation.ppm"]) \
as desktop:
try:
run(args, desktop, store, home)
except AssertionError:
(args.output / "activation.ppm").write_bytes(desktop.capture())
raise
except (AssertionError, SessionError, TimeoutError) as failure:
print(f"activation check failed: {failure}", file=sys.stderr)
print(f"logs and capture in {args.output}", file=sys.stderr)
return 1
finally:
shutil.rmtree(store, ignore_errors=True)
shutil.rmtree(home, ignore_errors=True)
print("activation check passed")
return 0
if __name__ == "__main__":
sys.exit(main())