Refactor forwarder and implement clock service

rpi/services/clock_service.py

@@ -0,0 +1,55 @@
+from typing import Callable
+
+from hardware.screen.screen import Screen
+from models.clock import Clock
+
+class ClockService:
+
+    screen : Screen
+    white_clock : Clock
+    black_clock : Clock
+
+    on_terminated : Callable[[], None]
+
+    def __init__(self):
+        self.screen = Screen()
+        self.screen.enableBackground()
+        self.screen.displayMessage("Waiting for start...")
+
+    def start(self, time_control : int, increment : int ):
+        self.white_clock = self.__init_clock(time_control, increment)
+        self.black_clock = self.__init_clock(time_control, increment)
+
+        self.white_clock.start()
+
+    def stop(self):
+        self.white_clock.stop()
+        self.black_clock.stop()
+
+    def switch(self):
+        if self.white_clock.is_running():
+            self.white_clock.stop()
+            self.black_clock.start()
+
+        elif self.black_clock.is_running():
+            self.black_clock.stop()
+            self.white_clock.start()
+
+    def set_on_terminated(self, callback : Callable[[], None]):
+        self.on_terminated = callback
+
+    def __init_clock(self, time_control : int, increment : int) -> Clock:
+        clock = Clock(time_control, increment)
+        clock.set_on_update(self.__tick)
+        clock.set_on_terminated(self.__terminate)
+        return clock
+
+    def __tick(self, formatted_time : str) -> None:
+        self.__update_screen(formatted_time)
+
+    def __terminate(self) -> None:
+        self.__update_screen("Time is over !")
+        self.on_terminated()
+
+    def __update_screen(self, message : str) -> None:
+        self.screen.displayMessage(message)

rpi/services/forwarder_service.py

@@ -0,0 +1,37 @@
+import os
+
+from dotenv import load_dotenv
+
+from controllers.mqtt_forwarder import MQTTForwarder
+from services.mqtt_service import MQTTService
+
+
+class ForwarderService:
+
+    src_broker_service: MQTTService
+    dst_broker_service: MQTTService
+    forwards: dict[MQTTForwarder, tuple[str, str]]
+
+    def __init__(self, src_broker: MQTTService, dst_broker: MQTTService):
+        self.src_broker_service = src_broker
+        self.dst_broker_service = dst_broker
+        self.forwards = {}
+
+    def register_forwarder(self, client_id: str, src_topic: str, dst_topic: str) -> None:
+        forwarder = MQTTForwarder(
+            client_id,
+            self.src_broker_service,
+            self.dst_broker_service
+        )
+        self.forwards[forwarder] = (src_topic, dst_topic)
+
+    def start_all(self):
+        self.src_broker_service.connect()
+        self.dst_broker_service.connect()
+
+        for forwarder, (src_topic, dst_topic) in self.forwards.items():
+            forwarder.start(src_topic, dst_topic)
+
+    def stop_all(self):
+        self.src_broker_service.disconnect()
+        self.dst_broker_service.disconnect()