Move door commands into RunChickenDevice; drop RunChickenController

RunChickenController held its own BleakClient snapshot, which went stale
after a reconnect and forced the cover entity to repoint it before every
command. Fold open/close into RunChickenDevice, which already owns the
connection, so there is a single connection+command+notification owner and
the stale-client class of bug is gone by construction.

- parser.py: add async_open/async_close (retry-wrapped) writing via the live
  client, plus a shared _require_client helper. Remove the now-unused public
  `client` property.
- cover.py: commands call device.async_open/async_close directly; the entity
  no longer creates or refreshes a controller, so its __init__ is just
  identity/device-info.
- config_flow.py: the connectivity probe tears down via device.async_disconnect()
  instead of poking device.client.
- Delete run_chicken_ble/cover.py and drop RunChickenController from the
  package API.

Author: bkanuka

custom_components/run_chicken/config_flow.py

@@ -122,7 +122,5 @@ async def _async_try_connect(self, address: str) -> str | None:
             _LOGGER.exception("Unexpected error connecting to Run-Chicken device %s", address)
             return "unknown"
         finally:
-            client = device.client
-            if client is not None:
-                await client.disconnect()
+            await device.async_disconnect()
         return None

custom_components/run_chicken/cover.py

@@ -10,15 +10,13 @@
     CoverEntity,
     CoverEntityDescription,
 )
-from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers.device_registry import (
     CONNECTION_BLUETOOTH,
     DeviceInfo,
 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import RunChickenCoordinator
-from .run_chicken_ble.cover import RunChickenController
 from .run_chicken_ble.models import RunChickenDoorState
 
 _LOGGER = logging.getLogger(__name__)
@@ -57,12 +55,6 @@ def __init__(self, coordinator: RunChickenCoordinator) -> None:
         super().__init__(coordinator)
         self.run_chicken_device = coordinator.device
 
-        client = self.run_chicken_device.client
-        if client is None:
-            msg = "Run-Chicken device is not connected; cannot set up cover."
-            raise ConfigEntryNotReady(msg)
-        self.controller = RunChickenController(client=client)
-
         self._attr_unique_id = f"run_chicken_{self.run_chicken_device.address}"
 
         self._attr_device_info = DeviceInfo(
@@ -84,31 +76,13 @@ def is_closed(self) -> bool | None:
             return None
         return self.coordinator.data.door_state is RunChickenDoorState.CLOSED
 
-    async def _async_ready_controller(self) -> RunChickenController:
-        """
-        Reconnect if needed and point the controller at the current client.
-
-        After a disconnect the device builds a fresh client, so the controller's
-        captured client goes stale and writes fail with "characteristic not
-        found". Refreshing it here keeps commands aligned with the live client.
-        """
-        await self.run_chicken_device.ensure_client_connected()
-        client = self.run_chicken_device.client
-        if client is None:
-            msg = "Run-Chicken device is not connected."
-            raise HomeAssistantError(msg)
-        self.controller.client = client
-        return self.controller
-
     async def async_open_cover(self, **kwargs: Any) -> None:  # noqa: ARG002
-        """Open the coop door, reconnecting first if the connection dropped."""
-        controller = await self._async_ready_controller()
-        await controller.open_cover()
+        """Open the coop door (the device reconnects first if needed)."""
+        await self.run_chicken_device.async_open()
 
     async def async_close_cover(self, **kwargs: Any) -> None:  # noqa: ARG002
-        """Close the coop door, reconnecting first if the connection dropped."""
-        controller = await self._async_ready_controller()
-        await controller.close_cover()
+        """Close the coop door (the device reconnects first if needed)."""
+        await self.run_chicken_device.async_close()
 
     def _handle_coordinator_update(self) -> None:
         """Handle data update."""

custom_components/run_chicken/run_chicken_ble/__init__.py

@@ -12,12 +12,10 @@
 defines the public surface of the package.
 """
 
-from .cover import RunChickenController
 from .models import RunChickenDeviceData
 from .parser import RunChickenDevice
 
 __all__ = [
-    "RunChickenController",
     "RunChickenDevice",
     "RunChickenDeviceData",
 ]

custom_components/run_chicken/run_chicken_ble/cover.py

@@ -13,7 +13,8 @@
 )
 from homeassistant.helpers.update_coordinator import UpdateFailed
 
-from .const import READ_CHAR_UUID
+from .const import READ_CHAR_UUID, WRITE_CHAR_UUID
+from .create_packet import create_close_packet, create_open_packet
 from .models import RunChickenDeviceData, RunChickenDoorState
 
 if TYPE_CHECKING:
@@ -52,11 +53,6 @@ def __init__(
         else:
             self._device_data: RunChickenDeviceData = device_data
 
-    @property
-    def client(self) -> BleakClient | None:
-        """Return the BLE client."""
-        return self._client
-
     @property
     def address(self) -> str:
         """Return the BLE address of the device."""
@@ -67,16 +63,21 @@ def device_data(self) -> RunChickenDeviceData:
         """Return the device data."""
         return self._device_data
 
-    def _connected_read_char(self) -> tuple[BleakClient, BleakGATTCharacteristic]:
-        """Return the connected client and its read characteristic, or raise."""
+    def _require_client(self) -> BleakClient:
+        """Return the connected client, or raise if not connected."""
         if self._client is None:
             msg = "Run-Chicken device is not connected."
             raise UpdateFailed(msg)
-        char = self._client.services.get_characteristic(READ_CHAR_UUID)
+        return self._client
+
+    def _connected_read_char(self) -> tuple[BleakClient, BleakGATTCharacteristic]:
+        """Return the connected client and its read characteristic, or raise."""
+        client = self._require_client()
+        char = client.services.get_characteristic(READ_CHAR_UUID)
         if char is None:
             msg = f"Read characteristic {READ_CHAR_UUID} not found on device."
             raise UpdateFailed(msg)
-        return self._client, char
+        return client, char
 
     def set_disconnect_callback(self, callback: Callable[[], None]) -> None:
         """
@@ -184,3 +185,19 @@ async def update_device(self) -> RunChickenDeviceData:
         await self.ensure_client_connected()
         self._device_data.door_state = self._parse_door_state(await self._read_payload())
         return self._device_data
+
+    @retry_bluetooth_connection_error()
+    async def async_open(self) -> None:
+        """Open the Run-Chicken door."""
+        await self._async_send_command(create_open_packet())
+
+    @retry_bluetooth_connection_error()
+    async def async_close(self) -> None:
+        """Close the Run-Chicken door."""
+        await self._async_send_command(create_close_packet())
+
+    async def _async_send_command(self, packet: bytes) -> None:
+        """Connect if needed and write a command packet to the door."""
+        await self.ensure_client_connected()
+        client = self._require_client()
+        await client.write_gatt_char(WRITE_CHAR_UUID, packet)