Reconnect and recover after a Bluetooth disconnect (#3)

The door occasionally drops its BLE connection. Until HA was restarted this
left it unusable in three ways, because nothing reconnected:

- Commands failed with "characteristic ... was not found": the cover's
  controller kept writing through the client captured at setup while
  RunChickenDevice had built a replacement. Reconnect and repoint the
  controller at the live client before each command (the fix from #13).
- Push updates (door-state changes the door reports on its own) stopped:
  GATT notifications only arrive over a live connection, and after a drop
  nothing re-established it or re-subscribed.

Add active reconnection: RunChickenDevice takes a disconnect callback that
fires on an unexpected drop; __init__ wires it to a coordinator refresh,
which reconnects, re-subscribes notifications, and re-reads state. The
notification callback is stored and re-subscribed on every reconnect.

Lifecycle: async_disconnect() marks an expected disconnect and tears down
the link on unload (suppressing reconnect), and the advertisement callback
registration is now released via entry.async_on_unload.

Author: bkanuka

custom_components/run_chicken/__init__.py

@@ -100,11 +100,13 @@ def async_handle_bluetooth_event(service_info: BluetoothServiceInfoBleak, change
         loop = asyncio.get_running_loop()
         loop.create_task(coordinator.async_request_refresh())  # noqa: RUF006
 
-    async_register_callback(
-        hass,
-        async_handle_bluetooth_event,
-        BluetoothCallbackMatcher(address=address),
-        BluetoothScanningMode.ACTIVE,
+    entry.async_on_unload(
+        async_register_callback(
+            hass,
+            async_handle_bluetooth_event,
+            BluetoothCallbackMatcher(address=address),
+            BluetoothScanningMode.ACTIVE,
+        )
     )
 
     def notification_callback(gatt_char: BleakGATTCharacteristic, payload: bytearray) -> None:  # noqa: ARG001
@@ -116,11 +118,23 @@ def notification_callback(gatt_char: BleakGATTCharacteristic, payload: bytearray
 
     await run_chicken_device.register_notification_callback(notification_callback)
 
+    # Notifications stop when the door drops the connection, so reconnect on an
+    # unexpected disconnect. The coordinator refresh re-establishes the
+    # connection, which re-subscribes notifications and re-reads the state.
+    def _schedule_reconnect() -> None:
+        _LOGGER.debug("Run-Chicken %s disconnected; scheduling reconnect", address)
+        hass.async_create_task(coordinator.async_request_refresh(), f"{DOMAIN}_reconnect_{address}")
+
+    run_chicken_device.set_disconnect_callback(_schedule_reconnect)
+
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: RunChickenConfigEntry) -> bool:
     """Unload a config entry."""
+    # Stop auto-reconnect and drop the connection before tearing down.
+    await entry.runtime_data.async_disconnect()
+
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
         hass.data[DOMAIN].pop(entry.entry_id)
 

custom_components/run_chicken/cover.py

@@ -10,7 +10,7 @@
     CoverEntity,
     CoverEntityDescription,
 )
-from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers.device_registry import (
     CONNECTION_BLUETOOTH,
     DeviceInfo,
@@ -102,23 +102,31 @@ def is_closed(self) -> bool | None:
             return None
         return self.coordinator.data.door_state is RunChickenDoorState.CLOSED
 
-    async def async_open_cover(self, **kwargs: Any) -> None:  # noqa: ARG002
+    async def _async_ready_controller(self) -> RunChickenController:
         """
-        Open the coop door via the BLE controller.
+        Reconnect if needed and point the controller at the current client.
 
-        Ensures a connected `RunChickenCover` controller exists, then sends
-        the open command to the device.
+        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.controller.open_cover()
+        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_close_cover(self, **kwargs: Any) -> None:  # noqa: ARG002
-        """
-        Close the coop door via the BLE 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()
 
-        Ensures a connected `RunChickenCover` controller exists, then sends
-        the close command to the device.
-        """
-        await self.controller.close_cover()
+    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()
 
     def _handle_coordinator_update(self) -> None:
         """Handle data update."""

custom_components/run_chicken/run_chicken_ble/parser.py

@@ -40,6 +40,12 @@ def __init__(
 
         self.ble_device: BLEDevice = ble_device
         self._client: BleakClient | None = client
+        # Stored so notifications can be re-subscribed on every reconnect.
+        self._notification_callback: Callable | None = None
+        # Invoked on an unexpected disconnect so the owner can reconnect.
+        self._disconnect_callback: Callable[[], None] | None = None
+        # Set during teardown so we don't fight an intentional disconnect.
+        self._expected_disconnect = False
 
         if device_data is None:
             self._device_data: RunChickenDeviceData = RunChickenDeviceData(address=ble_device.address)
@@ -72,22 +78,61 @@ def _connected_read_char(self) -> tuple[BleakClient, BleakGATTCharacteristic]:
             raise UpdateFailed(msg)
         return self._client, char
 
+    def set_disconnect_callback(self, callback: Callable[[], None]) -> None:
+        """
+        Register a callback invoked when the device disconnects unexpectedly.
+
+        Notifications only arrive while connected, so the owner uses this to
+        re-establish the connection (which re-subscribes notifications).
+        """
+        self._disconnect_callback = callback
+
     async def register_notification_callback(self, callback: Callable) -> None:
-        """Register a callback to be called when the device sends a notification."""
-        client, read_char = self._connected_read_char()
-        await client.start_notify(read_char, callback)
+        """
+        Register a callback for device notifications.
+
+        Notifications are only delivered over a live connection, so the callback
+        is stored and automatically re-subscribed whenever the device reconnects.
+        """
+        self._notification_callback = callback
+        await self._async_subscribe_notifications()
+
+    async def _async_subscribe_notifications(self) -> None:
+        """Subscribe the stored notification callback on the current client, if any."""
+        if self._notification_callback is None or self._client is None:
+            return
+        read_char = self._client.services.get_characteristic(READ_CHAR_UUID)
+        if read_char is None:
+            _LOGGER.warning("Read characteristic %s not found; cannot subscribe to notifications", READ_CHAR_UUID)
+            return
+        await self._client.start_notify(read_char, self._notification_callback)
+        _LOGGER.debug("Subscribed to Run-Chicken notifications on %s", self._client.address)
 
     async def ensure_client_connected(self) -> None:
         """Ensure the client is connected."""
         if self._client is None or not self._client.is_connected:
             await self._get_client()
 
+    async def async_disconnect(self) -> None:
+        """Disconnect and suppress auto-reconnect; used during teardown."""
+        self._expected_disconnect = True
+        client = self._client
+        self._client = None
+        if client is not None and client.is_connected:
+            await client.disconnect()
+
     async def _get_client(self) -> BleakClient:
         """Get the client from the ble device."""
+        if self._expected_disconnect:
+            msg = "Run-Chicken device is shutting down."
+            raise UpdateFailed(msg)
 
         def on_disconnect(client: BleakClient) -> None:
             _LOGGER.warning("Device %s disconnected unexpectedly", client.address)
             self._client = None
+            # Notifications die with the connection; ask the owner to reconnect.
+            if not self._expected_disconnect and self._disconnect_callback is not None:
+                self._disconnect_callback()
 
         if self.ble_device.address != self._device_data.address:
             self._client = None
@@ -108,6 +153,9 @@ def on_disconnect(client: BleakClient) -> None:
 
         self._device_data.address = self._client.address
 
+        # Re-subscribe notifications so push updates resume after a reconnect.
+        await self._async_subscribe_notifications()
+
         return self._client
 
     @staticmethod