♻️ rafactor bluetooth manager, handle connecting state

Author: Jezza34000

pypetkitapi/bluetooth.py

@@ -84,6 +84,28 @@ async def check_relay_availability(self, fountain_id: int) -> bool:
             return False
         return True
 
+    async def _request_ble_api(
+        self,
+        endpoint: PetkitEndpoint,
+        fountain: "WaterFountain",
+        extra_data: dict | None = None,
+    ):
+        """API Bluetooth request method"""
+        data = {
+            "bleId": fountain.id,
+            "type": fountain.device_nfo.type,  # type: ignore[union-attr]
+            "mac": fountain.mac,
+        }
+        if extra_data:
+            data.update(extra_data)
+
+        return await self.client.req.request(
+            method=HTTPMethod.POST,
+            url=endpoint,
+            data=data,
+            headers=await self.client.get_session_id(),
+        )
+
     async def open_ble_connection(self, fountain_id: int) -> bool:
         """Open a BLE connection to the given fountain_id.
         :param fountain_id: The ID of the fountain to open the BLE connection for.
@@ -94,51 +116,44 @@ async def open_ble_connection(self, fountain_id: int) -> bool:
         if water_fountain.ble_connection_state == BluetoothState.CONNECTED:
             _LOGGER.debug("BLE connection already established (id %s)", fountain_id)
             return True
-        # ToDo : BluetoothState.CONNECTING must be managed
-        water_fountain.ble_connection_state = BluetoothState.NOT_CONNECTED
-        if not await self.check_relay_availability(fountain_id):
-            _LOGGER.debug("BLE relay not available (id: %s).", fountain_id)
-            return False
-        response = await self.client.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CONNECT,
-            data={
-                "bleId": fountain_id,
-                "type": water_fountain.device_nfo.type,  # type: ignore[union-attr]
-                "mac": water_fountain.mac,
-            },
-            headers=await self.client.get_session_id(),
-        )
-        if response != {"state": 1}:
-            _LOGGER.debug("Unable to open a BLE connection (id %s)", fountain_id)
-            return False
+
+        if water_fountain.ble_connection_state == BluetoothState.CONNECTING:
+            _LOGGER.debug("BLE connection already in progress (id %s).", fountain_id)
+        else:
+            if not await self.check_relay_availability(fountain_id):
+                _LOGGER.debug("BLE relay not available (id: %s).", fountain_id)
+                water_fountain.ble_connection_state = BluetoothState.NOT_CONNECTED
+                return False
+
+            response = await self._request_ble_api(
+                PetkitEndpoint.BLE_CONNECT, water_fountain
+            )
+            if response != {"state": 1}:
+                _LOGGER.debug("Unable to open a BLE connection (id %s)", fountain_id)
+                water_fountain.ble_connection_state = BluetoothState.NOT_CONNECTED
+                return False
+
+            water_fountain.ble_connection_state = BluetoothState.CONNECTING
+
         for attempt in range(BLE_CONNECT_ATTEMPT):
             _LOGGER.debug(
-                "BLE connection... %s/%s (id %s)",
+                "BLE connection... attempt: %s (id %s)",
                 attempt,
-                BLE_CONNECT_ATTEMPT,
                 fountain_id,
             )
-            response = await self.client.req.request(
-                method=HTTPMethod.POST,
-                url=PetkitEndpoint.BLE_POLL,
-                data={
-                    "bleId": fountain_id,
-                    "type": water_fountain.device_nfo.type,  # type: ignore[union-attr]
-                    "mac": water_fountain.mac,
-                },
-                headers=await self.client.get_session_id(),
+            response = await self._request_ble_api(
+                PetkitEndpoint.BLE_POLL, water_fountain
             )
-            if response == 0:
+            if response == BluetoothState.CONNECTING:
                 # Wait for 4 seconds before polling again, connection is still in progress
                 await asyncio.sleep(4)
-            elif response == -1:
+            elif response == BluetoothState.ERROR:
                 _LOGGER.debug("Failed to establish BLE connection (id %s)", fountain_id)
                 water_fountain.last_ble_poll = datetime.now().strftime(
                     "%Y-%m-%dT%H:%M:%S.%f"
                 )
                 return False
-            elif response == 1:
+            elif response == BluetoothState.CONNECTED:
                 _LOGGER.debug(
                     "BLE connection established successfully (id %s)", fountain_id
                 )
@@ -164,20 +179,14 @@ async def close_ble_connection(self, fountain_id: int) -> None:
 
         if water_fountain.ble_connection_state != BluetoothState.CONNECTED:
             _LOGGER.debug(
-                "BLE connection not established. Cannot close (id %s)", fountain_id
+                "BLE connection not established. Cannot close (id %s) State is=%s",
+                fountain_id,
+                water_fountain.ble_connection_state,
             )
             return
 
-        await self.client.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CANCEL,
-            data={
-                "bleId": fountain_id,
-                "type": water_fountain.device_nfo.type,  # type: ignore[union-attr]
-                "mac": water_fountain.mac,
-            },
-            headers=await self.client.get_session_id(),
-        )
+        await self._request_ble_api(PetkitEndpoint.BLE_CANCEL, water_fountain)
+        water_fountain.ble_connection_state = BluetoothState.NOT_CONNECTED
         _LOGGER.debug("BLE connection closed successfully (id %s)", fountain_id)
 
     async def get_ble_cmd_data(
@@ -229,17 +238,10 @@ async def send_ble_command(self, fountain_id: int, command: FountainAction) -> b
         cmd_code, cmd_data = await self.get_ble_cmd_data(
             list(command_data), water_fountain.ble_counter
         )
-        response = await self.client.req.request(
-            method=HTTPMethod.POST,
-            url=PetkitEndpoint.BLE_CONTROL_DEVICE,
-            data={
-                "bleId": water_fountain.id,
-                "cmd": cmd_code,
-                "data": cmd_data,
-                "mac": water_fountain.mac,
-                "type": water_fountain.device_nfo.type,  # type: ignore[union-attr]
-            },
-            headers=await self.client.get_session_id(),
+        response = await self._request_ble_api(
+            PetkitEndpoint.BLE_CONTROL_DEVICE,
+            water_fountain,
+            extra_data={"cmd": cmd_code, "data": cmd_data},
         )
         if response != 1:
             _LOGGER.error("Failed to send BLE command (id %s)", fountain_id)

pypetkitapi/const.py

@@ -151,13 +151,14 @@ class RecordType(StrEnum):
 
 
 class BluetoothState(IntEnum):
-    """Possible states of a Bluetooth connection."""
-
-    NO_STATE = 0
-    NOT_CONNECTED = 1
-    CONNECTING = 2
-    CONNECTED = 3
-    ERROR = 4
+    """Possible states of a Bluetooth connection.
+    Same value as returned by Petkit API
+    """
+
+    CONNECTING = 0
+    CONNECTED = 1
+    ERROR = -1
+    NOT_CONNECTED = 2
 
 
 class PetkitEndpoint(StrEnum):

pypetkitapi/water_fountain_container.py

@@ -164,7 +164,7 @@ class WaterFountain(BaseModel):
     water_pump_run_time: int | None = Field(None, alias="waterPumpRunTime")
     device_records: list[WaterFountainRecord] | None = None
     device_nfo: Device | None = None
-    ble_connection_state: int = 0
+    ble_connection_state: int = 2
     ble_counter: int = 0
     last_ble_poll: str | None = None