Merge branch 'main' into session-device-manager

Author: allenporter

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.19.0"
+version = "2.20.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

pyproject.toml

@@ -85,7 +85,7 @@ def should_keepalive(self) -> bool:
 
     async def validate_connection(self) -> None:
         if not self.should_keepalive():
-            self._logger.info("Resetting Roborock connection due to kepalive timeout")
+            self._logger.info("Resetting Roborock connection due to keepalive timeout")
             await self.async_disconnect()
         await self.async_connect()
 

roborock/api.py

@@ -13,7 +13,7 @@
 from .api import KEEPALIVE, RoborockClient
 from .containers import DeviceData, UserData
 from .exceptions import RoborockException, VacuumError
-from .protocol import MessageParser, md5hex
+from .protocol import Decoder, Encoder, create_mqtt_decoder, create_mqtt_encoder, md5hex
 from .roborock_future import RoborockFuture
 
 _LOGGER = logging.getLogger(__name__)
@@ -74,6 +74,8 @@ def __init__(self, user_data: UserData, device_info: DeviceData) -> None:
         self._mqtt_client.username_pw_set(self._hashed_user, self._hashed_password)
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._mutex = Lock()
+        self._decoder: Decoder = create_mqtt_decoder(device_info.device.local_key)
+        self._encoder: Encoder = create_mqtt_encoder(device_info.device.local_key)
 
     def _mqtt_on_connect(self, *args, **kwargs):
         _, __, ___, rc, ____ = args
@@ -102,7 +104,7 @@ def _mqtt_on_connect(self, *args, **kwargs):
     def _mqtt_on_message(self, *args, **kwargs):
         client, __, msg = args
         try:
-            messages, _ = MessageParser.parse(msg.payload, local_key=self.device_info.device.local_key)
+            messages = self._decoder(msg.payload)
             super().on_message_received(messages)
         except Exception as ex:
             self._logger.exception(ex)

roborock/cloud_api.py

@@ -267,6 +267,17 @@ class RoborockFanSpeedQRevoCurv(RoborockFanPowerCode):
     smart_mode = 110
 
 
+class RoborockFanSpeedQRevoMaxV(RoborockFanPowerCode):
+    off = 105
+    quiet = 101
+    balanced = 102
+    turbo = 103
+    max = 104
+    custom = 106
+    max_plus = 108
+    smart_mode = 110
+
+
 class RoborockFanSpeedP10(RoborockFanPowerCode):
     off = 105
     quiet = 101
@@ -275,6 +286,7 @@ class RoborockFanSpeedP10(RoborockFanPowerCode):
     max = 104
     custom = 106
     max_plus = 108
+    smart_mode = 110
 
 
 class RoborockFanSpeedS8MaxVUltra(RoborockFanPowerCode):
@@ -316,6 +328,7 @@ class RoborockMopModeS8ProUltra(RoborockMopModeCode):
     deep_plus = 303
     fast = 304
     custom = 302
+    smart_mode = 306
 
 
 class RoborockMopModeS8MaxVUltra(RoborockMopModeCode):
@@ -337,6 +350,15 @@ class RoborockMopModeQRevoMaster(RoborockMopModeCode):
     smart_mode = 306
 
 
+class RoborockMopModeQRevoMaxV(RoborockMopModeCode):
+    standard = 300
+    deep = 301
+    custom = 302
+    deep_plus = 303
+    fast = 304
+    smart_mode = 306
+
+
 class RoborockMopIntensityCode(RoborockEnum):
     """Describes the mop intensity of the vacuum cleaner."""
 
@@ -383,6 +405,16 @@ class RoborockMopIntensityQRevoCurv(RoborockMopIntensityCode):
     smart_mode = 209
 
 
+class RoborockMopIntensityQRevoMaxV(RoborockMopIntensityCode):
+    off = 200
+    low = 201
+    medium = 202
+    high = 203
+    custom = 204
+    custom_water_flow = 207
+    smart_mode = 209
+
+
 class RoborockMopIntensityP10(RoborockMopIntensityCode):
     """Describes the mop intensity of the vacuum cleaner."""
 
@@ -392,6 +424,7 @@ class RoborockMopIntensityP10(RoborockMopIntensityCode):
     high = 203
     custom = 204
     custom_water_flow = 207
+    smart_mode = 209
 
 
 class RoborockMopIntensityS8MaxVUltra(RoborockMopIntensityCode):

roborock/code_mappings.py

@@ -23,6 +23,7 @@
     RoborockFanSpeedQ7Max,
     RoborockFanSpeedQRevoCurv,
     RoborockFanSpeedQRevoMaster,
+    RoborockFanSpeedQRevoMaxV,
     RoborockFanSpeedS6Pure,
     RoborockFanSpeedS7,
     RoborockFanSpeedS7MaxV,
@@ -34,13 +35,15 @@
     RoborockMopIntensityQ7Max,
     RoborockMopIntensityQRevoCurv,
     RoborockMopIntensityQRevoMaster,
+    RoborockMopIntensityQRevoMaxV,
     RoborockMopIntensityS5Max,
     RoborockMopIntensityS6MaxV,
     RoborockMopIntensityS7,
     RoborockMopIntensityS8MaxVUltra,
     RoborockMopModeCode,
     RoborockMopModeQRevoCurv,
     RoborockMopModeQRevoMaster,
+    RoborockMopModeQRevoMaxV,
     RoborockMopModeS7,
     RoborockMopModeS8MaxVUltra,
     RoborockMopModeS8ProUltra,
@@ -615,6 +618,13 @@ class QRevoCurvStatus(Status):
     mop_mode: RoborockMopModeQRevoCurv | None = None
 
 
+@dataclass
+class QRevoMaxVStatus(Status):
+    fan_power: RoborockFanSpeedQRevoMaxV | None = None
+    water_box_mode: RoborockMopIntensityQRevoMaxV | None = None
+    mop_mode: RoborockMopModeQRevoMaxV | None = None
+
+
 @dataclass
 class S6MaxVStatus(Status):
     fan_power: RoborockFanSpeedS7MaxV | None = None
@@ -688,7 +698,7 @@ class S8MaxvUltraStatus(Status):
     # but i am currently unable to do my typical reverse engineering/ get any data from users on this,
     # so this will be here in the mean time.
     ROBOROCK_QREVO_S: P10Status,
-    ROBOROCK_QREVO_MAXV: P10Status,
+    ROBOROCK_QREVO_MAXV: QRevoMaxVStatus,
     ROBOROCK_QREVO_PRO: P10Status,
     ROBOROCK_S8_MAXV_ULTRA: S8MaxvUltraStatus,
 }

roborock/containers.py

@@ -12,7 +12,7 @@
 from . import DeviceData
 from .api import RoborockClient
 from .exceptions import RoborockConnectionException, RoborockException
-from .protocol import MessageParser
+from .protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
 from .roborock_message import RoborockMessage, RoborockMessageProtocol
 
 _LOGGER = logging.getLogger(__name__)
@@ -44,20 +44,18 @@ def __init__(self, device_data: DeviceData):
         self.host = device_data.host
         self._batch_structs: list[RoborockMessage] = []
         self._executing = False
-        self.remaining = b""
         self.transport: Transport | None = None
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = None
         RoborockClient.__init__(self, device_data)
         self._local_protocol = _LocalProtocol(self._data_received, self._connection_lost)
+        self._encoder: Encoder = create_local_encoder(device_data.device.local_key)
+        self._decoder: Decoder = create_local_decoder(device_data.device.local_key)
 
     def _data_received(self, message):
         """Called when data is received from the transport."""
-        if self.remaining:
-            message = self.remaining + message
-            self.remaining = b""
-        parser_msg, self.remaining = MessageParser.parse(message, local_key=self.device_info.device.local_key)
-        self.on_message_received(parser_msg)
+        parsed_msg = self._decoder(message)
+        self.on_message_received(parsed_msg)
 
     def _connection_lost(self, exc: Exception | None):
         """Called when the transport connection is lost."""

roborock/local_api.py

@@ -118,7 +118,7 @@ async def _run_task(self, start_future: asyncio.Future[None] | None) -> None:
                 if start_future:
                     _LOGGER.debug("MQTT loop was cancelled")
                     start_future.set_exception(err)
-                _LOGGER.debug("MQTT loop was cancelled whiel starting")
+                _LOGGER.debug("MQTT loop was cancelled while starting")
                 return
             # Catch exceptions to avoid crashing the loop
             # and to allow the loop to retry.
@@ -160,7 +160,7 @@ async def _mqtt_client(self, params: MqttParams) -> aiomqtt.Client:
                 async with self._client_lock:
                     self._client = client
                     for topic in self._listeners:
-                        _LOGGER.debug("Re-establising subscription to topic %s", topic)
+                        _LOGGER.debug("Re-establishing subscription to topic %s", topic)
                         # TODO: If this fails it will break the whole connection. Make
                         # this retry again in the background with backoff.
                         await client.subscribe(topic)

roborock/mqtt/roborock_session.py

@@ -359,3 +359,56 @@ def build(
 
 MessageParser: _Parser = _Parser(_Messages, True)
 BroadcastParser: _Parser = _Parser(_BroadcastMessage, False)
+
+
+Decoder = Callable[[bytes], list[RoborockMessage]]
+Encoder = Callable[[RoborockMessage], bytes]
+
+
+def create_mqtt_decoder(local_key: str) -> Decoder:
+    """Create a decoder for MQTT messages."""
+
+    def decode(data: bytes) -> list[RoborockMessage]:
+        """Parse the given data into Roborock messages."""
+        messages, _ = MessageParser.parse(data, local_key)
+        return messages
+
+    return decode
+
+
+def create_mqtt_encoder(local_key: str) -> Encoder:
+    """Create an encoder for MQTT messages."""
+
+    def encode(messages: RoborockMessage) -> bytes:
+        """Build the given Roborock messages into a byte string."""
+        return MessageParser.build(messages, local_key, prefixed=False)
+
+    return encode
+
+
+def create_local_decoder(local_key: str) -> Decoder:
+    """Create a decoder for local API messages."""
+
+    # This buffer is used to accumulate bytes until a complete message can be parsed.
+    # It is defined outside the decode function to maintain state across calls.
+    buffer: bytes = b""
+
+    def decode(bytes: bytes) -> list[RoborockMessage]:
+        """Parse the given data into Roborock messages."""
+        nonlocal buffer
+        buffer += bytes
+        parsed_messages, remaining = MessageParser.parse(buffer, local_key=local_key)
+        buffer = remaining
+        return parsed_messages
+
+    return decode
+
+
+def create_local_encoder(local_key: str) -> Encoder:
+    """Create an encoder for local API messages."""
+
+    def encode(message: RoborockMessage) -> bytes:
+        """Called when data is sent to the transport."""
+        return MessageParser.build(message, local_key=local_key)
+
+    return encode

roborock/protocol.py

@@ -4,7 +4,6 @@
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
-from ..protocol import MessageParser
 from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter
 from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
@@ -57,8 +56,7 @@ async def send_message(self, roborock_message: RoborockMessage):
             response_protocol = RoborockMessageProtocol.GENERAL_REQUEST
         if request_id is None:
             raise RoborockException(f"Failed build message {roborock_message}")
-        local_key = self.device_info.device.local_key
-        msg = MessageParser.build(roborock_message, local_key=local_key)
+        msg = self._encoder(roborock_message)
         if method:
             self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
         # Send the command to the Roborock device