From 590f0f62c881935502d2fe5b85ed26979a518be6 Mon Sep 17 00:00:00 2001 From: Christopher Warner Date: Wed, 14 Oct 2026 14:18:02 -0400 Subject: feat: allow screensaver in clamshell with external display When the lid is closed but a non-eDP monitor is active (docked T480), keep idle playback running instead of treating a closed lid as a hard stop. Co-authored-by: Cursor --- README.md | 2 ++ aerial_screensaver.py | 81 ++++++++++++++++++++++++++++++++++++++++++--------- install.sh | 1 + test_screensaver.py | 47 ++++++++++++++++++++++++++++++ 4 files changed, 118 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index bc9c105..c3064d9 100644 --- a/README.md +++ b/README.md @@ -91,6 +91,8 @@ VAAPI_DEVICE=/dev/dri/renderD128 On hybrid GPUs, leave `VAAPI_DEVICE` on the **iGPU** (Intel on T480, AMD display-class on Framework). `install.sh` auto-detects. +**Clamshell / lid closed:** with `ALLOW_CLAMSHELL=1` (default), the screensaver still runs when the lid is closed **if an external display is active** (typical docked T480). Lid closed with no external display still skips/stops playback. + ## Sharing (LocalSend) Send **two** files: diff --git a/aerial_screensaver.py b/aerial_screensaver.py index 12727c9..7b64cac 100755 --- a/aerial_screensaver.py +++ b/aerial_screensaver.py @@ -21,6 +21,8 @@ LID_STATE_CANDIDATES = ( "/proc/acpi/button/lid/LID0/state", "/proc/acpi/button/lid/LID/state", ) +# Built-in panel connectors (clamshell = lid closed + non-builtin still active). +BUILTIN_CONNECTOR_PREFIXES = ("eDP", "LVDS", "DSI") IPC_SOCKET_PREFIX = "/tmp/mpv_aerial_" LOG_PATH = Path.home() / "aerial_debug.log" @@ -35,13 +37,23 @@ def _load_config() -> dict[str, str]: key, value = line.split("=", 1) cfg[key.strip()] = value.strip().strip('"').strip("'") # Environment overrides config - for key in ("VIDEO_DIR", "IDLE_TIMEOUT_SECONDS", "VAAPI_DEVICE", "REQUIRE_AC"): + for key in ( + "VIDEO_DIR", + "IDLE_TIMEOUT_SECONDS", + "VAAPI_DEVICE", + "REQUIRE_AC", + "ALLOW_CLAMSHELL", + ): env = os.environ.get(f"AERIAL_{key}") if env: cfg[key] = env return cfg +def _connector_is_builtin(connector: str) -> bool: + return connector.startswith(BUILTIN_CONNECTOR_PREFIXES) + + def _pci_attrs_for_render(render: Path) -> tuple[str, str]: """Return (pci_class, vendor) hex strings for a render node.""" try: @@ -107,6 +119,12 @@ class AerialScreensaver: self.video_dir = Path(cfg.get("VIDEO_DIR", str(DEFAULT_VIDEO_DIR))).expanduser() self.idle_timeout_seconds = int(cfg.get("IDLE_TIMEOUT_SECONDS", DEFAULT_IDLE_SECONDS)) self.require_ac = cfg.get("REQUIRE_AC", "1").lower() not in ("0", "false", "no") + # Lid closed + external display (docked / clamshell) is allowed by default. + self.allow_clamshell = cfg.get("ALLOW_CLAMSHELL", "1").lower() not in ( + "0", + "false", + "no", + ) self.vaapi_device = find_vaapi_device(cfg.get("VAAPI_DEVICE") or None) self.processes: list[subprocess.Popen] = [] self.idle_monitor = None @@ -118,8 +136,9 @@ class AerialScreensaver: logging.info( "Initializing Aerial Screensaver " - "(mpv lite, AC=%s, lid-aware, multi-screen, vaapi=%s)...", + "(mpv lite, AC=%s, clamshell=%s, multi-screen, vaapi=%s)...", self.require_ac, + self.allow_clamshell, self.vaapi_device or "auto", ) self._connect_idle_monitor() @@ -186,8 +205,8 @@ class AerialScreensaver: logging.error("Error checking lid status: %s", e) return True - def get_screen_count(self) -> int: - """Return active GNOME logical monitor count (fallback: 1).""" + def _display_state(self) -> tuple[int, bool]: + """Return (logical_monitor_count, has_external_display).""" try: proxy = Gio.DBusProxy.new_for_bus_sync( Gio.BusType.SESSION, @@ -206,10 +225,37 @@ class AerialScreensaver: None, ) _serial, _monitors, logical_monitors, _props = reply.unpack() - return max(1, len(logical_monitors)) + has_external = False + for lm in logical_monitors: + # (x, y, scale, transform, primary, monitors, properties) + for mon in lm[5]: + connector = mon[0] + if not _connector_is_builtin(connector): + has_external = True + break + if has_external: + break + return len(logical_monitors), has_external except Exception as e: - logging.error("Error detecting screens, defaulting to 1: %s", e) - return 1 + logging.error("Error detecting displays: %s", e) + return 0, False + + def get_screen_count(self) -> int: + """Return active GNOME logical monitor count (fallback: 1).""" + count, _external = self._display_state() + return max(1, count) if count > 0 else 1 + + def has_external_display(self) -> bool: + _count, external = self._display_state() + return external + + def display_ok(self) -> bool: + """Lid open, or clamshell (lid closed + external display) when allowed.""" + if self.is_lid_open(): + return True + if self.allow_clamshell and self.has_external_display(): + return True + return False def on_dbus_signal(self, proxy, sender_name, signal_name, parameters) -> None: if signal_name != "WatchFired": @@ -217,14 +263,21 @@ class AerialScreensaver: watch_id = parameters.unpack()[0] if watch_id != self.watch_id: return - if self.is_on_ac() and self.is_lid_open(): - logging.info("Idle threshold reached, on AC and lid is OPEN. Starting mpv.") + on_ac = self.is_on_ac() + display_ok = self.display_ok() + if on_ac and display_ok: + lid = "open" if self.is_lid_open() else "closed (clamshell/external)" + logging.info( + "Idle threshold reached, on AC, display ok (lid %s). Starting mpv.", + lid, + ) self.start_screensaver() else: logging.info( - "Idle threshold reached but skip (AC: %s, Lid Open: %s)", - self.is_on_ac(), + "Idle threshold reached but skip (AC: %s, Lid Open: %s, External: %s)", + on_ac, self.is_lid_open(), + self.has_external_display(), ) def _collect_videos(self) -> list[str]: @@ -327,8 +380,10 @@ class AerialScreensaver: while self._any_running(): time.sleep(1) try: - if not self.is_lid_open(): - logging.info("Lid closed during playback. Stopping mpv.") + if not self.display_ok(): + logging.info( + "No usable display (lid closed without external). Stopping mpv." + ) self.stop_screensaver() break reply = self.idle_monitor.call_sync( diff --git a/install.sh b/install.sh index 35f4fa4..75ab4bf 100755 --- a/install.sh +++ b/install.sh @@ -101,6 +101,7 @@ if [[ ! -f "$CFG_DIR/config" ]]; then VIDEO_DIR=$VIDEO_DIR IDLE_TIMEOUT_SECONDS=300 REQUIRE_AC=1 +ALLOW_CLAMSHELL=1 VAAPI_DEVICE=${VAAPI:-} EOF chmod 644 "$CFG_DIR/config" diff --git a/test_screensaver.py b/test_screensaver.py index 57b0d5a..bd58ac4 100644 --- a/test_screensaver.py +++ b/test_screensaver.py @@ -87,6 +87,53 @@ class TestAerialScreensaver(unittest.TestCase): app.require_ac = False self.assertTrue(app.is_on_ac()) + def test_connector_is_builtin(self): + self.assertTrue(aerial_screensaver._connector_is_builtin("eDP-1")) + self.assertTrue(aerial_screensaver._connector_is_builtin("eDP-2")) + self.assertTrue(aerial_screensaver._connector_is_builtin("LVDS-1")) + self.assertFalse(aerial_screensaver._connector_is_builtin("DP-1")) + self.assertFalse(aerial_screensaver._connector_is_builtin("HDMI-1")) + + def test_display_ok_lid_open(self): + app = aerial_screensaver.AerialScreensaver.__new__(aerial_screensaver.AerialScreensaver) + app.allow_clamshell = True + with patch.object(app, "is_lid_open", return_value=True): + self.assertTrue(app.display_ok()) + + def test_display_ok_clamshell_with_external(self): + app = aerial_screensaver.AerialScreensaver.__new__(aerial_screensaver.AerialScreensaver) + app.allow_clamshell = True + with patch.object(app, "is_lid_open", return_value=False): + with patch.object(app, "has_external_display", return_value=True): + self.assertTrue(app.display_ok()) + + def test_display_ok_lid_closed_no_external(self): + app = aerial_screensaver.AerialScreensaver.__new__(aerial_screensaver.AerialScreensaver) + app.allow_clamshell = True + with patch.object(app, "is_lid_open", return_value=False): + with patch.object(app, "has_external_display", return_value=False): + self.assertFalse(app.display_ok()) + + def test_display_ok_clamshell_disabled(self): + app = aerial_screensaver.AerialScreensaver.__new__(aerial_screensaver.AerialScreensaver) + app.allow_clamshell = False + with patch.object(app, "is_lid_open", return_value=False): + with patch.object(app, "has_external_display", return_value=True): + self.assertFalse(app.display_ok()) + + def test_has_external_display_from_logical_monitors(self): + app = aerial_screensaver.AerialScreensaver.__new__(aerial_screensaver.AerialScreensaver) + logical = [ + (0, 0, 1.0, 0, True, [("DP-1", "BNQ", "RD320", "1")], {}), + ] + mock_proxy = MagicMock() + mock_reply = MagicMock() + mock_reply.unpack.return_value = (0, [], logical, {}) + mock_proxy.call_sync.return_value = mock_reply + with patch("aerial_screensaver.Gio.DBusProxy.new_for_bus_sync", return_value=mock_proxy): + self.assertTrue(app.has_external_display()) + self.assertEqual(app.get_screen_count(), 1) + if __name__ == "__main__": unittest.main() -- cgit v1.2.3