tinyjukebox 0.47.0__py3-none-any.whl

tinyjukebox/devices/drivermanager/drivermanager.py

@@ -0,0 +1,151 @@
+"""DriverManager - runs several drivers in one process."""
+
+import functools
+import logging
+from collections.abc import Callable, Mapping
+from typing import Any, ClassVar
+
+import tinyjukebox
+from tinyjukebox.core.microservice import AbstractMicroservice
+from tinyjukebox.core.pubsub import PubSubClient
+from tinyjukebox.core.ui import Command
+from tinyjukebox.core.ui.tools import get_yes_no, more, parse
+from tinyjukebox.devices.baseclasses.adriver import ADriver
+from tinyjukebox.devices.drivermanager.driverfactory import DriverFactory
+from tinyjukebox.devices.schema.drivermanager import get_schema
+
+__all__ = ["DriverManager"]
+
+
+class DriverManager(AbstractMicroservice):
+    """Creates all active drivers of the config section ``drivers`` and starts/stops them together.
+
+    * All drivers share the pubsub client and the logger of the manager.
+    * The command line offers ``list_drivers``, ``start_driver``, ``stop_driver``, ``restart_driver``, ``reload_driver``
+      and the driver specific commands with the driver id as prefix (e.g. ``rfid_gpio_state``).
+    """
+
+    _version: ClassVar[str] = tinyjukebox.__version__
+
+    def __init__(
+        self,
+        config: Mapping[str, Any],
+        pubsub_client: PubSubClient,
+        logger: logging.Logger,
+    ) -> None:
+        """The command line of the manager is offered by the owner (see :attr:`ui_commands`)."""
+        super().__init__(config, "drivers", pubsub_client, logger, logger_name=type(self).__name__, no_gui=True)
+        self._driver_factory = DriverFactory(self._pubsub_client, self._logger)
+        self._drivers = self._driver_factory.create_drivers(config)
+
+        for driver_id, driver in self._drivers.items():
+            for name, command in driver.driver_ui_commands.items():
+                self._add_ui_command(f"{driver_id}_{name}", self._driver_command(driver_id, name, command))
+        self._add_ui_command("list_drivers", self._cmd_list_drivers)
+        self._add_ui_command("reload_driver", self._cmd_reload_driver)
+        self._add_ui_command("stop_driver", self._cmd_stop_driver)
+        self._add_ui_command("start_driver", self._cmd_start_driver)
+        self._add_ui_command("restart_driver", self._cmd_restart_driver)
+
+    @property
+    def drivers(self) -> dict[str, ADriver]:
+        """``{driver id: driver}`` of all active drivers."""
+        return self._drivers
+
+    def states(self) -> list[dict[str, Any]]:
+        """The :meth:`~tinyjukebox.devices.baseclasses.adriver.ADriver.state` of every driver with its ``id``."""
+        return [{"id": driver_id, **driver.state()} for driver_id, driver in self._drivers.items()]
+
+    # --- life cycle ---------------------------------------------------------------------------------------------
+
+    def _start(self) -> None:
+        for driver in self._drivers.values():
+            driver.start()
+        self._logger.warning("DriverManager started")
+
+    def _stop(self) -> None:
+        # also after a failed start: only the started drivers, and a failing driver does not keep the others running
+        for driver in reversed(self._drivers.values()):
+            if driver.is_stopped:
+                continue
+            try:
+                driver.stop()
+            except Exception:
+                self._logger.exception("DriverManager - stopping %s failed", driver.get_short_info())
+        self._logger.warning("DriverManager stopped")
+
+    def restart_driver(self, driver_id: str) -> None:
+        driver = self._drivers[driver_id]
+        driver.stop()
+        driver.start()
+
+    def reload_driver(self, driver_id: str) -> None:
+        """Replace the driver with a new instance (e.g. after the hardware has been reconnected)."""
+        self._driver_factory.reload_driver(self._drivers, driver_id)
+
+    # --- console ------------------------------------------------------------------------------------------------
+
+    def _driver_command(self, driver_id: str, name: str, command: Command) -> Command:
+        """``command`` of the driver ``driver_id`` - of the instance that is current when it is called:
+        :meth:`reload_driver` replaces the instance, the command line keeps its commands."""
+
+        @functools.wraps(command)  # the docstring is the help text
+        def current(args: str) -> object:
+            return self._drivers[driver_id].driver_ui_commands[name](args)
+
+        return current
+
+    def _get_id_from_arg(self, arg: str) -> str | None:
+        args = parse(arg)
+        if len(args) != 1:
+            print("missing mandatory parameter id (see 'list_drivers').")
+            return None
+        if args[0] not in self._drivers:
+            print(f"unknown id '{args[0]}'")
+            return None
+        return args[0]
+
+    def _confirmed_driver_action(
+        self, arg: str, verb: str, must_run: bool | None, action: Callable[[str], None]
+    ) -> None:
+        """Ask for confirmation and call ``action(driver_id)``; ``must_run``: required state (None = any)."""
+        driver_id = self._get_id_from_arg(arg)
+        if driver_id is None:
+            return
+        driver = self._drivers[driver_id]
+        if must_run is not None and driver.is_stopped == must_run:
+            print(f"[{driver_id}] is {'not' if must_run else 'already'} running")
+            return
+        print(f"{verb} [{driver_id}]: {driver.get_short_info()}")
+        if get_yes_no() == "y":
+            action(driver_id)
+
+    def _cmd_stop_driver(self, arg: str) -> None:
+        """stop_driver id - stops the driver (id from 'list_drivers'): STOP_DRIVER id"""
+        self._confirmed_driver_action(arg, "stopping", True, lambda driver_id: self._drivers[driver_id].stop())
+
+    def _cmd_start_driver(self, arg: str) -> None:
+        """start_driver id - starts the driver (id from 'list_drivers'): START_DRIVER id"""
+        self._confirmed_driver_action(arg, "starting", False, lambda driver_id: self._drivers[driver_id].start())
+
+    def _cmd_restart_driver(self, arg: str) -> None:
+        """restart_driver id - stops and starts the driver (id from 'list_drivers'): RESTART_DRIVER id"""
+        self._confirmed_driver_action(arg, "restarting", True, self.restart_driver)
+
+    def _cmd_reload_driver(self, arg: str) -> None:
+        """reload_driver id - replaces the driver with a new instance (id from 'list_drivers'): RELOAD_DRIVER id"""
+        self._confirmed_driver_action(arg, "reloading", None, self.reload_driver)
+
+    def _cmd_list_drivers(self, arg: str) -> None:
+        """list_drivers - list all drivers: LIST_DRIVERS"""
+        more("".join(f"{driver_id}: {driver.get_short_info()}\n" for driver_id, driver in self._drivers.items()))
+
+    # --- schema -------------------------------------------------------------------------------------------------------
+
+    @classmethod
+    def _get_description(cls) -> str:
+        return "Device drivers of the box."
+
+    @classmethod
+    def _get_schema(cls) -> dict[str, Any]:
+        return get_schema()

tinyjukebox/devices/drivers/__init__.py

@@ -0,0 +1,31 @@
+"""All drivers - registry of driver types.
+
+Driver modules import their hardware libraries at module level. They are therefore only imported on demand
+(:func:`get_driver_class`), so tinyjukebox stays importable on machines without these libraries.
+Convention: type ``foo`` → driver module ``tinyjukebox.devices.drivers.foo``, schema module
+``tinyjukebox.devices.schema.foo``.
+"""
+
+import importlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tinyjukebox.devices.baseclasses.adriver import ADriver
+
+__all__ = ["DRIVERS", "get_driver_class"]
+
+DRIVERS: dict[str, str] = {"input": "Input", "rfid": "RFID", "rgbled": "RGBLed", "bluetooth": "Bluetooth"}
+"""driver type (value of ``type`` in the config, lower case) → class name"""
+
+
+def get_driver_class(driver_type: str) -> type["ADriver"]:
+    """Import and return the driver class for ``driver_type`` (case insensitive).
+
+    :raises ValueError: for unknown driver types.
+    """
+    key = driver_type.lower()
+    if key not in DRIVERS:
+        raise ValueError(f"unknown driver type '{driver_type}'.")
+    module = importlib.import_module(f"{__name__}.{key}")
+    driver_class: type[ADriver] = getattr(module, DRIVERS[key])
+    return driver_class

tinyjukebox/devices/drivers/bluetooth.py

@@ -0,0 +1,257 @@
+"""Bluetooth headset: BlueZ (D-Bus) pairs and connects it, BlueALSA plays on it and sets its volume."""
+
+import asyncio
+import contextlib
+import logging
+import threading
+from collections.abc import Mapping
+from typing import Any
+
+from tinyjukebox.core import unexpected
+from tinyjukebox.core.pubsub import PubSubClient
+from tinyjukebox.core.threads import LoggerThread
+from tinyjukebox.devices.baseclasses.adriver import ADriver
+from tinyjukebox.devices.bluetooth.avrcp_input import AvrcpInput
+from tinyjukebox.devices.bluetooth.bluez import Bluez, BluezError, DbusBluez
+from tinyjukebox.devices.bluetooth.link import (
+    COLLECT_TIME,
+    RECONNECT_INTERVAL,
+    SEARCH_TIME,
+    HeadsetLink,
+    Mixer,
+    MixerFactory,
+    button_of,
+)
+from tinyjukebox.devices.schema.bluetooth import get_schema
+from tinyjukebox.messages import (
+    BLUETOOTH_COMMAND,
+    BLUETOOTH_STATE,
+    BUTTON_PRESSED,
+    PLAYBACK,
+    BluetoothCommand,
+    BluetoothState,
+    Button,
+    PlaybackStatus,
+)
+from tinyjukebox.volumemanager import AlsaVolumeControl
+
+__all__ = ["Bluetooth"]
+
+START_TIMEOUT = 15.0  # seconds to wait for the event loop at the start
+STOP_TIMEOUT = 10.0  # seconds to wait for the event loop at the stop
+RETRY_INTERVAL = 30.0  # seconds until BlueZ is tried again if it is not available
+MIXER_RETRY = 0.5  # seconds until the mixer of the headset is opened again - it appears a moment after the headset
+
+
+class Bluetooth(ADriver):
+    """The box as bluetooth sender (like a tv set) for exactly one headset - see
+    :class:`~tinyjukebox.devices.bluetooth.link.HeadsetLink` for what it does.
+
+    * publishes :class:`~tinyjukebox.messages.BluetoothState` on :data:`~tinyjukebox.messages.BLUETOOTH_STATE` and the
+      buttons of the headset on :data:`~tinyjukebox.messages.BUTTON_PRESSED`,
+    * receives :class:`~tinyjukebox.messages.BluetoothCommand` on :data:`~tinyjukebox.messages.BLUETOOTH_COMMAND` and
+      the playback status on :data:`~tinyjukebox.messages.PLAYBACK`.
+
+    BlueZ is used via D-Bus in an event loop (asyncio) in a thread of its own - the handlers only pass the messages
+    on to it. Needs the services bluetooth and bluealsa (``bluez-alsa-utils``) and the groups bluetooth and audio.
+    Without BlueZ (service not running yet, no adapter) the box works without headset; the driver tries again every
+    :data:`RETRY_INTERVAL` seconds.
+
+    Example::
+
+        driver:
+            type: bluetooth
+            adapter: hci0             # optional
+            avrcp: player             # optional - player | input: how the buttons of the headset arrive
+            play-pause-toggle: false  # optional - true: play and pause both switch between play and pause
+    """
+
+    # seconds - see tinyjukebox.devices.bluetooth.link (shorter in tests)
+    reconnect_interval = RECONNECT_INTERVAL
+    search_time = SEARCH_TIME
+    collect_time = COLLECT_TIME
+    retry_interval = RETRY_INTERVAL
+
+    def __init__(
+        self,
+        config: Mapping[str, Any],
+        pubsub_client: PubSubClient,
+        logger: logging.Logger,
+        bluez: Bluez | None = None,
+        mixer_factory: MixerFactory | None = None,
+    ) -> None:
+        """``bluez``, ``mixer_factory``: replace BlueZ and the BlueALSA mixer (tests)."""
+        super().__init__(config, pubsub_client, logger)
+        self._bluez = bluez
+        self._mixer_factory = mixer_factory
+        self._avrcp_input = self._config.get("avrcp", "player") == "input"
+        self._toggle = bool(self._config.get("play-pause-toggle", False))
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._stop_event: asyncio.Event | None = None
+        self._thread: LoggerThread | None = None
+        self._link: HeadsetLink | None = None
+        self._active_bluez: Bluez | None = None
+        self._input: AvrcpInput | None = None
+        self._started = threading.Event()
+        self._playback = PlaybackStatus.STOPPED  # the last one - a new link starts with it
+        self._add_ui_command("state", self._cmd_state)
+
+    def _mixer(self, address: str) -> Mixer:
+        # the mixer of BlueALSA for one headset ("single device mode"): its control is just 'A2DP' and the mixer
+        # exists only while the headset is connected
+        return AlsaVolumeControl("A2DP", self._logger, device=f"bluealsa:{address}", watch_retry=MIXER_RETRY)
+
+    def _publish_button(self, button: Button) -> None:
+        self._publish_value(BUTTON_PRESSED, button)
+
+    def _publish_state(self, state: BluetoothState) -> None:
+        self._publish_value(BLUETOOTH_STATE, state)
+
+    def _input_command(self, command: str) -> None:
+        """A button read from the input device (reader thread)."""
+        link = self._link
+        if link is not None:
+            button = button_of(command, link.playback, self._toggle)
+            if button is not None:
+                self._publish_button(button)
+
+    def _cmd_state(self, args: str) -> None:
+        """state - the devices BlueZ knows: STATE"""
+        bluez = self._active_bluez
+        try:
+            devices = bluez.devices() if bluez is not None else []
+        except RuntimeError:  # changed by the event loop meanwhile
+            devices = []
+            print(f"[{self._name}] busy - try again.")
+        for device in devices:
+            print(
+                f"[{self._name}] {device.address} '{device.name}' paired: {device.paired}, connected: "
+                f"{device.connected}, audio: {device.audio}, battery: {device.battery}"
+            )
+        if not devices:
+            print(f"[{self._name}] no devices.")
+
+    # --- event loop thread ----------------------------------------------------------------------------------------
+
+    def _run(self) -> None:
+        loop = asyncio.new_event_loop()
+        try:
+            loop.run_until_complete(self._main(loop))
+        finally:
+            self._started.set()
+            self._loop = None
+            pending = asyncio.all_tasks(loop)  # nothing is left behind - whatever happened
+            for task in pending:
+                task.cancel()
+            if pending:
+                loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            loop.close()
+
+    async def _main(self, loop: asyncio.AbstractEventLoop) -> None:
+        stop = self._stop_event = asyncio.Event()
+        self._loop = loop
+        self._started.set()
+        failure: str | None = None
+        while not stop.is_set():
+            bluez = self._bluez or DbusBluez(self._logger, self._config.get("adapter", "hci0"))
+            link = HeadsetLink(
+                bluez,
+                self._mixer_factory or self._mixer,
+                self._publish_state,
+                self._publish_button,
+                self._logger,
+                play_pause_toggle=self._toggle,
+                register_player=not self._avrcp_input,
+                reconnect_interval=self.reconnect_interval,
+                search_time=self.search_time,
+                collect_time=self.collect_time,
+            )
+            link.playback_status(self._playback)
+            self._active_bluez, self._link = bluez, link
+            try:
+                await link.run(stop)
+                failure = None
+            except (BluezError, OSError, EOFError, TimeoutError) as e:
+                # e.g. the service bluetooth is not running (yet) - the box plays on its speaker meanwhile
+                level = logging.DEBUG if str(e) == failure else logging.ERROR  # the same reason only once
+                failure = str(e)
+                self._logger.log(
+                    level, "Bluetooth - not available: %s - trying again every %s s", e, self.retry_interval
+                )
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(stop.wait(), self.retry_interval)
+            except Exception as e:
+                # what nobody expected (an answer of BlueZ in another form, a refused authentication of D-Bus) ends
+                # the headset no more for the rest of the run: reported, and tried again as above
+                self._logger.exception("Bluetooth - failed - trying again in %s s", self.retry_interval)
+                unexpected.report(e, "bluetooth driver")
+                failure = None
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(stop.wait(), self.retry_interval)
+            finally:
+                self._link = None
+
+    def _in_loop(self, callback: Any, *args: Any) -> None:
+        loop = self._loop
+        if loop is None:
+            self._logger.warning("Bluetooth - not running, dropped %s", args)
+            return
+        loop.call_soon_threadsafe(callback, *args)
+
+    def _command_handler(self, message: object) -> None:
+        """Handler for :data:`~tinyjukebox.messages.BLUETOOTH_COMMAND`."""
+        link = self._link
+        if isinstance(message, BluetoothCommand) and link is not None:
+            self._in_loop(link.command, message)
+        else:
+            self._logger.warning("Bluetooth - cannot process %r (bluetooth available: %s)", message, link is not None)
+
+    def _playback_handler(self, message: object) -> None:
+        """Handler for :data:`~tinyjukebox.messages.PLAYBACK`."""
+        if not isinstance(message, PlaybackStatus):
+            return
+        self._playback = message
+        link = self._link
+        if link is not None:
+            self._in_loop(link.playback_status, message)
+
+    # --- life cycle -----------------------------------------------------------------------------------------------
+
+    def _driver_start(self) -> None:
+        self._started.clear()
+        self._thread = LoggerThread(target=self._run, name="bluetooth", logger=self._logger, daemon=True)
+        self._thread.start()
+        self._started.wait(START_TIMEOUT)
+        self._pubsub_client.subscribe(BLUETOOTH_COMMAND, self._command_handler)
+        self._pubsub_client.subscribe(PLAYBACK, self._playback_handler)
+        if self._avrcp_input:
+            self._input = AvrcpInput(self._input_command, self._logger)
+            self._input.start()
+
+    def _driver_stop(self) -> None:
+        self._pubsub_client.unsubscribe(BLUETOOTH_COMMAND, self._command_handler, ignore_not_found=True)
+        self._pubsub_client.unsubscribe(PLAYBACK, self._playback_handler, ignore_not_found=True)
+        if self._input is not None:
+            self._input.stop()
+            self._input = None
+        loop, stop_event = self._loop, self._stop_event
+        if loop is not None and stop_event is not None:
+            loop.call_soon_threadsafe(stop_event.set)
+        if self._thread is not None:
+            # a call of the mixer that hangs in alsa-lib must not hold up the stop of the box: the thread is a daemon
+            self._thread.join(STOP_TIMEOUT)
+            if self._thread.is_alive():
+                self._logger.error(
+                    "Bluetooth - the thread does not end within %s s; the box stops without it", STOP_TIMEOUT
+                )
+            self._thread = None
+        self._link = None
+
+    def healthy(self) -> bool:
+        """The driver runs, and so does its thread with the connection to BlueZ."""
+        thread = self._thread
+        return super().healthy() and thread is not None and thread.is_alive()
+
+    @classmethod
+    def _get_schema(cls) -> dict[str, Any]:
+        return get_schema()

tinyjukebox/devices/drivers/input.py

@@ -0,0 +1,165 @@
+"""GPIO input of a button of the box."""
+
+import logging
+import threading
+import time
+from collections.abc import Mapping
+from typing import Any
+
+from RPi import GPIO
+
+from tinyjukebox.core.pubsub import PubSubClient
+from tinyjukebox.devices.baseclasses.adriver import ADriver
+from tinyjukebox.devices.baseclasses.aevents import AEvents
+from tinyjukebox.devices.schema.input import get_schema
+from tinyjukebox.messages import BUTTON_HELD, BUTTON_PRESSED, BUTTON_RELEASED, Button
+
+__all__ = ["Input"]
+
+_EVENTS = {BUTTON_PRESSED: "pressed", BUTTON_HELD: "held", BUTTON_RELEASED: "released"}
+
+
+class Input(ADriver, AEvents):
+    """Publishes the edges of a button (internal pull-up: pressed = low) with the configured
+    :class:`~tinyjukebox.messages.Button` as payload:
+
+    * pressed: :data:`~tinyjukebox.messages.BUTTON_PRESSED`; after ``hold_timeout`` seconds
+      :data:`~tinyjukebox.messages.BUTTON_HELD` - with ``hold_repeat`` again every ``hold_timeout`` seconds for as long
+      as the button stays pressed
+    * released: :data:`~tinyjukebox.messages.BUTTON_RELEASED`; cancels a pending hold event
+
+    Example::
+
+        driver:
+            type: input
+            pin: 21
+            hold_timeout: 1
+            hold_repeat: false  # optional
+            button: volume-up   # volume-up, volume-down, next, prev
+    """
+
+    def __init__(
+        self,
+        config: Mapping[str, Any],
+        pubsub_client: PubSubClient,
+        logger: logging.Logger,
+    ) -> None:
+        ADriver.__init__(self, config, pubsub_client, logger)
+        AEvents.__init__(self, self._config, self._logger)
+
+        self._pin = int(self._config["pin"])
+        self._hold_timeout = float(self._config["hold_timeout"])
+        self._hold_repeat = bool(self._config.get("hold_repeat", False))
+        self._button = Button(self._config["button"])
+        self._hold_timer: threading.Timer | None = None
+        self._hold_lock = threading.Lock()
+        self._holds = False  # hold events only between _driver_start and _driver_stop (guarded by _hold_lock)
+        self._last_event: tuple[str, float] | None = None  # what was published last and when (time.time())
+        self._presses = 0
+        self._add_event(self._pin, self._callback_pin)
+        self._add_ui_command("gpio_state", self._cmd_gpio_state)
+
+    def _cmd_gpio_state(self, args: str) -> None:
+        """gpio_state - displays if the gpio is closed or open: GPIO_STATE"""
+        state = "open" if GPIO.input(self._pin) else "closed"
+        print(f"[{self._name}] gpio {self._pin} is {state}")
+
+    def _publish_event(self, topic: str) -> None:
+        self._last_event = (_EVENTS[topic], time.time())
+        if topic == BUTTON_PRESSED:
+            self._presses += 1
+        self._publish_value(topic, self._button)
+
+    def _driver_state(self) -> dict[str, Any]:
+        """``pressed``: the level of the pin right now (``None``: it cannot be read) - next to the last event it
+        tells a button that does not arrive at the pin from one whose edges get lost."""
+        pressed: bool | None = None
+        if self.is_started:
+            try:
+                pressed = not GPIO.input(self._pin)
+            except Exception as e:  # the view must not fail with the pin
+                self._logger.debug("Input._driver_state - gpio %s cannot be read: %s", self._pin, e)
+        event, at = self._last_event or (None, None)
+        return {
+            "button": self._button.value,
+            "pin": self._pin,
+            "pressed": pressed,
+            "hold_timeout": self._hold_timeout,
+            "hold_repeat": self._hold_repeat,
+            "last_event": event,
+            "last_event_at": at,
+            "presses": self._presses,
+        }
+
+    def _new_hold_timer(self) -> threading.Timer:
+        timer = threading.Timer(self._hold_timeout, self._hold_event)
+        timer.name = f"input.{self._name}.hold"
+        timer.daemon = True
+        timer.start()
+        return timer
+
+    def _start_hold_timer(self) -> None:
+        with self._hold_lock:
+            if self._hold_timer is not None:
+                self._hold_timer.cancel()
+            # an edge callback may still run while the driver stops
+            self._hold_timer = self._new_hold_timer() if self._holds else None
+
+    def _cancel_hold_timer(self) -> None:
+        with self._hold_lock:
+            if self._hold_timer is not None:
+                self._hold_timer.cancel()
+                self._hold_timer = None
+
+    def _hold_event(self) -> None:
+        """Called by the hold timer ``hold_timeout`` seconds after the button has been pressed (``hold_repeat``:
+        and after the previous hold event)."""
+        with self._hold_lock:
+            if self._hold_timer is not threading.current_thread():  # released, pressed again or stopped meanwhile
+                return
+        if GPIO.input(self._pin):
+            # the edge of the release has been lost (e.g. within the bounce time of the press) - without this check
+            # a repeating button would never stop
+            self._logger.info("Input._hold_event - not pressed any more.")
+            self._cancel_hold_timer()
+            self._publish_event(BUTTON_RELEASED)
+            return
+        self._logger.debug("Input._hold_event - pressed for longer than %s seconds.", self._hold_timeout)
+        self._publish_event(BUTTON_HELD)
+        if self._hold_repeat:
+            with self._hold_lock:
+                if self._hold_timer is threading.current_thread():  # neither released nor pressed again meanwhile
+                    self._hold_timer = self._new_hold_timer()
+
+    def _callback_pin(self, channel: int) -> None:
+        """Edge callback of the GPIO library."""
+        state = GPIO.input(self._pin)
+        self._logger.info("Input._callback_pin - received event. pin state: %s.", state)
+        if not state:
+            self._start_hold_timer()
+            self._publish_event(BUTTON_PRESSED)
+        else:
+            self._cancel_hold_timer()
+            self._publish_event(BUTTON_RELEASED)
+
+    def _driver_start(self) -> None:
+        GPIO.setmode(GPIO.BCM)
+        GPIO.setup(self._pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
+        with self._hold_lock:
+            self._holds = True
+        self._register_events()
+
+    def _driver_stop(self) -> None:
+        self._unregister_events()
+        with self._hold_lock:
+            self._holds = False
+            timer, self._hold_timer = self._hold_timer, None
+        if timer is not None:
+            timer.cancel()
+            if timer is not threading.current_thread():
+                timer.join()  # a hold event that runs right now reads the pin before it is released
+        GPIO.cleanup(self._pin)
+
+    @classmethod
+    def _get_schema(cls) -> dict[str, Any]:
+        return get_schema()