python-roborock 2.23.0__tar.gz → 2.25.0__tar.gz

{python_roborock-2.23.0 → python_roborock-2.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.23.0
+Version: 2.25.0
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.23.0 → python_roborock-2.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.23.0"
+version = "2.25.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -76,3 +76,4 @@ select=["E", "F", "UP", "I"]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 timeout = 30
+log_format = "%(asctime)s.%(msecs)03d %(levelname)s (%(threadName)s) [%(name)s] %(message)s"

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/cli.py

@@ -12,9 +12,9 @@ from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException
 from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import RoborockException
-from roborock.containers import DeviceData, HomeDataProduct, LoginData
-from roborock.mqtt.roborock_session import create_mqtt_session
-from roborock.protocol import MessageParser, create_mqtt_params
+from roborock.containers import DeviceData, HomeData, HomeDataProduct, LoginData
+from roborock.devices.device_manager import create_device_manager, create_home_data_api
+from roborock.protocol import MessageParser
 from roborock.util import run_sync
 from roborock.version_1_apis.roborock_local_client_v1 import RoborockLocalClientV1
 from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
@@ -101,44 +101,25 @@ async def session(ctx, duration: int):
     context: RoborockContext = ctx.obj
     login_data = context.login_data()
 
-    # Discovery devices if not already available
-    if not login_data.home_data:
-        await _discover(ctx)
-        login_data = context.login_data()
-    if not login_data.home_data or not login_data.home_data.devices:
-        raise RoborockException("Unable to discover devices")
-
-    all_devices = login_data.home_data.devices + login_data.home_data.received_devices
-    click.echo(f"Discovered devices: {', '.join([device.name for device in all_devices])}")
-
-    rriot = login_data.user_data.rriot
-    params = create_mqtt_params(rriot)
-
-    mqtt_session = await create_mqtt_session(params)
-    click.echo("Starting MQTT session...")
-    if not mqtt_session.connected:
-        raise RoborockException("Failed to connect to MQTT broker")
+    home_data_api = create_home_data_api(login_data.email, login_data.user_data)
 
-    def on_message(bytes: bytes):
-        """Callback function to handle incoming MQTT messages."""
-        # Decode the first 20 bytes of the message for display
-        bytes = bytes[:20]
+    async def home_data_cache() -> HomeData:
+        if login_data.home_data is None:
+            login_data.home_data = await home_data_api()
+            context.update(login_data)
+        return login_data.home_data
 
-        click.echo(f"Received message: {bytes}...")
+    # Create device manager
+    device_manager = await create_device_manager(login_data.user_data, home_data_cache)
 
-    unsubs = []
-    for device in all_devices:
-        device_topic = f"rr/m/o/{rriot.u}/{params.username}/{device.duid}"
-        unsub = await mqtt_session.subscribe(device_topic, on_message)
-        unsubs.append(unsub)
+    devices = await device_manager.get_devices()
+    click.echo(f"Discovered devices: {', '.join([device.name for device in devices])}")
 
     click.echo("MQTT session started. Listening for messages...")
     await asyncio.sleep(duration)
 
-    click.echo("Stopping MQTT session...")
-    for unsub in unsubs:
-        unsub()
-    await mqtt_session.close()
+    # Close the device manager (this will close all devices and MQTT session)
+    await device_manager.close()
 
 
 async def _discover(ctx):

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/devices/device.py

@@ -6,9 +6,13 @@ until the API is stable.
 
 import enum
 import logging
+from collections.abc import Callable
 from functools import cached_property
 
 from roborock.containers import HomeDataDevice, HomeDataProduct, UserData
+from roborock.roborock_message import RoborockMessage
+
+from .mqtt_channel import MqttChannel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,11 +33,25 @@ class DeviceVersion(enum.StrEnum):
 class RoborockDevice:
     """Unified Roborock device class with automatic connection setup."""
 
-    def __init__(self, user_data: UserData, device_info: HomeDataDevice, product_info: HomeDataProduct) -> None:
-        """Initialize the RoborockDevice with device info, user data, and capabilities."""
+    def __init__(
+        self,
+        user_data: UserData,
+        device_info: HomeDataDevice,
+        product_info: HomeDataProduct,
+        mqtt_channel: MqttChannel,
+    ) -> None:
+        """Initialize the RoborockDevice.
+
+        The device takes ownership of the MQTT channel for communication with the device.
+        Use `connect()` to establish the connection, which will set up the MQTT channel
+        for receiving messages from the device. Use `close()` to unsubscribe from the MQTT
+        channel.
+        """
         self._user_data = user_data
         self._device_info = device_info
         self._product_info = product_info
+        self._mqtt_channel = mqtt_channel
+        self._unsub: Callable[[], None] | None = None
 
     @property
     def duid(self) -> str:
@@ -63,3 +81,28 @@ class RoborockDevice:
             self._device_info.name,
         )
         return DeviceVersion.UNKNOWN
+
+    async def connect(self) -> None:
+        """Connect to the device using MQTT.
+
+        This method will set up the MQTT channel for communication with the device.
+        """
+        if self._unsub:
+            raise ValueError("Already connected to the device")
+        self._unsub = await self._mqtt_channel.subscribe(self._on_mqtt_message)
+
+    async def close(self) -> None:
+        """Close the MQTT connection to the device.
+
+        This method will unsubscribe from the MQTT channel and clean up resources.
+        """
+        if self._unsub:
+            self._unsub()
+            self._unsub = None
+
+    def _on_mqtt_message(self, message: RoborockMessage) -> None:
+        """Handle incoming MQTT messages from the device.
+
+        This method should be overridden in subclasses to handle specific device messages.
+        """
+        _LOGGER.debug("Received message from device %s: %s", self.duid, message)

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/devices/device_manager.py

@@ -1,5 +1,6 @@
 """Module for discovering Roborock devices."""
 
+import asyncio
 import logging
 from collections.abc import Awaitable, Callable
 
@@ -10,8 +11,13 @@ from roborock.containers import (
     UserData,
 )
 from roborock.devices.device import RoborockDevice
+from roborock.mqtt.roborock_session import create_mqtt_session
+from roborock.mqtt.session import MqttSession
+from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient
 
+from .mqtt_channel import MqttChannel
+
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
@@ -34,11 +40,16 @@ class DeviceManager:
         self,
         home_data_api: HomeDataApi,
         device_creator: DeviceCreator,
+        mqtt_session: MqttSession,
     ) -> None:
-        """Initialize the DeviceManager with user data and optional cache storage."""
+        """Initialize the DeviceManager with user data and optional cache storage.
+
+        This takes ownership of the MQTT session and will close it when the manager is closed.
+        """
         self._home_data_api = home_data_api
         self._device_creator = device_creator
         self._devices: dict[str, RoborockDevice] = {}
+        self._mqtt_session = mqtt_session
 
     async def discover_devices(self) -> list[RoborockDevice]:
         """Discover all devices for the logged-in user."""
@@ -46,9 +57,16 @@ class DeviceManager:
         device_products = home_data.device_products
         _LOGGER.debug("Discovered %d devices %s", len(device_products), home_data)
 
-        self._devices = {
-            duid: self._device_creator(device, product) for duid, (device, product) in device_products.items()
-        }
+        # These are connected serially to avoid overwhelming the MQTT broker
+        new_devices = {}
+        for duid, (device, product) in device_products.items():
+            if duid in self._devices:
+                continue
+            new_device = self._device_creator(device, product)
+            await new_device.connect()
+            new_devices[duid] = new_device
+
+        self._devices.update(new_devices)
         return list(self._devices.values())
 
     async def get_device(self, duid: str) -> RoborockDevice | None:
@@ -59,6 +77,13 @@ class DeviceManager:
         """Get all discovered devices."""
         return list(self._devices.values())
 
+    async def close(self) -> None:
+        """Close all MQTT connections and clean up resources."""
+        tasks = [device.close() for device in self._devices.values()]
+        self._devices.clear()
+        tasks.append(self._mqtt_session.close())
+        await asyncio.gather(*tasks)
+
 
 def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
     """Create a home data API wrapper.
@@ -67,7 +92,9 @@ def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
     home data for the user.
     """
 
-    client = RoborockApiClient(email, user_data)
+    # Note: This will auto discover the API base URL. This can be improved
+    # by caching this next to `UserData` if needed to avoid unnecessary API calls.
+    client = RoborockApiClient(email)
 
     async def home_data_api() -> HomeData:
         return await client.get_home_data(user_data)
@@ -83,9 +110,13 @@ async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi)
     include caching or other optimizations.
     """
 
+    mqtt_params = create_mqtt_params(user_data.rriot)
+    mqtt_session = await create_mqtt_session(mqtt_params)
+
     def device_creator(device: HomeDataDevice, product: HomeDataProduct) -> RoborockDevice:
-        return RoborockDevice(user_data, device, product)
+        mqtt_channel = MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)
+        return RoborockDevice(user_data, device, product, mqtt_channel)
 
-    manager = DeviceManager(home_data_api, device_creator)
+    manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session)
     await manager.discover_devices()
     return manager

python_roborock-2.25.0/roborock/devices/local_channel.py

@@ -0,0 +1,146 @@
+"""Module for communicating with Roborock devices over a local network."""
+
+import asyncio
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from json import JSONDecodeError
+
+from roborock.exceptions import RoborockConnectionException, RoborockException
+from roborock.protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
+from roborock.roborock_message import RoborockMessage
+
+_LOGGER = logging.getLogger(__name__)
+_PORT = 58867
+
+
+@dataclass
+class _LocalProtocol(asyncio.Protocol):
+    """Callbacks for the Roborock local client transport."""
+
+    messages_cb: Callable[[bytes], None]
+    connection_lost_cb: Callable[[Exception | None], None]
+
+    def data_received(self, data: bytes) -> None:
+        """Called when data is received from the transport."""
+        self.messages_cb(data)
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        """Called when the transport connection is lost."""
+        self.connection_lost_cb(exc)
+
+
+class LocalChannel:
+    """Simple RPC-style channel for communicating with a device over a local network.
+
+    Handles request/response correlation and timeouts, but leaves message
+    format most parsing to higher-level components.
+    """
+
+    def __init__(self, host: str, local_key: str):
+        self._host = host
+        self._transport: asyncio.Transport | None = None
+        self._protocol: _LocalProtocol | None = None
+        self._subscribers: list[Callable[[RoborockMessage], None]] = []
+        self._is_connected = False
+
+        # RPC support
+        self._waiting_queue: dict[int, asyncio.Future[RoborockMessage]] = {}
+        self._decoder: Decoder = create_local_decoder(local_key)
+        self._encoder: Encoder = create_local_encoder(local_key)
+        self._queue_lock = asyncio.Lock()
+
+    async def connect(self) -> None:
+        """Connect to the device."""
+        if self._is_connected:
+            _LOGGER.warning("Already connected")
+            return
+        _LOGGER.debug("Connecting to %s:%s", self._host, _PORT)
+        loop = asyncio.get_running_loop()
+        protocol = _LocalProtocol(self._data_received, self._connection_lost)
+        try:
+            self._transport, self._protocol = await loop.create_connection(lambda: protocol, self._host, _PORT)
+            self._is_connected = True
+        except OSError as e:
+            raise RoborockConnectionException(f"Failed to connect to {self._host}:{_PORT}") from e
+
+    async def close(self) -> None:
+        """Disconnect from the device."""
+        if self._transport:
+            self._transport.close()
+        else:
+            _LOGGER.warning("Close called but transport is already None")
+        self._transport = None
+        self._is_connected = False
+
+    def _data_received(self, data: bytes) -> None:
+        """Handle incoming data from the transport."""
+        if not (messages := self._decoder(data)):
+            _LOGGER.warning("Failed to decode local message: %s", data)
+            return
+        for message in messages:
+            _LOGGER.debug("Received message: %s", message)
+            asyncio.create_task(self._resolve_future_with_lock(message))
+            for callback in self._subscribers:
+                try:
+                    callback(message)
+                except Exception as e:
+                    _LOGGER.exception("Uncaught error in message handler callback: %s", e)
+
+    def _connection_lost(self, exc: Exception | None) -> None:
+        """Handle connection loss."""
+        _LOGGER.warning("Connection lost to %s", self._host, exc_info=exc)
+        self._transport = None
+        self._is_connected = False
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        """Subscribe to all messages from the device."""
+        self._subscribers.append(callback)
+
+        def unsubscribe() -> None:
+            self._subscribers.remove(callback)
+
+        return unsubscribe
+
+    async def _resolve_future_with_lock(self, message: RoborockMessage) -> None:
+        """Resolve waiting future with proper locking."""
+        if (request_id := message.get_request_id()) is None:
+            _LOGGER.debug("Received message with no request_id")
+            return
+        async with self._queue_lock:
+            if (future := self._waiting_queue.pop(request_id, None)) is not None:
+                future.set_result(message)
+            else:
+                _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
+
+    async def send_command(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
+        """Send a command message and wait for the response message."""
+        if not self._transport or not self._is_connected:
+            raise RoborockConnectionException("Not connected to device")
+
+        try:
+            if (request_id := message.get_request_id()) is None:
+                raise RoborockException("Message must have a request_id for RPC calls")
+        except (ValueError, JSONDecodeError) as err:
+            _LOGGER.exception("Error getting request_id from message: %s", err)
+            raise RoborockException(f"Invalid message format, Message must have a request_id: {err}") from err
+
+        future: asyncio.Future[RoborockMessage] = asyncio.Future()
+        async with self._queue_lock:
+            if request_id in self._waiting_queue:
+                raise RoborockException(f"Request ID {request_id} already pending, cannot send command")
+            self._waiting_queue[request_id] = future
+
+        try:
+            encoded_msg = self._encoder(message)
+            self._transport.write(encoded_msg)
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError as ex:
+            async with self._queue_lock:
+                self._waiting_queue.pop(request_id, None)
+            raise RoborockException(f"Command timed out after {timeout}s") from ex
+        except Exception:
+            logging.exception("Uncaught error sending command")
+            async with self._queue_lock:
+                self._waiting_queue.pop(request_id, None)
+            raise

python_roborock-2.25.0/roborock/devices/mqtt_channel.py

@@ -0,0 +1,115 @@
+"""Modules for communicating with specific Roborock devices over MQTT."""
+
+import asyncio
+import logging
+from collections.abc import Callable
+from json import JSONDecodeError
+
+from roborock.containers import RRiot
+from roborock.exceptions import RoborockException
+from roborock.mqtt.session import MqttParams, MqttSession
+from roborock.protocol import create_mqtt_decoder, create_mqtt_encoder
+from roborock.roborock_message import RoborockMessage
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MqttChannel:
+    """Simple RPC-style channel for communicating with a device over MQTT.
+
+    Handles request/response correlation and timeouts, but leaves message
+    format most parsing to higher-level components.
+    """
+
+    def __init__(self, mqtt_session: MqttSession, duid: str, local_key: str, rriot: RRiot, mqtt_params: MqttParams):
+        self._mqtt_session = mqtt_session
+        self._duid = duid
+        self._local_key = local_key
+        self._rriot = rriot
+        self._mqtt_params = mqtt_params
+
+        # RPC support
+        self._waiting_queue: dict[int, asyncio.Future[RoborockMessage]] = {}
+        self._decoder = create_mqtt_decoder(local_key)
+        self._encoder = create_mqtt_encoder(local_key)
+        self._queue_lock = asyncio.Lock()
+
+    @property
+    def _publish_topic(self) -> str:
+        """Topic to send commands to the device."""
+        return f"rr/m/i/{self._rriot.u}/{self._mqtt_params.username}/{self._duid}"
+
+    @property
+    def _subscribe_topic(self) -> str:
+        """Topic to receive responses from the device."""
+        return f"rr/m/o/{self._rriot.u}/{self._mqtt_params.username}/{self._duid}"
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        """Subscribe to the device's response topic.
+
+        The callback will be called with the message payload when a message is received.
+
+        All messages received will be processed through the provided callback, even
+        those sent in response to the `send_command` command.
+
+        Returns a callable that can be used to unsubscribe from the topic.
+        """
+
+        def message_handler(payload: bytes) -> None:
+            if not (messages := self._decoder(payload)):
+                _LOGGER.warning("Failed to decode MQTT message: %s", payload)
+                return
+            for message in messages:
+                _LOGGER.debug("Received message: %s", message)
+                asyncio.create_task(self._resolve_future_with_lock(message))
+                try:
+                    callback(message)
+                except Exception as e:
+                    _LOGGER.exception("Uncaught error in message handler callback: %s", e)
+
+        return await self._mqtt_session.subscribe(self._subscribe_topic, message_handler)
+
+    async def _resolve_future_with_lock(self, message: RoborockMessage) -> None:
+        """Resolve waiting future with proper locking."""
+        if (request_id := message.get_request_id()) is None:
+            _LOGGER.debug("Received message with no request_id")
+            return
+        async with self._queue_lock:
+            if (future := self._waiting_queue.pop(request_id, None)) is not None:
+                future.set_result(message)
+            else:
+                _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
+
+    async def send_command(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
+        """Send a command message and wait for the response message.
+
+        Returns the raw response message - caller is responsible for parsing.
+        """
+        try:
+            if (request_id := message.get_request_id()) is None:
+                raise RoborockException("Message must have a request_id for RPC calls")
+        except (ValueError, JSONDecodeError) as err:
+            _LOGGER.exception("Error getting request_id from message: %s", err)
+            raise RoborockException(f"Invalid message format, Message must have a request_id: {err}") from err
+
+        future: asyncio.Future[RoborockMessage] = asyncio.Future()
+        async with self._queue_lock:
+            if request_id in self._waiting_queue:
+                raise RoborockException(f"Request ID {request_id} already pending, cannot send command")
+            self._waiting_queue[request_id] = future
+
+        try:
+            encoded_msg = self._encoder(message)
+            await self._mqtt_session.publish(self._publish_topic, encoded_msg)
+
+            return await asyncio.wait_for(future, timeout=timeout)
+
+        except asyncio.TimeoutError as ex:
+            async with self._queue_lock:
+                self._waiting_queue.pop(request_id, None)
+            raise RoborockException(f"Command timed out after {timeout}s") from ex
+        except Exception:
+            logging.exception("Uncaught error sending command")
+            async with self._queue_lock:
+                self._waiting_queue.pop(request_id, None)
+            raise

python_roborock-2.25.0/roborock/protocols/v1_protocol.py

@@ -0,0 +1,91 @@
+"""Roborock V1 Protocol Encoder."""
+
+from __future__ import annotations
+
+import json
+import math
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from roborock.roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from roborock.roborock_typing import RoborockCommand
+from roborock.util import get_next_int
+
+CommandType = RoborockCommand | str
+ParamsType = list | dict | int | None
+
+
+@dataclass(frozen=True, kw_only=True)
+class SecurityData:
+    """Security data included in the request for some V1 commands."""
+
+    endpoint: str
+    nonce: bytes
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert security data to a dictionary for sending in the payload."""
+        return {"security": {"endpoint": self.endpoint, "nonce": self.nonce.hex().lower()}}
+
+
+@dataclass
+class RequestMessage:
+    """Data structure for v1 RoborockMessage payloads."""
+
+    method: RoborockCommand | str
+    params: ParamsType
+    timestamp: int = field(default_factory=lambda: math.floor(time.time()))
+    request_id: int = field(default_factory=lambda: get_next_int(10000, 32767))
+
+    def as_payload(self, security_data: SecurityData | None) -> bytes:
+        """Convert the request arguments to a dictionary."""
+        inner = {
+            "id": self.request_id,
+            "method": self.method,
+            "params": self.params or [],
+            **(security_data.to_dict() if security_data else {}),
+        }
+        return bytes(
+            json.dumps(
+                {
+                    "dps": {"101": json.dumps(inner, separators=(",", ":"))},
+                    "t": self.timestamp,
+                },
+                separators=(",", ":"),
+            ).encode()
+        )
+
+
+def create_mqtt_payload_encoder(security_data: SecurityData) -> Callable[[CommandType, ParamsType], RoborockMessage]:
+    """Create a payload encoder for V1 commands over MQTT."""
+
+    def _get_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
+        """Build the payload for a V1 command."""
+        request = RequestMessage(method=method, params=params)
+        payload = request.as_payload(security_data)  # always secure
+        return RoborockMessage(
+            timestamp=request.timestamp,
+            protocol=RoborockMessageProtocol.RPC_REQUEST,
+            payload=payload,
+        )
+
+    return _get_payload
+
+
+def encode_local_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
+    """Encode payload for V1 commands over local connection."""
+
+    request = RequestMessage(method=method, params=params)
+    payload = request.as_payload(security_data=None)
+
+    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 RoborockMessage(
+        timestamp=request.timestamp,
+        protocol=RoborockMessageProtocol.GENERAL_REQUEST,
+        payload=payload,
+        message_retry=message_retry,
+    )

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/version_1_apis/roborock_client_v1.py

@@ -1,7 +1,6 @@
 import asyncio
 import dataclasses
 import json
-import math
 import struct
 import time
 from abc import ABC, abstractmethod
@@ -54,15 +53,15 @@ from roborock.roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
 )
-from roborock.util import RepeatableTask, get_next_int, unpack_list
+from roborock.util import RepeatableTask, unpack_list
+
+CUSTOM_COMMANDS = {RoborockCommand.GET_MAP_CALIBRATION}
 
 COMMANDS_SECURED = {
     RoborockCommand.GET_MAP_V1,
     RoborockCommand.GET_MULTI_MAP,
 }
 
-CUSTOM_COMMANDS = {RoborockCommand.GET_MAP_CALIBRATION}
-
 CLOUD_REQUIRED = COMMANDS_SECURED.union(CUSTOM_COMMANDS)
 
 WASH_N_FILL_DOCK = [
@@ -340,35 +339,6 @@ class RoborockClientV1(RoborockClient, ABC):
         """Load the map into the vacuum's memory."""
         await self.send_command(RoborockCommand.LOAD_MULTI_MAP, [map_flag])
 
-    def _get_payload(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-        secured=False,
-    ):
-        timestamp = math.floor(time.time())
-        request_id = get_next_int(10000, 32767)
-        inner = {
-            "id": request_id,
-            "method": method,
-            "params": params or [],
-        }
-        if secured:
-            inner["security"] = {
-                "endpoint": self._endpoint,
-                "nonce": self._nonce.hex().lower(),
-            }
-        payload = bytes(
-            json.dumps(
-                {
-                    "dps": {"101": json.dumps(inner, separators=(",", ":"))},
-                    "t": timestamp,
-                },
-                separators=(",", ":"),
-            ).encode()
-        )
-        return request_id, timestamp, payload
-
     @abstractmethod
     async def _send_command(
         self,

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -4,9 +4,10 @@ from roborock.local_api import RoborockLocalClient
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
-from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from ..protocols.v1_protocol import encode_local_payload
+from ..roborock_message import RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter
-from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
+from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,26 +22,16 @@ class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
 
-    def build_roborock_message(
-        self, method: RoborockCommand | str, params: list | dict | int | None = None
-    ) -> RoborockMessage:
-        secured = True if method in COMMANDS_SECURED else False
-        request_id, timestamp, payload = self._get_payload(method, params, secured)
-        self._logger.debug("Building message id %s for method %s", request_id, method)
-        request_protocol = RoborockMessageProtocol.GENERAL_REQUEST
-        message_retry: MessageRetry | None = None
-        if method == RoborockCommand.RETRY_REQUEST and isinstance(params, dict):
-            message_retry = MessageRetry(method=params["method"], retry_id=params["retry_id"])
-        return RoborockMessage(
-            timestamp=timestamp, protocol=request_protocol, payload=payload, message_retry=message_retry
-        )
-
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        roborock_message = self.build_roborock_message(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)
 
     async def send_message(self, roborock_message: RoborockMessage):

{python_roborock-2.23.0 → python_roborock-2.25.0}/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -11,6 +11,7 @@ from roborock.cloud_api import RoborockMqttClient
 from ..containers import DeviceData, UserData
 from ..exceptions import CommandVacuumError, RoborockException, VacuumError
 from ..protocol import Utils
+from ..protocols.v1_protocol import SecurityData, create_mqtt_payload_encoder
 from ..roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
@@ -36,6 +37,9 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         RoborockClientV1.__init__(self, device_info, endpoint)
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
+        self._payload_encoder = create_mqtt_payload_encoder(
+            SecurityData(endpoint=self._endpoint, nonce=self._nonce),
+        )
 
     async def send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()
@@ -78,10 +82,9 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         if method in CUSTOM_COMMANDS:
             # When we have more custom commands do something more complicated here
             return await self._get_calibration_points()
-        request_id, timestamp, payload = self._get_payload(method, params, True)
-        self._logger.debug("Building message id %s for method %s", request_id, method)
-        request_protocol = RoborockMessageProtocol.RPC_REQUEST
-        roborock_message = RoborockMessage(timestamp=timestamp, protocol=request_protocol, payload=payload)
+
+        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):