feat: Refactor ServerWwdController initialization and state managemen…

stackchan_server/server_wwd.py

@@ -20,23 +20,19 @@ class ServerWwdController:
     def __init__(
         self,
         *,
-        send_state_command: Callable[[int], Awaitable[None]],
-        set_current_state: Callable[[int], None],
+        enter_server_wwd: Callable[[], Awaitable[None]],
+        return_to_idle: Callable[[], Awaitable[None]],
         close_websocket: Callable[[int, str], Awaitable[None]],
-        current_state: Callable[[], int],
+        is_idle_state: Callable[[], bool],
         is_closed: Callable[[], bool],
         on_detected: Callable[[], None],
-        server_wwd_state: int,
-        idle_state: int,
     ) -> None:
-        self._send_state_command = send_state_command
-        self._set_current_state = set_current_state
+        self._enter_server_wwd = enter_server_wwd
+        self._return_to_idle = return_to_idle
         self._close_websocket = close_websocket
-        self._current_state = current_state
+        self._is_idle_state = is_idle_state
         self._is_closed = is_closed
         self._on_detected = on_detected
-        self._server_wwd_state = server_wwd_state
-        self._idle_state = idle_state
 
         self._detector = create_server_side_wake_word_detector()
         self._task: Optional[asyncio.Task[bool]] = None
@@ -58,11 +54,7 @@ async def enable_auto_detection(self) -> None:
         self._auto_start = True
 
     async def start_if_available(self) -> bool:
-        if (
-            self._is_closed()
-            or self._detector is None
-            or self._current_state() != self._idle_state
-        ):
+        if self._is_closed() or self._detector is None or not self._is_idle_state():
             return False
 
         if self._task is not None and not self._task.done():
@@ -188,7 +180,7 @@ async def _run_detection(self) -> bool:
         should_restart = False
         try:
             await detector.start()
-            await self._send_state_command(self._server_wwd_state)
+            await self._enter_server_wwd()
             detected = await detector.wait_result()
             if detected:
                 self._on_detected()
@@ -208,9 +200,8 @@ async def _run_detection(self) -> bool:
             await detector.stop()
             self._arm_trailing_pcm_drain()
             if not self._is_closed():
-                self._set_current_state(self._idle_state)
                 try:
-                    await self._send_state_command(self._idle_state)
+                    await self._return_to_idle()
                 except Exception:
                     logger.exception(
                         "Failed to return firmware to idle after wake-word detection"

stackchan_server/ws_proxy.py

@@ -134,16 +134,12 @@ def __init__(
         self._servo_sent_counter = 0
         self._pending_servo_wait_targets: deque[int] = deque()
         self._server_wwd = ServerWwdController(
-            send_state_command=self.send_state_command,
-            set_current_state=lambda state: setattr(
-                self, "_current_firmware_state", FirmwareState(state)
-            ),
+            enter_server_wwd=self._enter_server_wwd_state,
+            return_to_idle=self._return_to_idle_state,
             close_websocket=self.ws.close,
-            current_state=lambda: int(self._current_firmware_state),
+            is_idle_state=lambda: self._current_firmware_state == FirmwareState.IDLE,
             is_closed=lambda: self._closed,
             on_detected=self._wakeword_event.set,
-            server_wwd_state=int(FirmwareState.SERVER_WWD),
-            idle_state=int(FirmwareState.IDLE),
         )
 
     @property
@@ -448,6 +444,13 @@ async def _send_state_command(
             )
         )
 
+    async def _enter_server_wwd_state(self) -> None:
+        await self.send_state_command(FirmwareState.SERVER_WWD)
+
+    async def _return_to_idle_state(self) -> None:
+        self._current_firmware_state = FirmwareState.IDLE
+        await self.send_state_command(FirmwareState.IDLE)
+
     async def _send_ws_bytes(self, data: bytes) -> None:
         try:
             await self.ws.send_bytes(data)