Trying to retrieve services

Author: o-murphy

bleak/backends/circuitpython/client.py

@@ -1,5 +1,8 @@
 import logging
+import asyncio
 from typing import Optional, Any
+from uuid import UUID
+
 from typing_extensions import override
 
 from _bleio import set_adapter
@@ -15,6 +18,7 @@
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
+
 class BleakClientCircuitPython(BaseBleakClient):
     def __init__(
         self,
@@ -26,6 +30,7 @@ def __init__(
         _adapter = kwargs.get("adapter")
         if _adapter is not None:
             set_adapter(_adapter)
+        self._timeout = 10
 
         self._radio: Optional[BLERadio] = None
         self._advertisement: Optional[Advertisement] = None
@@ -40,22 +45,13 @@ def __init__(
 
     @override
     async def connect(self, pair, dangerous_use_bleak_cache=False, **kwargs):
-        logger.debug("Attempting to connect BLE device @ {}".format(self.address))
-
-        if self.is_connected:
-            raise BleakError("Client is already connected")
 
         if not self._advertisement.connectable:
             raise BleakError("Device is not connectable")
 
-        if pair:
-            raise NotImplementedError("Not yet implemented")
-
         timeout = kwargs.get("timeout", self._timeout)
 
         if self._advertisement is None:
-            logger.debug("Attempting to find BLE device @ {}".format(self.address))
-
             device = await BleakScanner.find_device_by_address(
                 self.address, timeout=timeout, backend=BleakScannerCircuitPython
             )
@@ -69,21 +65,21 @@ async def connect(self, pair, dangerous_use_bleak_cache=False, **kwargs):
         if self._radio is None:
             self._radio = BLERadio()
 
-        # TODO: disconnect_callback ?
-
         logger.debug("Connecting to BLE device @ {}".format(self.address))
 
-        # TODO: wrap async
-        self._connection = self._radio.connect(self._advertisement.address, timeout=timeout)
+        self._connection = await asyncio.create_task(self._connect_task())
+        if not self.is_connected:
+            raise BleakError("Device is not connected")
+
         logger.debug("Connected to BLE device @ {}".format(self.address))
 
         logger.debug("Retrieving services from BLE device @ {}".format(self.address))
 
-        # TODO: get services
-
+        # TODO: отримати сервіси, обгорнувши синхронний виклик у asyncio.to_thread
+        discovered_services_tuple = await asyncio.create_task(self._discover_services_task())
+        print(discovered_services_tuple)
         logger.debug("Services retrieved from BLE device @ {}".format(self.address))
 
-
     async def disconnect(self) -> None:
         """Disconnect from the peripheral device"""
         logger.debug("Disconnecting from BLE device @ {}".format(self.address))
@@ -95,10 +91,31 @@ async def disconnect(self) -> None:
             logger.debug("Device is not connected @ {}".format(self.address))
             return
 
-        # TODO: wrap async
-        self._connection.disconnect()
+        await asyncio.create_task(self._disconnect_task())
+        self._connection = None
+
         logger.debug("Device disconnected @ {}".format(self.address))
 
+    async def _connect_task(self):
+        return self._radio.connect(self._advertisement.address)
+
+    async def _disconnect_task(self):
+        """Helper to run the blocking disconnect call."""
+        if self.is_connected:
+            self._connection.disconnect()
+
+    async def _discover_services_task(self):
+        if hasattr(self._connection, "_bleio_connection"):
+            bleio_conn = self._connection._bleio_connection
+            if hasattr(bleio_conn, "discover_remote_services"):
+                await asyncio.sleep(1.0)
+                try:
+                    await asyncio.sleep(1)
+                    return bleio_conn.discover_remote_services()
+                except Exception as e:
+                    raise BleakError(f"Failed to discover remote services: {e}")
+        raise BleakError("Discover remote services not available")
+
     @property
     @override
     def is_connected(self) -> bool: