feat: adding device_id to listeners and fixing race condition on connection, disconnection and messages

Author: humbertogontijo

roborock/api.py

@@ -176,7 +176,7 @@ def __init__(self, endpoint: str, device_info: DeviceData) -> None:
             }
             device_cache[device_info.device.duid] = cache
         self.cache: dict[CacheableAttribute, AttributeCache] = cache
-        self._listeners: list[Callable[[CacheableAttribute, RoborockBase], None]] = []
+        self._listeners: list[Callable[[str, CacheableAttribute, RoborockBase], None]] = []
 
     def __del__(self) -> None:
         self.release()
@@ -256,7 +256,7 @@ def on_message_received(self, messages: list[RoborockMessage]) -> None:
                                     value[data_protocol.name] = data_point
                                     status = _cls.from_dict(value)
                                     for listener in self._listeners:
-                                        listener(CacheableAttribute.status, status)
+                                        listener(self.device_info.device.duid, CacheableAttribute.status, status)
                                 elif data_protocol in ROBOROCK_DATA_CONSUMABLE_PROTOCOL:
                                     if self.cache[CacheableAttribute.consumable].value is None:
                                         self._logger.debug(
@@ -267,7 +267,9 @@ def on_message_received(self, messages: list[RoborockMessage]) -> None:
                                     value[data_protocol.name] = data_point
                                     consumable = Consumable.from_dict(value)
                                     for listener in self._listeners:
-                                        listener(CacheableAttribute.consumable, consumable)
+                                        listener(
+                                            self.device_info.device.duid, CacheableAttribute.consumable, consumable
+                                        )
                                 return
                             except ValueError:
                                 pass

roborock/cloud_api.py

@@ -132,17 +132,19 @@ def sync_connect(self) -> bool:
 
     async def async_disconnect(self) -> None:
         async with self._mutex:
+            async_response = self._async_response(DISCONNECT_REQUEST_ID)
             disconnecting = self.sync_disconnect()
             if disconnecting:
-                (_, err) = await self._async_response(DISCONNECT_REQUEST_ID)
+                (_, err) = await async_response
                 if err:
                     raise RoborockException(err) from err
 
     async def async_connect(self) -> None:
         async with self._mutex:
+            async_response = self._async_response(CONNECT_REQUEST_ID)
             connecting = self.sync_connect()
             if connecting:
-                (_, err) = await self._async_response(CONNECT_REQUEST_ID)
+                (_, err) = await async_response
                 if err:
                     raise RoborockException(err) from err
 
@@ -165,8 +167,9 @@ async def send_message(self, roborock_message: RoborockMessage):
         local_key = self.device_info.device.local_key
         msg = MessageParser.build(roborock_message, local_key, False)
         self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
+        async_response = self._async_response(request_id, response_protocol)
         self._send_msg_raw(msg)
-        (response, err) = await self._async_response(request_id, response_protocol)
+        (response, err) = await async_response
         self._diagnostic_data[method if method is not None else "unknown"] = {
             "params": roborock_message.get_params(),
             "response": response,

roborock/local_api.py

@@ -153,8 +153,9 @@ async def send_message(self, roborock_message: RoborockMessage):
         if method:
             self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
         # Send the command to the Roborock device
+        async_response = self._async_response(request_id, response_protocol)
         self._send_msg_raw(msg)
-        (response, err) = await self._async_response(request_id, response_protocol)
+        (response, err) = await async_response
         self._diagnostic_data[method if method is not None else "unknown"] = {
             "params": roborock_message.get_params(),
             "response": response,