Merge pull request slgobinath#720 from deltragon/smartpause-rework

smartpause: refactor into multiple classes

Author: deltragon

safeeyes/plugins/smartpause/dependency_checker.py

@@ -22,9 +22,7 @@
 
 def validate(plugin_config, plugin_settings):
     command = None
-    if utility.DESKTOP_ENVIRONMENT == "gnome" and utility.IS_WAYLAND:
-        command = "dbus-send"
-    elif utility.DESKTOP_ENVIRONMENT == "sway":
+    if utility.DESKTOP_ENVIRONMENT == "sway":
         command = "swayidle"
     elif utility.IS_WAYLAND:
         if not utility.module_exist("pywayland"):

safeeyes/plugins/smartpause/ext_idle_notify.py

@@ -18,29 +18,100 @@
 
 # This file is heavily inspired by https://github.com/juienpro/easyland/blob/efc26a0b22d7bdbb0f8436183428f7036da4662a/src/easyland/idle.py
 
+from dataclasses import dataclass
+import logging
 import threading
-import datetime
 import os
 import select
+import typing
 
 from pywayland.client import Display
 from pywayland.protocol.wayland.wl_seat import WlSeat
-from pywayland.protocol.ext_idle_notify_v1 import ExtIdleNotifierV1
+from pywayland.protocol.ext_idle_notify_v1 import (
+    ExtIdleNotifierV1,
+    ExtIdleNotificationV1,
+)
 
+from .interface import IdleMonitorInterface
+from safeeyes import utility
 
-class ExtIdleNotify:
-    _idle_notifier = None
-    _seat = None
-    _notification = None
-    _notifier_set = False
-    _running = True
-    _thread = None
-    _r_channel = None
-    _w_channel = None
 
-    _idle_since = None
+@dataclass
+class IdleConfig:
+    on_idle: typing.Callable[[], None]
+    on_resumed: typing.Callable[[], None]
+    idle_time: float
 
-    def __init__(self):
+
+class IdleMonitorExtIdleNotify(IdleMonitorInterface):
+    _ext_idle_notify_internal: typing.Optional["ExtIdleNotifyInternal"] = None
+    _thread: typing.Optional[threading.Thread] = None
+
+    _r_channel_started: int
+    _w_channel_started: int
+
+    _r_channel_stop: int
+    _w_channel_stop: int
+
+    _r_channel_listen: int
+    _w_channel_listen: int
+
+    _idle_config: typing.Optional[IdleConfig] = None
+
+    def init(self) -> None:
+        # we spawn one wayland client once
+        # when the monitor is not running, it should be quite idle
+        self._r_channel_started, self._w_channel_started = os.pipe()
+        self._r_channel_stop, self._w_channel_stop = os.pipe()
+        self._r_channel_listen, self._w_channel_listen = os.pipe()
+        os.set_blocking(self._r_channel_listen, False)
+
+        self._thread = threading.Thread(
+            target=self._run, name="ExtIdleNotify", daemon=False
+        )
+        self._thread.start()
+
+        result = os.read(self._r_channel_started, 1)
+
+        if result == b"0":
+            self._thread.join()
+            self._thread = None
+            raise Exception("ext-idle-notify-v1 not supported")
+
+    def start_monitor(
+        self,
+        on_idle: typing.Callable[[], None],
+        on_resumed: typing.Callable[[], None],
+        idle_time: float,
+    ) -> None:
+        self._idle_config = IdleConfig(
+            on_idle=on_idle,
+            on_resumed=on_resumed,
+            idle_time=idle_time,
+        )
+
+        # 1 means start listening, or that the configuration changed
+        os.write(self._w_channel_listen, b"1")
+
+    def configuration_changed(
+        self,
+        on_idle: typing.Callable[[], None],
+        on_resumed: typing.Callable[[], None],
+        idle_time: float,
+    ) -> None:
+        self._idle_config = IdleConfig(
+            on_idle=on_idle,
+            on_resumed=on_resumed,
+            idle_time=idle_time,
+        )
+
+        # 1 means start listening, or that the configuration changed
+        os.write(self._w_channel_listen, b"1")
+
+    def is_monitor_running(self) -> bool:
+        return self._idle_config is not None
+
+    def _run(self) -> None:
         # Note that this creates a new connection to the wayland compositor.
         # This is not an issue per se, but does mean that the compositor sees this as
         # a new, separate client, that just happens to run in the same process as
@@ -54,80 +125,196 @@ def __init__(self):
         # https://lists.freedesktop.org/archives/wayland-devel/2019-March/040344.html
         # The best thing would be, of course, for gtk to gain native support for
         # ext-idle-notify-v1.
-        self._display = Display()
-        self._display.connect()
-        self._r_channel, self._w_channel = os.pipe()
+        with Display() as display:
+            self._ext_idle_notify_internal = ExtIdleNotifyInternal(
+                display,
+                self._r_channel_stop,
+                self._w_channel_started,
+                self._r_channel_listen,
+                self._on_idle,
+                self._on_resumed,
+                self._get_idle_time,
+            )
+            self._ext_idle_notify_internal.run()
+            self._ext_idle_notify_internal = None
+
+    def _on_idle(self) -> None:
+        if self._idle_config is not None:
+            self._idle_config.on_idle()
+
+    def _on_resumed(self) -> None:
+        if self._idle_config is not None:
+            self._idle_config.on_resumed()
 
-    def stop(self):
-        self._running = False
+    def _get_idle_time(self) -> typing.Optional[float]:
+        if self._idle_config is not None:
+            return self._idle_config.idle_time
+        else:
+            return None
+
+    def stop_monitor(self) -> None:
+        # 0 means to stop listening
+        # It's not an issue to write to the channel if we're not listening anymore
+        # already
+        os.write(self._w_channel_listen, b"0")
+
+        self._idle_config = None
+
+    def stop(self) -> None:
         # write anything, just to wake up the channel
-        os.write(self._w_channel, b"!")
-        self._notification.destroy()
-        self._notification = None
-        self._seat = None
-        self._thread.join()
-        os.close(self._r_channel)
-        os.close(self._w_channel)
+        if self._thread is not None:
+            os.write(self._w_channel_stop, b"!")
+            self._thread.join()
+            self._thread = None
+            os.close(self._r_channel_stop)
+            os.close(self._w_channel_stop)
 
-    def run(self):
-        self._thread = threading.Thread(
-            target=self._run, name="ExtIdleNotify", daemon=False
-        )
-        self._thread.start()
+            os.close(self._r_channel_started)
+            os.close(self._w_channel_started)
 
-    def _run(self):
+            os.close(self._r_channel_listen)
+            os.close(self._w_channel_listen)
+
+
+class ExtIdleNotifyInternal:
+    """This runs in the thread, and is only alive while the display exists.
+
+    Split out into a separate object to simplify lifetime handling.
+    """
+
+    _idle_notifier: typing.Optional[ExtIdleNotifierV1] = None
+    _notification: typing.Optional[ExtIdleNotificationV1] = None
+    _display: Display
+    _r_channel_stop: int
+    _w_channel_started: int
+    _r_channel_listen: int
+    _seat: typing.Optional[WlSeat] = None
+
+    _on_idle: typing.Callable[[], None]
+    _on_resumed: typing.Callable[[], None]
+    _get_idle_time: typing.Callable[[], typing.Optional[float]]
+
+    def __init__(
+        self,
+        display: Display,
+        r_channel_stop: int,
+        w_channel_started: int,
+        r_channel_listen: int,
+        on_idle: typing.Callable[[], None],
+        on_resumed: typing.Callable[[], None],
+        get_idle_time: typing.Callable[[], typing.Optional[float]],
+    ) -> None:
+        self._display = display
+        self._r_channel_stop = r_channel_stop
+        self._w_channel_started = w_channel_started
+        self._r_channel_listen = r_channel_listen
+        self._on_idle = on_idle
+        self._on_resumed = on_resumed
+        self._get_idle_time = get_idle_time
+
+    def run(self) -> None:
+        """Run the wayland client.
+
+        This will block until it's stopped by the channel.
+        When this stops, self should no longer be used.
+        """
         reg = self._display.get_registry()
         reg.dispatcher["global"] = self._global_handler
 
+        self._display.roundtrip()
+
+        while self._seat is None:
+            self._display.dispatch(block=True)
+
+        if self._idle_notifier is None:
+            self._seat = None
+
+            self._display.roundtrip()
+
+            # communicate to the outer thread that the compositor does not
+            # implement the ext-idle-notify-v1 protocol
+            os.write(self._w_channel_started, b"0")
+
+            return
+
+        os.write(self._w_channel_started, b"1")
+
         display_fd = self._display.get_fd()
 
-        while self._running:
+        while True:
             self._display.flush()
 
             # this blocks until either there are new events in self._display
             # (retrieved using dispatch())
-            # or until there are events in self._r_channel - which means that stop()
-            # was called
+            # or until there are events in self._r_channel_stop - which means that
+            # stop() was called
             # unfortunately, this seems like the best way to make sure that dispatch
             # doesn't block potentially forever (up to multiple seconds in my usage)
-            read, _w, _x = select.select((display_fd, self._r_channel), (), ())
+            read, _w, _x = select.select(
+                (display_fd, self._r_channel_stop, self._r_channel_listen), (), ()
+            )
 
-            if self._r_channel in read:
+            if self._r_channel_listen in read:
+                # r_channel_listen is nonblocking
+                # if there is nothing to read here, result should just be b""
+                result = os.read(self._r_channel_listen, 1)
+                if result == b"1":
+                    self._listen()
+                elif result == b"0":
+                    if self._notification is not None:
+                        self._notification.destroy()  # type: ignore[attr-defined]
+                        self._notification = None
+
+            if self._r_channel_stop in read:
                 # the channel was written to, which means stop() was called
-                # at this point, self._running should be false as well
                 break
 
             if display_fd in read:
                 self._display.dispatch(block=True)
 
-        self._display.disconnect()
+        self._display.roundtrip()
+
+        if self._notification is not None:
+            self._notification.destroy()  # type: ignore[attr-defined]
+            self._notification = None
+
+        self._display.roundtrip()
+
+        self._seat = None
+        self._idle_notifier = None
+
+    def _listen(self):
+        """Create a new idle notification listener.
 
-    def _global_handler(self, reg, id_num, iface_name, version):
+        If one already exists, throw it away and recreate it with the new
+        idle time.
+        """
+        # note that the typing doesn't work correctly here - it always says that
+        # get_idle_notification is not defined
+        # so just don't check this method
+        if self._notification is not None:
+            self._notification.destroy()
+            self._notification = None
+
+        timeout_sec = self._get_idle_time()
+        if timeout_sec is None:
+            logging.debug(
+                "this should not happen. _listen() was called but idle time was not set"
+            )
+        self._notification = self._idle_notifier.get_idle_notification(
+            int(timeout_sec * 1000), self._seat
+        )
+        self._notification.dispatcher["idled"] = self._idle_notifier_handler
+        self._notification.dispatcher["resumed"] = self._idle_notifier_resume_handler
+
+    def _global_handler(self, reg, id_num, iface_name, version) -> None:
         if iface_name == "wl_seat":
             self._seat = reg.bind(id_num, WlSeat, version)
         if iface_name == "ext_idle_notifier_v1":
             self._idle_notifier = reg.bind(id_num, ExtIdleNotifierV1, version)
 
-        if self._idle_notifier and self._seat and not self._notifier_set:
-            self._notifier_set = True
-            timeout_sec = 1
-            self._notification = self._idle_notifier.get_idle_notification(
-                timeout_sec * 1000, self._seat
-            )
-            self._notification.dispatcher["idled"] = self._idle_notifier_handler
-            self._notification.dispatcher["resumed"] = (
-                self._idle_notifier_resume_handler
-            )
-
-    def _idle_notifier_handler(self, notification):
-        self._idle_since = datetime.datetime.now()
-
-    def _idle_notifier_resume_handler(self, notification):
-        self._idle_since = None
-
-    def get_idle_time_seconds(self):
-        if self._idle_since is None:
-            return 0
+    def _idle_notifier_handler(self, notification) -> None:
+        utility.execute_main_thread(self._on_idle)
 
-        result = datetime.datetime.now() - self._idle_since
-        return result.total_seconds()
+    def _idle_notifier_resume_handler(self, notification) -> None:
+        utility.execute_main_thread(self._on_resumed)