feat: add l01 to the new device format

Author: Lash-L

roborock/data/v1/v1_containers.py

@@ -578,7 +578,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

roborock/devices/local_channel.py

@@ -7,13 +7,16 @@
 
 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 = 10.0
 
 
 @dataclass
@@ -39,18 +42,83 @@ class LocalChannel(Channel):
     format most parsing to higher-level components.
     """
 
-    def __init__(self, host: str, local_key: str):
+    def __init__(self, host: str, local_key: str, local_protocol_version: LocalProtocolVersion | None = None):
         self._host = host
         self._transport: asyncio.Transport | None = None
         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_key = local_key
+        self._local_protocol_version = local_protocol_version
+        self._connect_nonce = get_next_int(10000, 32767)
+        self._ack_nonce: int | None = None
+        self._update_encoder_decoder()
+
+    def _update_encoder_decoder(self):
+        self._encoder = create_local_encoder(
+            local_key=self._local_key, connect_nonce=self._connect_nonce, ack_nonce=self._ack_nonce
+        )
+        self._decoder = create_local_decoder(
+            local_key=self._local_key, connect_nonce=self._connect_nonce, ack_nonce=self._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) -> bool:
+        """Perform the initial handshaking."""
+        _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._connect_nonce,
+            seq=1,
+        )
+        try:
+            response = await self.send_message(
+                roborock_message=request,
+                request_id=request.seq,
+                response_protocol=RoborockMessageProtocol.HELLO_RESPONSE,
+            )
+            self._ack_nonce = response.random
+            self._local_protocol_version = local_protocol_version
+            self._update_encoder_decoder()
+
+            _LOGGER.debug(
+                "Client %s speaks the %s protocol.",
+                self._host,
+                local_protocol_version,
+            )
+            return True
+        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 False
+
+    async def hello(self):
+        """Send hello to the device to negotiate protocol."""
+        if self._local_protocol_version:
+            # version is forced - try it first, if it fails, try the opposite
+            if not await self._do_hello(self._local_protocol_version):
+                if not await self._do_hello(
+                    LocalProtocolVersion.V1
+                    if self._local_protocol_version is not LocalProtocolVersion.V1
+                    else LocalProtocolVersion.L01
+                ):
+                    raise RoborockException("Failed to connect to device with any known protocol")
+        else:
+            # try 1.0, then L01
+            if not await self._do_hello(LocalProtocolVersion.V1):
+                if not await self._do_hello(LocalProtocolVersion.L01):
+                    raise RoborockException("Failed to connect to device with any known protocol")
+
     @property
     def is_connected(self) -> bool:
         """Check if the channel is currently connected."""
@@ -113,6 +181,29 @@ async def publish(self, message: RoborockMessage) -> None:
             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.
 #

roborock/devices/v1_channel.py

@@ -212,6 +212,7 @@ async def _local_connect(self, *, use_cache: bool = True) -> None:
             raise RoborockException(f"Error connecting to local device {self._device_uid}: {e}") from e
         # Wire up the new channel
         self._local_channel = local_channel
+        await self._local_channel.hello()
         self._local_rpc_channel = create_local_rpc_channel(self._local_channel)
         self._local_unsub = await self._local_channel.subscribe(self._on_local_message)
         _LOGGER.info("Successfully connected to local device %s", self._device_uid)

roborock/mqtt/roborock_session.py

@@ -106,6 +106,7 @@ async def _run_task(self, start_future: asyncio.Future[None] | None) -> None:
                     # 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

roborock/protocols/v1_protocol.py

@@ -11,6 +11,7 @@
 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 @@
 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."""

roborock/version_1_apis/roborock_local_client_v1.py

@@ -3,27 +3,19 @@
 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
 
 _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."""