chore: avoid re-parsing RoborockMessages and replace with passing explicit arguments (#439)

Author: allenporter

roborock/roborock_message.py

@@ -256,23 +256,3 @@ def get_request_id(self) -> int | None:
                     data_point_response = json.loads(data_point)
                     return data_point_response.get("id")
         return None
-
-    def get_method(self) -> str | None:
-        protocol = self.protocol
-        if self.payload and protocol in [4, 5, 101, 102]:
-            payload = json.loads(self.payload.decode())
-            for data_point_number, data_point in payload.get("dps").items():
-                if data_point_number in ["101", "102"]:
-                    data_point_response = json.loads(data_point)
-                    return data_point_response.get("method")
-        return None
-
-    def get_params(self) -> list | dict | None:
-        protocol = self.protocol
-        if self.payload and protocol in [4, 101, 102]:
-            payload = json.loads(self.payload.decode())
-            for data_point_number, data_point in payload.get("dps").items():
-                if data_point_number in ["101", "102"]:
-                    data_point_response = json.loads(data_point)
-                    return data_point_response.get("params")
-        return None

roborock/version_1_apis/roborock_local_client_v1.py

@@ -18,6 +18,19 @@
 _LOGGER = logging.getLogger(__name__)
 
 
+_HELLO_REQUEST_MESSAGE = RoborockMessage(
+    protocol=RoborockMessageProtocol.HELLO_REQUEST,
+    seq=1,
+    random=22,
+)
+
+_PING_REQUEST_MESSAGE = RoborockMessage(
+    protocol=RoborockMessageProtocol.PING_REQUEST,
+    seq=2,
+    random=23,
+)
+
+
 @dataclass
 class _LocalProtocol(asyncio.Protocol):
     """Callbacks for the Roborock local client transport."""
@@ -109,29 +122,13 @@ async def async_disconnect(self) -> None:
             self._sync_disconnect()
 
     async def hello(self):
-        request_id = 1
-        protocol = RoborockMessageProtocol.HELLO_REQUEST
         try:
-            return await self._send_message(
-                RoborockMessage(
-                    protocol=protocol,
-                    seq=request_id,
-                    random=22,
-                )
-            )
+            return await self._send_message(_HELLO_REQUEST_MESSAGE)
         except Exception as e:
             self._logger.error(e)
 
     async def ping(self) -> None:
-        request_id = 2
-        protocol = RoborockMessageProtocol.PING_REQUEST
-        return await self._send_message(
-            RoborockMessage(
-                protocol=protocol,
-                seq=request_id,
-                random=23,
-            )
-        )
+        await self._send_message(_PING_REQUEST_MESSAGE)
 
     def _send_msg_raw(self, data: bytes):
         try:
@@ -151,12 +148,15 @@ async def _send_command(
 
         roborock_message = encode_local_payload(method, params)
         self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id(), method)
-        return await self._send_message(roborock_message)
+        return await self._send_message(roborock_message, method, params)
 
-    async def _send_message(self, roborock_message: RoborockMessage):
+    async def _send_message(
+        self,
+        roborock_message: RoborockMessage,
+        method: str | None = None,
+        params: list | dict | int | None = None,
+    ) -> RoborockMessage:
         await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
         request_id: int | None
         if not method or not method.startswith("get"):
             request_id = roborock_message.seq
@@ -177,16 +177,16 @@ async def _send_message(self, roborock_message: RoborockMessage):
             response = await async_response
         except VacuumError as err:
             self._diagnostic_data[diagnostic_key] = {
-                "params": roborock_message.get_params(),
+                "params": params,
                 "error": err,
             }
             raise CommandVacuumError(method, err) from err
         self._diagnostic_data[diagnostic_key] = {
-            "params": roborock_message.get_params(),
+            "params": params,
             "response": response,
         }
         if roborock_message.protocol == RoborockMessageProtocol.GENERAL_REQUEST:
-            self._logger.debug(f"id={request_id} Response from method {roborock_message.get_method()}: {response}")
+            self._logger.debug(f"id={request_id} Response from method {method}: {response}")
         if response == "retry":
             raise RoborockException(f"Command {method} failed with 'retry' message; Device is busy, try again later")
         return response

roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -13,7 +13,6 @@
 from ..protocol import Utils
 from ..protocols.v1_protocol import SecurityData, create_mqtt_payload_encoder
 from ..roborock_message import (
-    RoborockMessage,
     RoborockMessageProtocol,
 )
 from ..roborock_typing import RoborockCommand
@@ -41,10 +40,19 @@ def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout:
             SecurityData(endpoint=self._endpoint, nonce=self._nonce),
         )
 
-    async def send_message(self, roborock_message: RoborockMessage):
+    async def _send_command(
+        self,
+        method: RoborockCommand | str,
+        params: list | dict | int | None = None,
+    ):
+        if method in CUSTOM_COMMANDS:
+            # When we have more custom commands do something more complicated here
+            return await self._get_calibration_points()
+
+        roborock_message = self._payload_encoder(method, params)
+        self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id, method)
+
         await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
         request_id = roborock_message.get_request_id()
         if request_id is None:
             raise RoborockException(f"Failed build message {roborock_message}")
@@ -60,12 +68,12 @@ async def send_message(self, roborock_message: RoborockMessage):
             response = await async_response
         except VacuumError as err:
             self._diagnostic_data[diagnostic_key] = {
-                "params": roborock_message.get_params(),
+                "params": params,
                 "error": err,
             }
             raise CommandVacuumError(method, err) from err
         self._diagnostic_data[diagnostic_key] = {
-            "params": roborock_message.get_params(),
+            "params": params,
             "response": response,
         }
         if response_protocol == RoborockMessageProtocol.MAP_RESPONSE:
@@ -74,19 +82,6 @@ async def send_message(self, roborock_message: RoborockMessage):
             self._logger.debug(f"id={request_id} Response from {method}: {response}")
         return response
 
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        if method in CUSTOM_COMMANDS:
-            # When we have more custom commands do something more complicated here
-            return await self._get_calibration_points()
-
-        roborock_message = self._payload_encoder(method, params)
-        self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id, method)
-        return await self.send_message(roborock_message)
-
     async def _get_calibration_points(self):
         map: bytes = await self.send_command(RoborockCommand.GET_MAP_V1)
         parser = RoborockMapDataParser(ColorsPalette(), Sizes(), [], ImageConfig(), [])