feat: Simplify local payload encoding by rejecting any cloud commands sent locally

Author: allenporter

roborock/protocols/v1_protocol.py

@@ -13,12 +13,6 @@
 from roborock.roborock_typing import RoborockCommand
 from roborock.util import get_next_int
 
-# All mqtt commands are sent securely. Only local commands in this list are secured.
-COMMANDS_SECURED = {
-    RoborockCommand.GET_MAP_V1,
-    RoborockCommand.GET_MULTI_MAP,
-}
-
 CommandType = RoborockCommand | str
 ParamsType = list | dict | int | None
 
@@ -79,24 +73,19 @@ def _get_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
     return _get_payload
 
 
-def create_local_payload_encoder(security_data: SecurityData) -> Callable[[CommandType, ParamsType], RoborockMessage]:
-    """Create a payload encoder for V1 commands over local connection."""
-
-    def _get_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
-        """Build the payload for a V1 command."""
-        request = RequestMessage(method=method, params=params)
-        is_secured = request.method in COMMANDS_SECURED
-        payload = request.as_payload(security_data if is_secured else None)
+def encode_local_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
+    """Encode payload for V1 commands over local connection."""
 
-        message_retry: MessageRetry | None = None
-        if method == RoborockCommand.RETRY_REQUEST and isinstance(params, dict):
-            message_retry = MessageRetry(method=method, retry_id=params["retry_id"])
+    request = RequestMessage(method=method, params=params)
+    payload = request.as_payload(security_data=None)
 
-        return RoborockMessage(
-            timestamp=request.timestamp,
-            protocol=RoborockMessageProtocol.GENERAL_REQUEST,
-            payload=payload,
-            message_retry=message_retry,
-        )
+    message_retry: MessageRetry | None = None
+    if method == RoborockCommand.RETRY_REQUEST and isinstance(params, dict):
+        message_retry = MessageRetry(method=method, retry_id=params["retry_id"])
 
-    return _get_payload
+    return RoborockMessage(
+        timestamp=request.timestamp,
+        protocol=RoborockMessageProtocol.GENERAL_REQUEST,
+        payload=payload,
+        message_retry=message_retry,
+    )

roborock/version_1_apis/roborock_client_v1.py

@@ -54,11 +54,14 @@
     RoborockMessageProtocol,
 )
 from roborock.util import RepeatableTask, unpack_list
-from roborock.protocols.v1_protocol import COMMANDS_SECURED
-
 
 CUSTOM_COMMANDS = {RoborockCommand.GET_MAP_CALIBRATION}
 
+COMMANDS_SECURED = {
+    RoborockCommand.GET_MAP_V1,
+    RoborockCommand.GET_MULTI_MAP,
+}
+
 CLOUD_REQUIRED = COMMANDS_SECURED.union(CUSTOM_COMMANDS)
 
 WASH_N_FILL_DOCK = [

roborock/version_1_apis/roborock_local_client_v1.py

@@ -4,10 +4,10 @@
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
-from ..protocols.v1_protocol import SecurityData, create_local_payload_encoder
+from ..protocols.v1_protocol import encode_local_payload
 from ..roborock_message import RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter
-from .roborock_client_v1 import RoborockClientV1
+from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,16 +21,16 @@ def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
         RoborockClientV1.__init__(self, device_data, "abc")
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
-        self._payload_encoder = create_local_payload_encoder(
-            SecurityData(endpoint=self._endpoint, nonce=self._nonce),
-        )
 
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        roborock_message = self._payload_encoder(method, params)
+        if method in CLOUD_REQUIRED:
+            raise RoborockException(f"Method {method} is not supported over local connection")
+
+        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)