python-roborock 3.2.0__tar.gz → 3.3.0__tar.gz

{python_roborock-3.2.0 → python_roborock-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.2.0
+Version: 3.3.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-3.2.0 → python_roborock-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.2.0"
+version = "3.3.0"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-3.2.0 → python_roborock-3.3.0}/roborock/data/v1/v1_containers.py

@@ -584,7 +584,7 @@ class AppInitStatus(RoborockBase):
     new_feature_info_str: str
     new_feature_info_2: int | None = None
     carriage_type: int | None = None
-    dsp_version: int | None = None
+    dsp_version: str | None = None
 
 
 @dataclass

{python_roborock-3.2.0 → python_roborock-3.3.0}/roborock/devices/local_channel.py

@@ -7,13 +7,25 @@ from dataclasses import dataclass
 
 from roborock.callbacks import CallbackList, decoder_callback
 from roborock.exceptions import RoborockConnectionException, RoborockException
-from roborock.protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
-from roborock.roborock_message import RoborockMessage
+from roborock.protocol import create_local_decoder, create_local_encoder
+from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 
+from ..protocols.v1_protocol import LocalProtocolVersion
+from ..util import get_next_int
 from .channel import Channel
 
 _LOGGER = logging.getLogger(__name__)
 _PORT = 58867
+_TIMEOUT = 5.0
+
+
+@dataclass
+class LocalChannelParams:
+    """Parameters for local channel encoder/decoder."""
+
+    local_key: str
+    connect_nonce: int
+    ack_nonce: int | None
 
 
 @dataclass
@@ -45,12 +57,74 @@ class LocalChannel(Channel):
         self._protocol: _LocalProtocol | None = None
         self._subscribers: CallbackList[RoborockMessage] = CallbackList(_LOGGER)
         self._is_connected = False
-
-        self._decoder: Decoder = create_local_decoder(local_key)
-        self._encoder: Encoder = create_local_encoder(local_key)
+        self._local_protocol_version: LocalProtocolVersion | None = None
+        self._update_encoder_decoder(
+            LocalChannelParams(local_key=local_key, connect_nonce=get_next_int(10000, 32767), ack_nonce=None)
+        )
+
+    def _update_encoder_decoder(self, params: LocalChannelParams):
+        self._params = params
+        self._encoder = create_local_encoder(
+            local_key=params.local_key, connect_nonce=params.connect_nonce, ack_nonce=params.ack_nonce
+        )
+        self._decoder = create_local_decoder(
+            local_key=params.local_key, connect_nonce=params.connect_nonce, ack_nonce=params.ack_nonce
+        )
         # Callback to decode messages and dispatch to subscribers
         self._data_received: Callable[[bytes], None] = decoder_callback(self._decoder, self._subscribers, _LOGGER)
 
+    async def _do_hello(self, local_protocol_version: LocalProtocolVersion) -> LocalChannelParams | None:
+        """Perform the initial handshaking and return encoder params if successful."""
+        _LOGGER.debug(
+            "Attempting to use the %s protocol for client %s...",
+            local_protocol_version,
+            self._host,
+        )
+        request = RoborockMessage(
+            protocol=RoborockMessageProtocol.HELLO_REQUEST,
+            version=local_protocol_version.encode(),
+            random=self._params.connect_nonce,
+            seq=1,
+        )
+        try:
+            response = await self._send_message(
+                roborock_message=request,
+                request_id=request.seq,
+                response_protocol=RoborockMessageProtocol.HELLO_RESPONSE,
+            )
+            _LOGGER.debug(
+                "Client %s speaks the %s protocol.",
+                self._host,
+                local_protocol_version,
+            )
+            return LocalChannelParams(
+                local_key=self._params.local_key, connect_nonce=self._params.connect_nonce, ack_nonce=response.random
+            )
+        except RoborockException as e:
+            _LOGGER.debug(
+                "Client %s did not respond or does not speak the %s protocol. %s",
+                self._host,
+                local_protocol_version,
+                e,
+            )
+            return None
+
+    async def _hello(self):
+        """Send hello to the device to negotiate protocol."""
+        attempt_versions = [LocalProtocolVersion.V1, LocalProtocolVersion.L01]
+        if self._local_protocol_version:
+            # Sort to try the preferred version first
+            attempt_versions.sort(key=lambda v: v != self._local_protocol_version)
+
+        for version in attempt_versions:
+            params = await self._do_hello(version)
+            if params is not None:
+                self._local_protocol_version = version
+                self._update_encoder_decoder(params)
+                return
+
+        raise RoborockException("Failed to connect to device with any known protocol")
+
     @property
     def is_connected(self) -> bool:
         """Check if the channel is currently connected."""
@@ -62,7 +136,7 @@ class LocalChannel(Channel):
         return self._is_connected
 
     async def connect(self) -> None:
-        """Connect to the device."""
+        """Connect to the device and negotiate protocol."""
         if self._is_connected:
             _LOGGER.warning("Already connected")
             return
@@ -75,6 +149,14 @@ class LocalChannel(Channel):
         except OSError as e:
             raise RoborockConnectionException(f"Failed to connect to {self._host}:{_PORT}") from e
 
+        # Perform protocol negotiation
+        try:
+            await self._hello()
+        except RoborockException:
+            # If protocol negotiation fails, clean up the connection state
+            self.close()
+            raise
+
     def close(self) -> None:
         """Disconnect from the device."""
         if self._transport:
@@ -113,6 +195,29 @@ class LocalChannel(Channel):
             logging.exception("Uncaught error sending command")
             raise RoborockException(f"Failed to send message: {message}") from err
 
+    async def _send_message(
+        self,
+        roborock_message: RoborockMessage,
+        request_id: int,
+        response_protocol: int,
+    ) -> RoborockMessage:
+        """Send a raw message and wait for a raw response."""
+        future: asyncio.Future[RoborockMessage] = asyncio.Future()
+
+        def find_response(response_message: RoborockMessage) -> None:
+            if response_message.protocol == response_protocol and response_message.seq == request_id:
+                future.set_result(response_message)
+
+        unsub = await self.subscribe(find_response)
+        try:
+            await self.publish(roborock_message)
+            return await asyncio.wait_for(future, timeout=_TIMEOUT)
+        except TimeoutError as ex:
+            future.cancel()
+            raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
+        finally:
+            unsub()
+
 
 # This module provides a factory function to create LocalChannel instances.
 #

{python_roborock-3.2.0 → python_roborock-3.3.0}/roborock/mqtt/roborock_session.py

@@ -106,6 +106,7 @@ class RoborockMqttSession(MqttSession):
                     # Reset backoff once we've successfully connected
                     self._backoff = MIN_BACKOFF_INTERVAL
                     self._healthy = True
+                    _LOGGER.info("MQTT Session connected.")
                     if start_future:
                         start_future.set_result(None)
                         start_future = None

{python_roborock-3.2.0 → python_roborock-3.3.0}/roborock/protocols/v1_protocol.py

@@ -11,6 +11,7 @@ import struct
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
+from enum import StrEnum
 from typing import Any
 
 from roborock.data import RRiot
@@ -32,6 +33,13 @@ CommandType = RoborockCommand | str
 ParamsType = list | dict | int | None
 
 
+class LocalProtocolVersion(StrEnum):
+    """Supported local protocol versions. Different from vacuum protocol versions."""
+
+    L01 = "L01"
+    V1 = "1.0"
+
+
 @dataclass(frozen=True, kw_only=True)
 class SecurityData:
     """Security data included in the request for some V1 commands."""

{python_roborock-3.2.0 → python_roborock-3.3.0}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -3,13 +3,12 @@ import logging
 from asyncio import Lock, TimerHandle, Transport, get_running_loop
 from collections.abc import Callable
 from dataclasses import dataclass
-from enum import StrEnum
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand
 from ..api import RoborockClient
 from ..exceptions import RoborockConnectionException, RoborockException, VacuumError
 from ..protocol import create_local_decoder, create_local_encoder
-from ..protocols.v1_protocol import RequestMessage
+from ..protocols.v1_protocol import LocalProtocolVersion, RequestMessage
 from ..roborock_message import RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter, get_next_int
 from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
@@ -17,13 +16,6 @@ from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
 _LOGGER = logging.getLogger(__name__)
 
 
-class LocalProtocolVersion(StrEnum):
-    """Supported local protocol versions. Different from vacuum protocol versions."""
-
-    L01 = "L01"
-    V1 = "1.0"
-
-
 @dataclass
 class _LocalProtocol(asyncio.Protocol):
     """Callbacks for the Roborock local client transport."""