diff --git a/AGENTS.md b/AGENTS.md index d81bd0a06..474bdfe90 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -54,7 +54,7 @@ Evaluate every change against the repository's three core layers in strict prior ## Detailed Engineering Conventions ### 1. Typing & Data Models -- **Subclass `RoborockBase`**: Define structured domain and wire data models as `@dataclass` subclassing `RoborockBase` (`from_dict`, `as_dict`). Avoid `TypedDict` or loose dicts. (Binary protocol packets, transport message envelopes, and map layers are exempt). +- **Subclass `RoborockBase`**: Define structured domain and wire data models as `@dataclass` subclassing `RoborockBase` (`from_dict`, `as_dict`). Avoid `TypedDict` or loose dicts. (Binary protocol packets, transport message envelopes, and map layers are exempt). The existing frozen `Q10RoborockPoint` coordinate value is also exempt: it must retain immutability and hashability, and Python disallows frozen dataclass inheritance from the non-frozen `RoborockBase`. This exception does not extend to other domain models. - **Enum Fallback Resilience**: All enums representing device status, firmware modes, error codes, and wire protocol integer codes MUST inherit from `RoborockEnum` (defining a lowercase `unknown = -1` or `0` member) or `RoborockModeEnum` (using `from_code_optional()`). Internal enums not decoding unknown firmware codes remain standard `Enum`/`StrEnum`. - **Strongly Type What You Know; Contain `Any` to the Wire**: Public trait APIs, method signatures, properties, and domain models MUST declare concrete types. `Any` is accepted only where the underlying wire protocol is dynamic or polymorphic (Tuya DPS maps, low-level RPC dispatch, serialization helpers, evolving cloud schemas). - **Avoid Forward References & `TYPE_CHECKING`**: Avoid stringified forward references (`"ClassName"`) and `if typing.TYPE_CHECKING:` guards wherever possible. They typically indicate circular dependencies or coupling that should be refactored by extracting shared models. diff --git a/roborock/cli.py b/roborock/cli.py index bb02116b0..db718ee55 100644 --- a/roborock/cli.py +++ b/roborock/cli.py @@ -605,6 +605,7 @@ async def maps(ctx, device_id: str): async def _await_q10_map_push( properties: Q10PropertiesApi, predicate: Callable[[], bool], + revision: Callable[[], int], *, timeout: float = _Q10_MAP_PUSH_TIMEOUT, allow_cached_on_timeout: bool = False, @@ -617,9 +618,10 @@ async def _await_q10_map_push( """ loop = asyncio.get_running_loop() updated: asyncio.Future[None] = loop.create_future() + initial_revision = revision() def on_update() -> None: - if predicate() and not updated.done(): + if revision() > initial_revision and predicate() and not updated.done(): updated.set_result(None) unsub = properties.map.add_update_listener(on_update) @@ -649,6 +651,7 @@ async def map_image(ctx, device_id: str, output_file: str): await _await_q10_map_push( properties, lambda: properties.map.image_content is not None, + lambda: properties.map.map_revision, allow_cached_on_timeout=True, ) image_content = properties.map.image_content @@ -697,8 +700,8 @@ async def map_data(ctx, device_id: str, include_path: bool): async def q10_position(ctx, device_id: str, include_path: bool): """Get the current Q10 robot position and live cleaning path. - The Q10 only streams its position/path while it is actively cleaning, so this - will report that no live trace is available for an idle/docked robot. + The Q10 normally streams position/path while it is actively cleaning, so an + idle device may report that no fresh live trace is available. """ context: RoborockContext = ctx.obj device_manager = await context.get_device_manager() @@ -710,9 +713,10 @@ async def q10_position(ctx, device_id: str, include_path: bool): got_trace = await _await_q10_map_push( properties, lambda: bool(properties.map.path), + lambda: properties.map.trace_revision, ) if not got_trace: - click.echo("No live trace available (the robot only reports position while cleaning).") + click.echo("No fresh live trace available.") return map_trait = properties.map position = map_trait.robot_position @@ -875,6 +879,7 @@ async def rooms(ctx, device_id: str): await _await_q10_map_push( properties, lambda: properties.map.image_content is not None, + lambda: properties.map.map_revision, allow_cached_on_timeout=True, ) click.echo(dump_json({room.id: room.name for room in properties.map.rooms})) diff --git a/roborock/data/b01_q10/b01_q10_containers.py b/roborock/data/b01_q10/b01_q10_containers.py index 8550bd7c6..90b23fbdf 100644 --- a/roborock/data/b01_q10/b01_q10_containers.py +++ b/roborock/data/b01_q10/b01_q10_containers.py @@ -144,7 +144,9 @@ class Q10MapInfo(RoborockBase): """A saved map reported by ``dpMultiMap``. Q10 firmware represents the map identifier as a string on the wire. The - value is sent back unchanged in a subsequent ``{"op": "get"}`` request. + value is sent back unchanged in a subsequent ``{"op": "select"}`` detail + request. On Q10 firmware, ``select`` previews a saved map without applying + it as the active map. """ id: str diff --git a/roborock/devices/device_manager.py b/roborock/devices/device_manager.py index 156e3ac56..2960b2709 100644 --- a/roborock/devices/device_manager.py +++ b/roborock/devices/device_manager.py @@ -19,6 +19,7 @@ from roborock.devices.device import DeviceReadyCallback, RoborockDevice from roborock.diagnostics import Diagnostics, redact_device_data from roborock.exceptions import RoborockException +from roborock.map.b01_q10_map_parser import B01Q10MapParserConfig from roborock.map.map_parser import MapParserConfig from roborock.mqtt.roborock_session import create_lazy_mqtt_session from roborock.mqtt.session import MqttSession, SessionUnauthorizedHook @@ -262,7 +263,12 @@ def device_creator(home_data: HomeData, device: HomeDataDevice, product: HomeDat if "ss" in model_part: b01_q10_channel = create_b01_q10_channel(mqtt_channel) channel = b01_q10_channel - trait = b01.q10.create(channel) + trait = b01.q10.create( + channel, + map_parser_config=( + B01Q10MapParserConfig(map_scale=map_parser_config.map_scale) if map_parser_config else None + ), + ) elif "sc" in model_part: # Q7 devices start with 'sc' in their model naming. b01_q7_channel = create_b01_q7_channel(device, product, mqtt_channel) diff --git a/roborock/devices/traits/b01/q10/__init__.py b/roborock/devices/traits/b01/q10/__init__.py index 5416b7d77..31810de93 100644 --- a/roborock/devices/traits/b01/q10/__init__.py +++ b/roborock/devices/traits/b01/q10/__init__.py @@ -8,7 +8,13 @@ from roborock.data.containers import RoborockBase from roborock.devices.rpc.b01_q10_channel import B01Q10Channel from roborock.devices.traits import Trait -from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket +from roborock.map.b01_q10_map_parser import ( + B01Q10MapParserConfig, + Q10CleanRecordDetail, + Q10MapPacket, + Q10MapPacketKind, + Q10TracePacket, +) from roborock.protocols.b01_q10_protocol import Q10DpsUpdate, Q10Message from .button_light import ButtonLightTrait @@ -92,7 +98,12 @@ class Q10PropertiesApi(Trait): clean_history: CleanHistoryTrait """Trait for fetching the device clean-record history (``dpCleanRecord``).""" - def __init__(self, channel: B01Q10Channel) -> None: + def __init__( + self, + channel: B01Q10Channel, + *, + map_parser_config: B01Q10MapParserConfig, + ) -> None: """Initialize the B01Props API.""" self._channel = channel self.command = CommandTrait(channel) @@ -106,10 +117,17 @@ def __init__(self, channel: B01Q10Channel) -> None: self.network_info = NetworkInfoTrait() self.consumable = ConsumableTrait() self._map_dps = MapDpsTrait() - self.maps = MapsTrait(self.command) - self.map = MapContentTrait(self._map_dps, self.maps, self.command) + self.maps = MapsTrait(self.command, map_parser_config=map_parser_config) + self.map = MapContentTrait( + self._map_dps, + self.command, + map_parser_config=map_parser_config, + ) + self.clean_history = CleanHistoryTrait( + self.command, + map_parser_config=map_parser_config, + ) self.vacuum = VacuumTrait(self.command, self.status, self.map) - self.clean_history = CleanHistoryTrait(self.command) # Read-model traits updated from the device's DPS push stream. self._updatable_traits = [ self.status, @@ -158,7 +176,12 @@ def _handle_message(self, message: Q10Message) -> None: Map-list DPS responses and other DPS updates feed the read-model traits. """ if isinstance(message, Q10MapPacket): - self.map.update_from_map_packet(message) + if message.kind is Q10MapPacketKind.CURRENT: + self.map.update_from_map_packet(message) + elif message.kind is Q10MapPacketKind.SAVED_MAP_DETAIL: + self.maps.update_from_map_packet(message) + elif isinstance(message, Q10CleanRecordDetail): + self.clean_history.update_from_detail(message) elif isinstance(message, Q10TracePacket): self.map.update_from_trace_packet(message) elif isinstance(message, Q10DpsUpdate): @@ -179,6 +202,13 @@ def as_dict(self) -> dict[str, Any]: return result -def create(channel: B01Q10Channel) -> Q10PropertiesApi: +def create( + channel: B01Q10Channel, + *, + map_parser_config: B01Q10MapParserConfig | None = None, +) -> Q10PropertiesApi: """Create traits for B01 devices.""" - return Q10PropertiesApi(channel) + return Q10PropertiesApi( + channel, + map_parser_config=map_parser_config or B01Q10MapParserConfig(), + ) diff --git a/roborock/devices/traits/b01/q10/clean_history.py b/roborock/devices/traits/b01/q10/clean_history.py index fde2bb2fe..53cb8b367 100644 --- a/roborock/devices/traits/b01/q10/clean_history.py +++ b/roborock/devices/traits/b01/q10/clean_history.py @@ -22,6 +22,16 @@ YXStartMethod, ) from roborock.data.b01_q10.b01_q10_containers import Q10CleanRecord +from roborock.exceptions import RoborockException +from roborock.map.b01_q10_map_parser import ( + B01Q10MapParserConfig, + Q10CleanRecordDetail, + Q10HistoricalTracePacket, + Q10MapPacket, + Q10MapPacketKind, + Q10Point, +) +from roborock.map.b01_q10_render import Q10MapOverlays, render_q10_map from .command import CommandTrait from .common import UpdatableTrait @@ -115,12 +125,28 @@ class CleanHistoryTrait(UpdatableTrait): or a single ``op:"notify"`` record) rather than a flat data-point-to-field map. """ - def __init__(self, command: CommandTrait) -> None: + _command: CommandTrait + + def __init__( + self, + command: CommandTrait, + *, + map_parser_config: B01Q10MapParserConfig | None = None, + ) -> None: """Initialize the clean history trait.""" UpdatableTrait.__init__(self, command, _LOGGER) + self._command = command self._converter = CleanRecordConverter() + self._map_parser_config = map_parser_config or B01Q10MapParserConfig() self.records: list[Q10CleanRecord] = [] """Decoded clean records, most recent first.""" + self.detail: Q10CleanRecordDetail | None = None + """Most recently pushed ``03 01`` clean-record map detail.""" + self.detail_record: Q10CleanRecord | None = None + """Record associated with :attr:`detail_packet`, when requested here.""" + self.detail_image_content: bytes | None = None + """Rendered clean-record detail image, if decoding succeeded.""" + self._pending_detail_record: Q10CleanRecord | None = None @property def last_record(self) -> Q10CleanRecord | None: @@ -134,13 +160,52 @@ async def refresh(self) -> None: asynchronously on the device stream and populate :attr:`records` once :meth:`update_from_dps` processes the ``dpCleanRecord`` push. """ - if self._command is None: - raise ValueError("Trait is read-only; no command channel was provided") await self._command.send( B01_Q10_DP.COMMON, params={str(B01_Q10_DP.CLEAN_RECORD.code): {"op": "list"}}, ) + async def refresh_detail(self, record: Q10CleanRecord) -> None: + """Request the saved map and path for one clean record. + + The complete 12-field raw record is the firmware's detail identifier; + the shorter human-facing record ID is not accepted. Only one request + may be outstanding because ``03 01`` responses carry no correlation ID. + """ + if not record.raw or not record.map_len: + raise RoborockException("The Q10 clean record has no saved map detail") + if self._pending_detail_record is not None: + raise RoborockException("A Q10 clean-record detail request is already pending") + self._pending_detail_record = record + try: + await self._command.send( + B01_Q10_DP.COMMON, + params={ + str(B01_Q10_DP.CLEAN_RECORD.code): { + "op": "select", + "id": record.raw, + } + }, + ) + except RoborockException: + self._pending_detail_record = None + raise + + @property + def detail_packet(self) -> Q10MapPacket | None: + """The map from the most recently received clean-record detail.""" + return self.detail.map if self.detail else None + + @property + def detail_trace(self) -> Q10HistoricalTracePacket | None: + """Historical path embedded in the selected clean-record detail.""" + return self.detail.trace if self.detail else None + + @property + def detail_path(self) -> list[Q10Point]: + """Historical path points for the selected clean record.""" + return self.detail_trace.points if self.detail_trace else [] + def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None: """Apply a ``dpCleanRecord`` push (a full list reply or a single notify).""" envelope = decoded_dps.get(B01_Q10_DP.CLEAN_RECORD) @@ -151,6 +216,25 @@ def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None: return self._apply(push) + def update_from_detail(self, detail: Q10CleanRecordDetail) -> None: + """Store and render a pushed clean-record detail map.""" + if detail.map.kind is not Q10MapPacketKind.CLEAN_RECORD_DETAIL: + raise ValueError(f"Expected a Q10 clean-record detail packet, got {detail.map.kind.value}") + self.detail_record = self._pending_detail_record + self._pending_detail_record = None + self.detail = detail + try: + self.detail_image_content = render_q10_map( + detail.map, + detail.trace, + Q10MapOverlays(), + config=self._map_parser_config, + ) + except RoborockException: + _LOGGER.debug("Failed to render Q10 clean-record detail", exc_info=True) + self.detail_image_content = None + self._notify_update() + def _apply(self, push: CleanRecordPush) -> None: """Merge or replace the records from ``push``, then sort newest-first and notify.""" if push.replace: diff --git a/roborock/devices/traits/b01/q10/map.py b/roborock/devices/traits/b01/q10/map.py index a33c2df22..181739b2f 100644 --- a/roborock/devices/traits/b01/q10/map.py +++ b/roborock/devices/traits/b01/q10/map.py @@ -25,6 +25,7 @@ from roborock.map.b01_q10_map_parser import ( B01Q10MapParserConfig, Q10MapPacket, + Q10MapPacketKind, Q10Point, Q10Room, Q10TracePacket, @@ -34,7 +35,6 @@ from .command import CommandTrait from .common import UpdatableTrait -from .maps import MapsTrait _LOGGER = logging.getLogger(__name__) _DOCKED_STATES = {YXDeviceState.CHARGING, YXDeviceState.EMPTYING_THE_BIN} @@ -84,15 +84,13 @@ class MapContentTrait(TraitUpdateListener): """High-level composed Q10 map view. The latest map and trace packets are combined with the injected - :class:`MapDpsTrait` whenever a source changes. The - :class:`MapsTrait` supplies a stored ID only when this trait requests - content. + :class:`MapDpsTrait` whenever a source changes. Current-map acquisition is + independent of the saved-map list. """ def __init__( self, map_dps: MapDpsTrait, - maps: MapsTrait, command: CommandTrait, *, map_parser_config: B01Q10MapParserConfig | None = None, @@ -100,11 +98,12 @@ def __init__( TraitUpdateListener.__init__(self, logger=_LOGGER) self._config = map_parser_config or B01Q10MapParserConfig() self._map_dps = map_dps - self._maps = maps self._command = command self._map_packet: Q10MapPacket | None = None self._trace_packet: Q10TracePacket | None = None self._image_content: bytes | None = None + self._map_revision = 0 + self._trace_revision = 0 self._map_dps.add_update_listener(self._map_dps_updated) async def refresh(self) -> None: @@ -121,6 +120,16 @@ def image_content(self) -> bytes | None: """The composed map PNG, if the latest map rendered successfully.""" return self._image_content + @property + def map_revision(self) -> int: + """Monotonic revision incremented only by current-map packets.""" + return self._map_revision + + @property + def trace_revision(self) -> int: + """Monotonic revision incremented only by live-trace state changes.""" + return self._trace_revision + @property def rooms(self) -> list[Q10Room]: """Rooms reported by the device.""" @@ -150,18 +159,28 @@ def robot_heading(self) -> int | None: def update_from_map_packet(self, packet: Q10MapPacket) -> None: """Store a map-protocol update and render the latest sources.""" + if packet.kind is not Q10MapPacketKind.CURRENT: + raise ValueError(f"Expected a current Q10 map packet, got {packet.kind.value}") self._map_packet = packet + self._map_revision += 1 self._render() self._notify_update() def update_from_trace_packet(self, packet: Q10TracePacket) -> None: """Store a trace-protocol update and render the latest sources.""" - self._trace_packet = packet + self._trace_packet = None if self._map_dps.robot_at_dock else packet + self._trace_revision += 1 self._render() self._notify_update() def _map_dps_updated(self) -> None: """Render after the low-level map DPS source changes.""" + if self._map_dps.robot_at_dock and self._trace_packet is not None: + # A completed cleaning trace is not the current robot position once + # the device is docked. Clear the public live-path state even if the + # firmware does not send its usual zero-point trace. + self._trace_packet = None + self._trace_revision += 1 if self._map_packet is None: return self._render() diff --git a/roborock/devices/traits/b01/q10/maps.py b/roborock/devices/traits/b01/q10/maps.py index d09457764..9683d7119 100644 --- a/roborock/devices/traits/b01/q10/maps.py +++ b/roborock/devices/traits/b01/q10/maps.py @@ -6,8 +6,11 @@ from roborock.data import RoborockBase from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP -from roborock.data.b01_q10.b01_q10_containers import dpMultiMap +from roborock.data.b01_q10.b01_q10_containers import Q10MapInfo, dpMultiMap from roborock.devices.traits.common import DpsDataConverter +from roborock.exceptions import RoborockException +from roborock.map.b01_q10_map_parser import B01Q10MapParserConfig, Q10MapPacket, Q10MapPacketKind +from roborock.map.b01_q10_render import Q10MapOverlays, render_q10_map from .command import CommandTrait from .common import UpdatableTrait @@ -28,6 +31,13 @@ def current_map_id(self) -> str | None: return None return self.multi_map.current_map_id + @property + def map_list(self) -> list[Q10MapInfo]: + """Return a copy of the successfully reported saved-map list.""" + if self.multi_map is None or self.multi_map.op != "list" or self.multi_map.result != 1: + return [] + return list(self.multi_map.data) + class MapsTrait(Maps, UpdatableTrait): """Request and store the Q10 saved-map list.""" @@ -35,11 +45,24 @@ class MapsTrait(Maps, UpdatableTrait): _CONVERTER = DpsDataConverter.from_dataclass(Maps) _command: CommandTrait - def __init__(self, command: CommandTrait) -> None: + def __init__( + self, + command: CommandTrait, + *, + map_parser_config: B01Q10MapParserConfig | None = None, + ) -> None: """Initialize the saved-map list trait.""" Maps.__init__(self) UpdatableTrait.__init__(self, command, _LOGGER) self._command = command + self._map_parser_config = map_parser_config or B01Q10MapParserConfig() + self.detail_packet: Q10MapPacket | None = None + """Most recently pushed ``04 01`` saved-map detail.""" + self.detail_map_id: str | None = None + """Saved-map ID associated with :attr:`detail_packet`.""" + self.detail_image_content: bytes | None = None + """Rendered saved-map detail image, if decoding succeeded.""" + self._pending_detail_map_id: str | None = None async def refresh(self) -> None: """Request a new saved-map list from the device.""" @@ -48,6 +71,36 @@ async def refresh(self) -> None: {str(B01_Q10_DP.MULTI_MAP.code): {"op": "list"}}, ) + async def refresh_detail(self, map_id: str | None = None) -> None: + """Request a read-only preview for one saved map. + + The device delivers the result asynchronously as a ``04 01`` map + response, which :meth:`update_from_map_packet` stores separately from + the live map. + """ + if map_id is None: + map_id = self.current_map_id + if map_id is None: + raise RoborockException("Cannot request Q10 saved-map detail before the map list is available") + if map_id not in {map_info.id for map_info in self.map_list}: + raise RoborockException(f"Unknown Q10 saved-map ID: {map_id}") + if self._pending_detail_map_id is not None: + raise RoborockException("A Q10 saved-map detail request is already pending") + self._pending_detail_map_id = map_id + try: + await self._command.send( + B01_Q10_DP.COMMON, + { + str(B01_Q10_DP.MULTI_MAP.code): { + "op": "select", + "id": map_id, + } + }, + ) + except RoborockException: + self._pending_detail_map_id = None + raise + def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None: """Store a successful saved-map list response.""" response = decoded_dps.get(B01_Q10_DP.MULTI_MAP) @@ -56,3 +109,30 @@ def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None: if not isinstance(response, dict) or response.get("op") != "list" or response.get("result") != 1: return super().update_from_dps(decoded_dps) + + def update_from_map_packet(self, packet: Q10MapPacket) -> None: + """Store and render a pushed saved-map detail packet.""" + if packet.kind is not Q10MapPacketKind.SAVED_MAP_DETAIL: + raise ValueError(f"Expected a Q10 saved-map detail packet, got {packet.kind.value}") + packet_map_id = str(packet.map_id) + if self._pending_detail_map_id is not None and packet_map_id != self._pending_detail_map_id: + _LOGGER.debug( + "Ignoring Q10 saved-map detail for map %s while waiting for %s", + packet_map_id, + self._pending_detail_map_id, + ) + return + self.detail_map_id = packet_map_id + self._pending_detail_map_id = None + self.detail_packet = packet + try: + self.detail_image_content = render_q10_map( + packet, + None, + Q10MapOverlays(), + config=self._map_parser_config, + ) + except RoborockException: + _LOGGER.debug("Failed to render Q10 saved-map detail", exc_info=True) + self.detail_image_content = None + self._notify_update() diff --git a/roborock/map/b01_q10_map_parser.py b/roborock/map/b01_q10_map_parser.py index 5d28f825a..ad520b4f6 100644 --- a/roborock/map/b01_q10_map_parser.py +++ b/roborock/map/b01_q10_map_parser.py @@ -1,8 +1,9 @@ """Parser for Roborock Q10 (B01/ss07) map packets. -Q10 devices deliver map data as a protocol-301 ``MAP_RESPONSE`` message after a -``dpMultiMap`` list/get request. Unlike the Q7 ``SCMap`` protobuf -format, the Q10 uses a custom, unencrypted binary packet: +Q10 devices deliver map data as protocol-301 ``MAP_RESPONSE`` pushes. Current +maps follow a read-only status request, while saved-map and clean-record detail +packets follow their respective ``select`` requests. Unlike the Q7 ``SCMap`` +protobuf format, the Q10 uses a custom, unencrypted binary packet: - ``01 01`` marker, then a ``u32be`` map id (bytes 2-5) and two consecutive ``u16be`` dimensions: grid width (bytes 7-8) and grid height (bytes 9-10). @@ -22,6 +23,7 @@ import io import math import statistics +import struct from dataclasses import dataclass, field, replace from PIL import Image @@ -30,6 +32,7 @@ from vacuum_map_parser_base.map_data import ImageData, MapData, Point from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint +from roborock.data.code_mappings import RoborockEnum from roborock.data.containers import RoborockBase from roborock.exceptions import RoborockException @@ -67,9 +70,6 @@ def classify_q10_cell(value: int) -> str: return LAYER_FLOOR -MAP_PACKET_MARKER = b"\x01\x01" -TRACE_PACKET_MARKER = b"\x02\x01" - _MAP_ID_OFFSET = 2 # Width and height are two consecutive u16be fields. An earlier revision read the # width as u16le at offset 8; that high byte is actually the height's high byte, @@ -84,6 +84,7 @@ def classify_q10_cell(value: int) -> str: _ROOM_RECORD_LENGTH = 47 _ROOM_NAME_LENGTH_OFFSET = 26 _MAX_ROOMS = 32 +_MAX_GRID_CELLS = 16_000_000 # Sanity bound for the erase-zone vector section's vertices-per-polygon field. _MAX_ERASE_ZONE_VERTICES = 16 @@ -195,10 +196,34 @@ def charger_pixels(self) -> tuple[float, float] | None: ) +class Q10MapPacketKind(RoborockEnum): + """Semantic kind identified by a Q10 map packet's two-byte marker.""" + + unknown = -1 + CURRENT = 1 + TRACE = 2 + CLEAN_RECORD_DETAIL = 3 + SAVED_MAP_DETAIL = 4 + + @property + def marker(self) -> bytes: + """Return the two-byte wire marker for this packet kind.""" + return b"" if self is self.unknown else bytes((self.value, 1)) + + @classmethod + def from_payload(cls, payload: bytes) -> "Q10MapPacketKind | None": + """Return the recognized kind for a payload marker.""" + if len(payload) < 2 or payload[1] != 1: + return None + kind = cls(payload[0]) + return None if kind is cls.unknown else kind + + @dataclass class Q10MapPacket: - """Decoded contents of a Q10 ``01 01`` map packet.""" + """Decoded contents of a Q10 current or archived map packet.""" + kind: Q10MapPacketKind map_id: int width: int height: int @@ -271,6 +296,33 @@ def robot_position(self) -> Q10Point | None: return self.points[-1] if self.points else None +@dataclass +class Q10HistoricalTracePacket: + """Cleaning path embedded in a Q10 ``03 01`` clean-record detail packet. + + This is a different wire layout from the live ``02 01`` trace. Its header + carries a 16-bit format version, a 32-bit opaque value, a 32-bit + point count, a signed heading, and a zero reserved word. Points use the same + signed big-endian ``(x, y)`` coordinate pairs as the live trace. + """ + + points: list[Q10Point] = field(default_factory=list) + heading: int = 0 + + @property + def robot_position(self) -> Q10Point | None: + """The final recorded position, if the historical path is non-empty.""" + return self.points[-1] if self.points else None + + +@dataclass +class Q10CleanRecordDetail: + """A clean-record response containing a map and its recorded path.""" + + map: Q10MapPacket + trace: Q10HistoricalTracePacket | None = None + + # Trace packet (``02 01``): a 14-byte header followed by big-endian int16 (x, y) # point pairs forming the accumulated session path. Header layout confirmed # against live ss07 captures and cross-checked by @andrewlyeats: @@ -280,18 +332,26 @@ def robot_position(self) -> Q10Point | None: # - bytes 10-11: the 0201 SLAM heading (s16be degrees; 0 = +x, +90 = +y, # +-180 = -x, -90 = -y) -- the robot's current orientation. # - bytes 12-13: a constant (0x0000). -# - byte 14 onward: the path points. +# - byte 14 onward: exactly ``point_count`` path points. # An earlier revision used a 10-byte header, which folded the heading word into # a phantom leading point ``(heading, 0)`` -- that is the "stray point" the # heuristic below was papering over, and why the count read "one high". The -# parser reads all 4-byte pairs in the body rather than trusting the count -# field, so a truncated tail can't desync it. +# parser requires the declared point count to match the complete body, so a +# truncated or extended tail cannot be silently interpreted as path data. # NOTE: the format documented by roborock-qseries-map-bridge (18-byte header) # did not match this firmware -- this 14-byte layout is what the device sent. _TRACE_HEADER_LENGTH = 14 _TRACE_SEQUENCE_OFFSET = 3 +_TRACE_POINT_COUNT_OFFSET = 8 _TRACE_HEADING_OFFSET = 10 +_HISTORICAL_TRACE_HEADER_LENGTH = 14 +_HISTORICAL_TRACE_PREFIX_LENGTH = 1 +_HISTORICAL_TRACE_VERSION = 1 +_HISTORICAL_TRACE_POINT_COUNT_OFFSET = 6 +_HISTORICAL_TRACE_HEADING_OFFSET = 10 +_HISTORICAL_TRACE_RESERVED_OFFSET = 12 + # Some cleans still prepend a single near-origin sentinel as the first real # point (e.g. ~(5, 76) / (-3, 0) when the path proper starts near (-1700, -800)); # it skews the rendered start/bounding box and any path-based calibration. (This @@ -306,12 +366,12 @@ def robot_position(self) -> Q10Point | None: def is_map_packet(payload: bytes) -> bool: """Return True if the payload is a Q10 full-map (``01 01``) packet.""" - return payload[:2] == MAP_PACKET_MARKER + return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.CURRENT def is_trace_packet(payload: bytes) -> bool: """Return True if the payload is a Q10 live trace (``02 01``) packet.""" - return payload[:2] == TRACE_PACKET_MARKER + return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.TRACE def parse_trace_packet(payload: bytes) -> Q10TracePacket: @@ -323,6 +383,9 @@ def parse_trace_packet(payload: bytes) -> Q10TracePacket: body = payload[_TRACE_HEADER_LENGTH:] if len(body) % 4: raise RoborockException("Q10 trace points are not 4-byte (x, y) pairs") + declared_point_count = int.from_bytes(payload[_TRACE_POINT_COUNT_OFFSET : _TRACE_POINT_COUNT_OFFSET + 2], "big") + if declared_point_count != len(body) // 4: + raise RoborockException("Q10 trace point count does not match its payload") heading = int.from_bytes(payload[_TRACE_HEADING_OFFSET : _TRACE_HEADING_OFFSET + 2], "big", signed=True) points = [ @@ -353,11 +416,13 @@ def _drop_stray_leading_point(points: list[Q10Point]) -> list[Q10Point]: return points -def lz4_block_decompress(data: bytes) -> bytes: +def lz4_block_decompress(data: bytes, max_output_size: int) -> bytes: """Decompress a raw LZ4 *block* (no frame header). The Q10 map grid is stored as a single LZ4 block. This implements the - standard LZ4 block format so we don't add a native dependency. + standard LZ4 block format so we don't add a native dependency. Expansion beyond + ``max_output_size`` is rejected before + allocating the excess output. """ index = 0 output = bytearray() @@ -385,6 +450,8 @@ def read_length(value: int) -> int: end = index + literal_length if end > len(data): raise RoborockException("Truncated LZ4 block while reading literals") + if len(output) + literal_length > max_output_size: + raise RoborockException("LZ4 block exceeds maximum output size") output.extend(data[index:end]) index = end @@ -399,6 +466,8 @@ def read_length(value: int) -> int: raise RoborockException("Invalid LZ4 back-reference offset") match_length = read_length(token & 0x0F) + 4 + if len(output) + match_length > max_output_size: + raise RoborockException("LZ4 block exceeds maximum output size") for _ in range(match_length): output.append(output[-offset]) @@ -463,8 +532,24 @@ def _parse_rooms(room_data: bytes, grid: bytes) -> list[Q10Room]: def parse_map_packet(payload: bytes) -> Q10MapPacket: - """Parse a Q10 ``01 01`` map packet into grid + room metadata.""" - if len(payload) < _LAYOUT_COMPRESSED_OFFSET or not is_map_packet(payload): + """Parse the raster and shared metadata of a current or archived map.""" + packet, _, _ = _parse_map_layout(payload) + return packet + + +def parse_clean_record_detail(payload: bytes) -> Q10CleanRecordDetail: + """Parse a clean-record response into its map and optional recorded path.""" + if Q10MapPacketKind.from_payload(payload) is not Q10MapPacketKind.CLEAN_RECORD_DETAIL: + raise RoborockException("Payload is not a Q10 clean-record detail packet") + packet, tail, trace_offset = _parse_map_layout(payload) + trace = _parse_clean_record_trace(tail, trace_offset) if trace_offset is not None else None + return Q10CleanRecordDetail(map=packet, trace=trace) + + +def _parse_map_layout(payload: bytes) -> tuple[Q10MapPacket, bytes, int | None]: + """Decode shared map fields and return the tail and historical path offset.""" + kind = Q10MapPacketKind.from_payload(payload) + if len(payload) < _LAYOUT_COMPRESSED_OFFSET or kind is None or kind is Q10MapPacketKind.TRACE: raise RoborockException("Payload is not a Q10 map packet") map_id = int.from_bytes(payload[_MAP_ID_OFFSET : _MAP_ID_OFFSET + 4], "big") @@ -472,6 +557,8 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket: height = int.from_bytes(payload[_HEIGHT_OFFSET : _HEIGHT_OFFSET + 2], "big") if width <= 0: raise RoborockException("Q10 map packet has invalid width") + if height > 0 and width * height > _MAX_GRID_CELLS: + raise RoborockException("Q10 map packet dimensions exceed the supported grid size") compressed_length = int.from_bytes( payload[_COMPRESSED_LAYOUT_LENGTH_OFFSET : _COMPRESSED_LAYOUT_LENGTH_OFFSET + 2], "big" @@ -480,7 +567,10 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket: if compressed_length <= 0 or layout_end > len(payload): raise RoborockException("Q10 map packet has invalid layout block length") - decoded = lz4_block_decompress(payload[_LAYOUT_COMPRESSED_OFFSET:layout_end]) + decoded = lz4_block_decompress( + payload[_LAYOUT_COMPRESSED_OFFSET:layout_end], + max_output_size=_MAX_GRID_CELLS + 2 + _MAX_ROOMS * _ROOM_RECORD_LENGTH, + ) # Prefer the header height; fall back to inference if it doesn't line up # (e.g. older captures/fixtures that don't populate the height field). split = _split_with_dims(decoded, width, height) if height > 0 else None @@ -491,9 +581,10 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket: rooms = _parse_rooms(room_data, grid) tail = payload[layout_end:] erase_zones = _parse_erase_zones(tail) - carpet_mask = _parse_carpet_mask(tail, width, height) + carpet_mask, carpet_end = _parse_carpet_block(tail, width, height) header_calibration = _parse_header_calibration(payload) - return Q10MapPacket( + packet = Q10MapPacket( + kind=kind, map_id=map_id, width=width, height=height, @@ -503,6 +594,7 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket: header_calibration=header_calibration, carpet_mask=carpet_mask, ) + return packet, tail, carpet_end def _parse_header_calibration(payload: bytes) -> Q10HeaderCalibration | None: @@ -574,7 +666,18 @@ def _carpet_offset(tail: bytes) -> int: return 2 + count * vertices_per * 4 -def _parse_carpet_mask(tail: bytes, width: int, height: int) -> bytes | None: +def _erase_section_end(tail: bytes) -> int: + """Return the end of a complete, structurally valid erase section.""" + if len(tail) < 2: + return 0 + count, vertices_per = tail[0], tail[1] + if count and not 1 <= vertices_per <= _MAX_ERASE_ZONE_VERTICES: + return 0 + end = _carpet_offset(tail) + return end if end <= len(tail) else 0 + + +def _parse_carpet_block(tail: bytes, width: int, height: int) -> tuple[bytes | None, int | None]: """Decode the carpet mask that follows the erase section in the packet tail. Framing matches the main grid block: ``[u32 uncompressed_len]`` @@ -583,23 +686,73 @@ def _parse_carpet_mask(tail: bytes, width: int, height: int) -> bytes | None: non-zero cell is carpet (the value is the carpet kind). Confirmed byte-exact on live ss07 captures (R1 / RDC), where ``uncompressed_len == width*height``. - Returns the decompressed mask, or ``None`` if the section is absent or does - not line up (the ``uncompressed_len == width*height`` invariant is used as the - guard so a mis-located section yields no carpet rather than garbage). + Returns the decompressed mask and its end offset. Both are ``None`` if the + section is absent or does not line up. The end offset is used to anchor + optional later sections without scanning arbitrary trailing bytes. """ - offset = _carpet_offset(tail) + offset = _erase_section_end(tail) + if offset == 0: + return None, None if offset + 6 > len(tail): - return None + return None, None uncompressed_len = int.from_bytes(tail[offset : offset + 4], "big") compressed_len = int.from_bytes(tail[offset + 4 : offset + 6], "big") block_end = offset + 6 + compressed_len if uncompressed_len != width * height or compressed_len <= 0 or block_end > len(tail): - return None + return None, None try: - mask = lz4_block_decompress(tail[offset + 6 : block_end]) + mask = lz4_block_decompress(tail[offset + 6 : block_end], max_output_size=width * height) except RoborockException: + return None, None + if len(mask) != width * height: + return None, None + return mask, block_end + + +def _parse_clean_record_trace( + tail: bytes, + offset: int, +) -> Q10HistoricalTracePacket | None: + """Decode the bounded historical path following a ``03 01`` carpet block. + + The header and declared point count were validated against a physical ss07 + clean-record response and its point bytes match captured prefixes of the + corresponding live trace exactly. One observed zero byte precedes the path; + its meaning is unknown, so a non-zero value makes the entire section opaque. + Any unsupported version, non-zero reserved word, or truncated point table is + likewise left completely opaque. Bytes after the declared points are + deliberately not consumed: the observed 12-byte suffix appears structured, + but there is not enough controlled evidence to name or decode it safely. + """ + if offset >= len(tail) or tail[offset] != 0: + return None + offset += _HISTORICAL_TRACE_PREFIX_LENGTH + header_end = offset + _HISTORICAL_TRACE_HEADER_LENGTH + if header_end > len(tail): return None - return mask if len(mask) == width * height else None + version = int.from_bytes(tail[offset : offset + 2], "big") + reserved = int.from_bytes( + tail[offset + _HISTORICAL_TRACE_RESERVED_OFFSET : offset + _HISTORICAL_TRACE_RESERVED_OFFSET + 2], + "big", + ) + if version != _HISTORICAL_TRACE_VERSION or reserved != 0: + return None + point_count = int.from_bytes( + tail[offset + _HISTORICAL_TRACE_POINT_COUNT_OFFSET : offset + _HISTORICAL_TRACE_POINT_COUNT_OFFSET + 4], + "big", + ) + points_end = header_end + point_count * 4 + if points_end > len(tail): + return None + coordinates = struct.iter_unpack(">hh", memoryview(tail)[header_end:points_end]) + return Q10HistoricalTracePacket( + points=_drop_stray_leading_point([Q10Point(x=x, y=y) for x, y in coordinates]), + heading=int.from_bytes( + tail[offset + _HISTORICAL_TRACE_HEADING_OFFSET : offset + _HISTORICAL_TRACE_HEADING_OFFSET + 2], + "big", + signed=True, + ), + ) def erased_packet(packet: "Q10MapPacket", cells: set[int]) -> "Q10MapPacket": diff --git a/roborock/map/b01_q10_render.py b/roborock/map/b01_q10_render.py index 0e61452f3..a24df43cc 100644 --- a/roborock/map/b01_q10_render.py +++ b/roborock/map/b01_q10_render.py @@ -34,6 +34,7 @@ B01Q10MapParser, B01Q10MapParserConfig, Q10EraseZone, + Q10HistoricalTracePacket, Q10MapPacket, Q10TracePacket, erased_packet, @@ -62,7 +63,6 @@ # a much shorter path suffices to confirm it (early in a clean, not just a dense # one). See :func:`solve_calibration_with_origin`. _MIN_HEADER_CALIBRATION_POINTS = 4 - _Q10_DRAWABLE_TYPES = { Drawable.CHARGER, Drawable.NO_GO_AREAS, @@ -84,7 +84,7 @@ class Q10MapOverlays: def render_q10_map( packet: Q10MapPacket, - trace: Q10TracePacket | None, + trace: Q10TracePacket | Q10HistoricalTracePacket | None, overlays: Q10MapOverlays, *, config: B01Q10MapParserConfig, @@ -133,7 +133,7 @@ def render_q10_map( def solve_q10_calibration( packet: Q10MapPacket, - trace: Q10TracePacket | None, + trace: Q10TracePacket | Q10HistoricalTracePacket | None, ) -> GridCalibration | None: """Derive world-to-pixel calibration from a map and its current trace. @@ -232,7 +232,7 @@ def _erased_cells( def _place_trace( map_data: MapData, calibration: GridCalibration, - trace: Q10TracePacket, + trace: Q10TracePacket | Q10HistoricalTracePacket, *, charger_heading: int | None = None, ) -> None: diff --git a/roborock/protocols/b01_q10_protocol.py b/roborock/protocols/b01_q10_protocol.py index 2eccb15b8..a3a18fa1b 100644 --- a/roborock/protocols/b01_q10_protocol.py +++ b/roborock/protocols/b01_q10_protocol.py @@ -11,10 +11,11 @@ from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint from roborock.exceptions import RoborockException from roborock.map.b01_q10_map_parser import ( + Q10CleanRecordDetail, Q10MapPacket, + Q10MapPacketKind, Q10TracePacket, - is_map_packet, - is_trace_packet, + parse_clean_record_detail, parse_map_packet, parse_trace_packet, ) @@ -155,24 +156,27 @@ class Q10DpsUpdate: # A single decoded message from a Q10 device: a DPS status update, a full map # packet, or a live cleaning-path (trace) packet. Map/trace packets arrive as # protocol-301 ``MAP_RESPONSE`` pushes; everything else is a DPS update. -Q10Message = Q10DpsUpdate | Q10MapPacket | Q10TracePacket +Q10Message = Q10DpsUpdate | Q10MapPacket | Q10TracePacket | Q10CleanRecordDetail def decode_message(message: RoborockMessage) -> Q10Message | None: """Decode a pushed Q10 ``RoborockMessage`` into a typed message. - ``MAP_RESPONSE`` (protocol 301) payloads carry the binary map (``01 01``) or - trace (``02 01``) packets, which are parsed by the map parser; any other - ``MAP_RESPONSE`` marker is unrecognized and yields ``None``. Every other - protocol is treated as a DPS status update. + ``MAP_RESPONSE`` (protocol 301) payloads carry binary current-map (``01 + 01``), trace (``02 01``), clean-record detail (``03 01``), or saved-map + detail (``04 01``) packets. Any other marker is unrecognized and yields + ``None``. Every other protocol is treated as a DPS status update. Raises ``RoborockException`` if a recognized payload fails to parse. """ if message.protocol == RoborockMessageProtocol.MAP_RESPONSE: payload = message.payload or b"" - if is_map_packet(payload): - return parse_map_packet(payload) - if is_trace_packet(payload): + kind = Q10MapPacketKind.from_payload(payload) + if kind is Q10MapPacketKind.TRACE: return parse_trace_packet(payload) + if kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL: + return parse_clean_record_detail(payload) + if kind is not None: + return parse_map_packet(payload) return None return Q10DpsUpdate(dps=decode_rpc_response(message)) diff --git a/tests/conformance/test_model_conformance.py b/tests/conformance/test_model_conformance.py index 52979d662..634df643b 100644 --- a/tests/conformance/test_model_conformance.py +++ b/tests/conformance/test_model_conformance.py @@ -10,6 +10,7 @@ import pytest import roborock.data +from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint from roborock.data.containers import RoborockBase from tests.conformance.discovery import discover_dataclasses, to_pytest_params @@ -20,6 +21,12 @@ ) def test_data_model_subclasses_roborock_base(model_cls: type) -> None: """All domain dataclasses in roborock.data must inherit from RoborockBase.""" + # This immutable coordinate value predates the conformance suite. Frozen + # dataclasses cannot inherit from the non-frozen RoborockBase dataclass. + # Keep this exception explicit; other models must satisfy the normal rule. + if model_cls is Q10RoborockPoint: + assert model_cls.__dataclass_params__.frozen # type: ignore[attr-defined] + return assert issubclass(model_cls, RoborockBase), ( f"{model_cls.__module__}.{model_cls.__name__} is a dataclass but does not inherit from RoborockBase. " "Per AGENTS.md, domain containers must subclass RoborockBase for serialization." diff --git a/tests/data/b01_q10/test_b01_q10_containers.py b/tests/data/b01_q10/test_b01_q10_containers.py index f355e06e2..b5d406000 100644 --- a/tests/data/b01_q10/test_b01_q10_containers.py +++ b/tests/data/b01_q10/test_b01_q10_containers.py @@ -1,5 +1,7 @@ """Tests for Q10 data containers.""" +from dataclasses import FrozenInstanceError + import pytest from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint @@ -47,3 +49,15 @@ def test_q10_roborock_point_rejects_invalid_vector_coordinates( """Outbound vector coordinates must fit the signed wire grid exactly.""" with pytest.raises(ValueError): point.to_vector() + + +@pytest.mark.parametrize("field", ["x", "y"]) +def test_roborock_point_preserves_immutable_value_contract(field: str) -> None: + point = Q10RoborockPoint(25500, 25500) + original_hash = hash(point) + with pytest.raises(FrozenInstanceError): + setattr(point, field, 0) + with pytest.raises(FrozenInstanceError): + delattr(point, field) + assert point == Q10RoborockPoint(25500, 25500) + assert hash(point) == original_hash diff --git a/tests/devices/traits/b01/q10/test_clean_history.py b/tests/devices/traits/b01/q10/test_clean_history.py index 10fce2b64..f8cdef115 100644 --- a/tests/devices/traits/b01/q10/test_clean_history.py +++ b/tests/devices/traits/b01/q10/test_clean_history.py @@ -1,3 +1,5 @@ +from pathlib import Path + import pytest from roborock.data.b01_q10.b01_q10_code_mappings import ( @@ -10,6 +12,8 @@ from roborock.data.b01_q10.b01_q10_containers import Q10CleanRecord from roborock.devices.traits.b01.q10 import Q10PropertiesApi from roborock.devices.traits.b01.q10.clean_history import CleanHistoryTrait, CleanRecordConverter +from roborock.exceptions import RoborockException +from roborock.map.b01_q10_map_parser import parse_clean_record_detail from .conftest import FakeB01Q10Channel @@ -175,3 +179,53 @@ async def test_refresh_sends_op_list(q10_api: Q10PropertiesApi, fake_channel: Fa B01_Q10_DP.COMMON, {"52": {"op": "list"}}, ) + + +async def test_refresh_detail_sends_full_raw_record( + clean_history: CleanHistoryTrait, + fake_channel: FakeB01Q10Channel, +) -> None: + record = CleanRecordConverter.parse_record(RECORD_A) + assert record is not None + + await clean_history.refresh_detail(record) + + assert fake_channel.published_commands == [ + ( + B01_Q10_DP.COMMON, + {"52": {"op": "select", "id": RECORD_A}}, + ) + ] + + +async def test_refresh_detail_rejects_record_without_map(clean_history: CleanHistoryTrait) -> None: + record = CleanRecordConverter.parse_record("x_1781226271_1_1_0_0_0_0_2_1_1_0") + assert record is not None + + with pytest.raises(RoborockException, match="no saved map detail"): + await clean_history.refresh_detail(record) + + +async def test_refresh_detail_rejects_parallel_request(clean_history: CleanHistoryTrait) -> None: + record = CleanRecordConverter.parse_record(RECORD_A) + assert record is not None + await clean_history.refresh_detail(record) + + with pytest.raises(RoborockException, match="already pending"): + await clean_history.refresh_detail(record) + + +async def test_detail_response_is_associated_with_pending_record( + clean_history: CleanHistoryTrait, +) -> None: + record = CleanRecordConverter.parse_record(RECORD_A) + assert record is not None + await clean_history.refresh_detail(record) + fixture = Path("tests/map/testdata/b01_q10_map.bin").read_bytes() + packet = parse_clean_record_detail(b"\x03\x01" + fixture[2:]) + + clean_history.update_from_detail(packet) + + assert clean_history.detail_record is record + assert clean_history.detail_packet is packet.map + assert clean_history.detail is packet diff --git a/tests/devices/traits/b01/q10/test_map.py b/tests/devices/traits/b01/q10/test_map.py index 060553af5..4f1edae9d 100644 --- a/tests/devices/traits/b01/q10/test_map.py +++ b/tests/devices/traits/b01/q10/test_map.py @@ -1,9 +1,8 @@ """Tests for the Q10 B01 map content trait. -Map list data and map content have independent refresh schedules. Content -requests use a stored map ID, and the device sends the data later in a -``MAP_RESPONSE`` packet. These tests cover that state management. The render -details are tested in ``tests/map/test_b01_q10_render.py``. +Map list data and current-map content have independent refresh schedules. The +device sends map data later in a ``MAP_RESPONSE`` packet. These tests cover +that state management; rendering is tested separately. """ import asyncio @@ -23,8 +22,12 @@ from roborock.devices.traits.b01.q10.maps import MapsTrait from roborock.exceptions import RoborockException from roborock.map.b01_q10_map_parser import ( + B01Q10MapParserConfig, + Q10CleanRecordDetail, + Q10MapPacketKind, Q10Point, Q10TracePacket, + parse_clean_record_detail, parse_map_packet, parse_trace_packet, ) @@ -38,19 +41,9 @@ def _map_trait(map_dps: MapDpsTrait | None = None) -> MapContentTrait: - """Create map content with a stored map ID for tests that do not perform I/O.""" + """Create map content for tests that do not perform I/O.""" command = cast(CommandTrait, Mock(spec=CommandTrait)) - maps = MapsTrait(command) - maps.update_from_dps( - { - B01_Q10_DP.MULTI_MAP: { - "data": [{"id": "12345"}], - "op": "list", - "result": 1, - } - } - ) - return MapContentTrait(map_dps or MapDpsTrait(), maps, command) + return MapContentTrait(map_dps or MapDpsTrait(), command) def _zone_blob() -> str: @@ -83,6 +76,15 @@ def test_update_from_map_packet_populates_image_and_rooms() -> None: assert len(updates) == 1 +def test_live_map_trait_rejects_archived_packet() -> None: + """Direct callers cannot bypass API routing and replace live map state.""" + payload = FIXTURE.read_bytes() + archived = parse_clean_record_detail(b"\x03\x01" + payload[2:]) + + with pytest.raises(ValueError, match="Expected a current Q10 map packet"): + _map_trait().update_from_map_packet(archived.map) + + def test_update_from_trace_packet_populates_path_and_position() -> None: """A pushed 02 01 trace packet populates the path, position and heading.""" trace = parse_trace_packet(TRACE_SESSION_FIXTURE.read_bytes()) @@ -121,7 +123,7 @@ def __init__(self) -> None: } } ) - self.map = MapContentTrait(MapDpsTrait(), self.maps, command) + self.map = MapContentTrait(MapDpsTrait(), command) self.refresh_count = 0 async def refresh_map() -> None: @@ -149,6 +151,7 @@ async def test_await_q10_map_push_waits_for_fresh_update() -> None: got_trace = await _await_q10_map_push( cast(Q10PropertiesApi, properties), lambda: bool(properties.map.path), + lambda: properties.map.trace_revision, timeout=0.01, ) @@ -162,6 +165,7 @@ async def test_await_q10_map_push_returns_true_after_update() -> None: got_trace = await _await_q10_map_push( cast(Q10PropertiesApi, properties), lambda: bool(properties.map.path), + lambda: properties.map.trace_revision, timeout=0.01, ) @@ -176,6 +180,7 @@ async def test_await_q10_map_push_can_fall_back_to_cached_map_on_timeout() -> No got_map = await _await_q10_map_push( cast(Q10PropertiesApi, properties), lambda: properties.map.image_content is not None, + lambda: properties.map.map_revision, timeout=0.01, allow_cached_on_timeout=True, ) @@ -231,6 +236,86 @@ async def test_subscribe_loop_routes_map_push( assert {room.id: room.name for room in q10_api.map.rooms} == {2: "Living Room", 3: "Bedroom"} +async def test_archived_map_pushes_cannot_overwrite_live_map( + q10_api: Q10PropertiesApi, + message_queue: asyncio.Queue[Q10Message], +) -> None: + """03/04 detail packets are isolated from the current live-map trait.""" + current_bytes = FIXTURE.read_bytes() + current = parse_map_packet(current_bytes) + trace = parse_trace_packet(TRACE_SESSION_FIXTURE.read_bytes()) + clean_record = parse_clean_record_detail(b"\x03\x01" + current_bytes[2:]) + saved_map = parse_map_packet(b"\x04\x01" + current_bytes[2:]) + + message_queue.put_nowait(current) + message_queue.put_nowait(trace) + await _wait_for(lambda: q10_api.map.image_content is not None and bool(q10_api.map.path)) + live_image = q10_api.map.image_content + live_rooms = list(q10_api.map.rooms) + live_path = list(q10_api.map.path) + live_position = q10_api.map.robot_position + live_heading = q10_api.map.robot_heading + live_updates: list[None] = [] + clean_record_updates: list[None] = [] + saved_map_updates: list[None] = [] + q10_api.map.add_update_listener(lambda: live_updates.append(None)) + q10_api.clean_history.add_update_listener(lambda: clean_record_updates.append(None)) + q10_api.maps.add_update_listener(lambda: saved_map_updates.append(None)) + + message_queue.put_nowait(clean_record) + message_queue.put_nowait(saved_map) + await _wait_for(lambda: q10_api.maps.detail_packet is not None) + + assert q10_api.map.image_content == live_image + assert q10_api.map.rooms == live_rooms + assert q10_api.map.path == live_path + assert q10_api.map.robot_position == live_position + assert q10_api.map.robot_heading == live_heading + assert live_updates == [] + assert q10_api.clean_history.detail_packet is not None + assert q10_api.clean_history.detail_packet.kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL + assert q10_api.clean_history.detail_image_content is not None + assert q10_api.maps.detail_packet is not None + assert q10_api.maps.detail_packet.kind is Q10MapPacketKind.SAVED_MAP_DETAIL + assert q10_api.maps.detail_image_content is not None + assert clean_record_updates == [None] + assert saved_map_updates == [None] + + +def test_archive_owners_reject_wrong_packet_kinds(q10_api: Q10PropertiesApi) -> None: + """Semantic archive traits reject packets owned by another map stream.""" + current = parse_map_packet(FIXTURE.read_bytes()) + + with pytest.raises(ValueError, match="clean-record detail"): + q10_api.clean_history.update_from_detail(Q10CleanRecordDetail(map=current)) + with pytest.raises(ValueError, match="saved-map detail"): + q10_api.maps.update_from_map_packet(current) + + +def test_all_q10_map_views_share_the_injected_render_config( + fake_channel: FakeB01Q10Channel, +) -> None: + config = B01Q10MapParserConfig(map_scale=2) + api = Q10PropertiesApi(fake_channel, map_parser_config=config) + payload = FIXTURE.read_bytes() + + with ( + patch("roborock.devices.traits.b01.q10.map.render_q10_map", return_value=b"map") as live_render, + patch( + "roborock.devices.traits.b01.q10.clean_history.render_q10_map", + return_value=b"history", + ) as history_render, + patch("roborock.devices.traits.b01.q10.maps.render_q10_map", return_value=b"saved") as saved_render, + ): + api._handle_message(parse_map_packet(payload)) + api._handle_message(parse_clean_record_detail(b"\x03\x01" + payload[2:])) + api._handle_message(parse_map_packet(b"\x04\x01" + payload[2:])) + + assert live_render.call_args.kwargs["config"] is config + assert history_render.call_args.kwargs["config"] is config + assert saved_render.call_args.kwargs["config"] is config + + async def test_subscribe_loop_routes_trace_push( q10_api: Q10PropertiesApi, message_queue: asyncio.Queue[Q10Message], @@ -333,6 +418,106 @@ async def test_map_content_refresh_requests_are_not_rate_limited(q10_api: Q10Pro assert send.await_count == 2 +async def test_saved_map_detail_refresh_uses_current_map_id(q10_api: Q10PropertiesApi) -> None: + """Saved-map detail uses the independently validated select request.""" + q10_api.maps.update_from_dps( + { + B01_Q10_DP.MULTI_MAP: { + "data": [{"id": "12345"}], + "op": "list", + "result": 1, + } + } + ) + with patch.object(q10_api.command, "send") as send: + await q10_api.maps.refresh_detail() + + send.assert_awaited_once_with( + B01_Q10_DP.COMMON, + {str(B01_Q10_DP.MULTI_MAP.code): {"op": "select", "id": "12345"}}, + ) + + +async def test_saved_map_detail_refresh_accepts_any_listed_map_id(q10_api: Q10PropertiesApi) -> None: + q10_api.maps.update_from_dps( + { + B01_Q10_DP.MULTI_MAP: { + "data": [{"id": "12345"}, {"id": "67890"}], + "op": "list", + "result": 1, + } + } + ) + assert [map_info.id for map_info in q10_api.maps.map_list] == ["12345", "67890"] + + with patch.object(q10_api.command, "send") as send: + await q10_api.maps.refresh_detail("67890") + + send.assert_awaited_once_with( + B01_Q10_DP.COMMON, + {str(B01_Q10_DP.MULTI_MAP.code): {"op": "select", "id": "67890"}}, + ) + + +async def test_saved_map_detail_refresh_rejects_unknown_or_parallel_request( + q10_api: Q10PropertiesApi, +) -> None: + q10_api.maps.update_from_dps( + { + B01_Q10_DP.MULTI_MAP: { + "data": [{"id": "12345"}], + "op": "list", + "result": 1, + } + } + ) + with pytest.raises(RoborockException, match="Unknown Q10 saved-map ID"): + await q10_api.maps.refresh_detail("67890") + + await q10_api.maps.refresh_detail("12345") + with pytest.raises(RoborockException, match="already pending"): + await q10_api.maps.refresh_detail("12345") + + +async def test_saved_map_detail_correlates_pending_map_id(q10_api: Q10PropertiesApi) -> None: + requested_id = str(parse_map_packet(FIXTURE.read_bytes()).map_id) + q10_api.maps.update_from_dps( + { + B01_Q10_DP.MULTI_MAP: { + "data": [{"id": requested_id}, {"id": "999"}], + "op": "list", + "result": 1, + } + } + ) + + await q10_api.maps.refresh_detail("999") + packet = parse_map_packet(b"\x04\x01" + FIXTURE.read_bytes()[2:]) + q10_api.maps.update_from_map_packet(packet) + assert q10_api.maps.detail_packet is None + + matching = MapsTrait(q10_api.command) + matching.update_from_dps( + { + B01_Q10_DP.MULTI_MAP: { + "data": [{"id": requested_id}], + "op": "list", + "result": 1, + } + } + ) + await matching.refresh_detail(requested_id) + matching.update_from_map_packet(packet) + assert matching.detail_packet is packet + assert matching.detail_map_id == requested_id + + +async def test_saved_map_detail_refresh_requires_stored_map_id(q10_api: Q10PropertiesApi) -> None: + """Detail cannot be requested until the saved-map list supplies an ID.""" + with pytest.raises(RoborockException, match="map list is available"): + await q10_api.maps.refresh_detail() + + def test_map_get_ack_does_not_replace_saved_map_list(q10_api: Q10PropertiesApi) -> None: """A content acknowledgement cannot remove the stored map ID.""" q10_api._handle_message( @@ -490,8 +675,8 @@ async def test_charging_status_renders_robot_at_dock(render_map: Mock) -> None: assert render_map.call_args.kwargs["robot_at_dock"] is True -def test_docked_state_hides_trace_only_from_rendering(render_map: Mock) -> None: - """A docked render omits the valid trace without deleting source data.""" +def test_docked_state_clears_stale_live_trace(render_map: Mock) -> None: + """A docked update removes a completed path from public live state.""" map_dps = MapDpsTrait() trait = _map_trait(map_dps) packet = parse_map_packet(FIXTURE.read_bytes()) @@ -504,13 +689,13 @@ def test_docked_state_hides_trace_only_from_rendering(render_map: Mock) -> None: map_dps.update_from_dps({B01_Q10_DP.STATUS: YXDeviceState.CHARGING.code}) - assert trait.path == trace.points + assert trait.path == [] assert render_map.call_args.args[1] is None assert render_map.call_args.kwargs["robot_at_dock"] is True -def test_late_trace_is_retained_but_hidden_while_docked(render_map: Mock) -> None: - """A late trace stays available but is not part of a docked render.""" +def test_late_trace_is_ignored_while_docked(render_map: Mock) -> None: + """A delayed trace cannot repopulate public state while docked.""" map_dps = MapDpsTrait() map_dps.update_from_dps({B01_Q10_DP.STATUS: YXDeviceState.CHARGING.code}) trait = _map_trait(map_dps) @@ -520,7 +705,7 @@ def test_late_trace_is_retained_but_hidden_while_docked(render_map: Mock) -> Non trait.update_from_map_packet(parse_map_packet(FIXTURE.read_bytes())) trait.update_from_trace_packet(trace) - assert trait.path == trace.points + assert trait.path == [] assert render_map.call_args.args[1] is None diff --git a/tests/map/test_b01_q10_map_parser.py b/tests/map/test_b01_q10_map_parser.py index c0200ff58..e0585c719 100644 --- a/tests/map/test_b01_q10_map_parser.py +++ b/tests/map/test_b01_q10_map_parser.py @@ -2,6 +2,7 @@ import io from pathlib import Path +from typing import Any import pytest from PIL import Image @@ -10,11 +11,14 @@ from roborock.map.b01_grid_layers import LAYER_BACKGROUND, LAYER_FLOOR, LAYER_WALL from roborock.map.b01_q10_map_parser import ( B01Q10MapParser, + Q10MapPacketKind, + Q10Point, Q10Room, classify_q10_cell, is_map_packet, is_trace_packet, lz4_block_decompress, + parse_clean_record_detail, parse_map_packet, parse_trace_packet, ) @@ -96,7 +100,7 @@ def test_lz4_block_roundtrip_all_literals() -> None: block.append(0x0F << 4) block.append(len(original) - 15) block += original - assert lz4_block_decompress(bytes(block)) == original + assert lz4_block_decompress(bytes(block), max_output_size=len(original)) == original def test_lz4_block_back_reference() -> None: @@ -104,7 +108,14 @@ def test_lz4_block_back_reference() -> None: # seq1: 1 literal 'A', then match (offset 1, length 4+4=8) -> 'A' x9. # seq2: final literals-only token (0 literals) ends the block per LZ4 spec. block = bytes([0x14, ord("A"), 0x01, 0x00, 0x00]) - assert lz4_block_decompress(block) == b"A" * 9 + assert lz4_block_decompress(block, max_output_size=9) == b"A" * 9 + + +def test_lz4_block_rejects_output_over_limit() -> None: + block = bytes([0x14, ord("A"), 0x01, 0x00, 0x00]) + + with pytest.raises(RoborockException, match="maximum output size"): + lz4_block_decompress(block, max_output_size=8) def test_is_map_packet() -> None: @@ -356,6 +367,16 @@ def test_parse_trace_rejects_misaligned_points() -> None: parse_trace_packet(b"\x02\x01" + b"\x00" * 12 + b"\x01\x02\x03") +@pytest.mark.parametrize("declared_count", [0, 2]) +def test_parse_trace_rejects_declared_count_mismatch(declared_count: int) -> None: + """An aligned body cannot silently disagree with the firmware count.""" + payload = bytearray(_trace_payload([(10, 20)])) + payload[8:10] = declared_count.to_bytes(2, "big") + + with pytest.raises(RoborockException, match="point count"): + parse_trace_packet(bytes(payload)) + + def test_parse_rejects_bad_layout_length() -> None: payload = bytearray(_payload()) payload[27:29] = (0xFFFF).to_bytes(2, "big") # compressed length past the buffer @@ -363,6 +384,15 @@ def test_parse_rejects_bad_layout_length() -> None: parse_map_packet(bytes(payload)) +def test_parse_rejects_unreasonable_header_dimensions() -> None: + payload = bytearray(_payload()) + payload[7:9] = (65535).to_bytes(2, "big") + payload[9:11] = (65535).to_bytes(2, "big") + + with pytest.raises(RoborockException, match="supported grid size"): + parse_map_packet(bytes(payload)) + + def test_parse_erase_zones_from_map_packet_tail() -> None: """Erase rectangles appended after the grid decode to world polygons.""" rects = [ @@ -387,6 +417,32 @@ def _carpet_tail(width: int, height: int, carpet: bytes, erase: bytes = bytes([0 return erase + (width * height).to_bytes(4, "big") + len(block).to_bytes(2, "big") + block +def _map_detail_payload( + marker: bytes, + points: list[tuple[int, int]], + *, + version: int = 1, + opaque_value: int = 2, + heading: int = 3, + reserved: int = 0, + prefix: int = 0, + trailing: bytes = b"", +) -> bytes: + """Build a neutral synthetic detail packet from the existing map fixture.""" + header = ( + version.to_bytes(2, "big") + + opaque_value.to_bytes(4, "big") + + len(points).to_bytes(4, "big") + + heading.to_bytes(2, "big", signed=True) + + reserved.to_bytes(2, "big") + ) + point_table = b"".join(x.to_bytes(2, "big", signed=True) + y.to_bytes(2, "big", signed=True) for x, y in points) + history = bytes([prefix]) + header + point_table + payload = bytearray(FIXTURE.read_bytes() + _carpet_tail(8, 6, bytes(48)) + history + trailing) + payload[:2] = marker + return bytes(payload) + + def test_parse_carpet_mask_from_map_packet_tail() -> None: """A carpet mask after the erase section decodes to a same-dims grid. @@ -415,6 +471,82 @@ def test_parse_map_packet_without_carpet() -> None: assert parse_map_packet(FIXTURE.read_bytes()).carpet_mask is None +def test_classify_current_clean_record_and_saved_map_packets() -> None: + """All known map markers retain an explicit semantic kind.""" + current = FIXTURE.read_bytes() + clean_record = _map_detail_payload(b"\x03\x01", [(10, -20)]) + saved_map = _map_detail_payload(b"\x04\x01", [(10, -20)]) + + assert is_map_packet(current) + assert parse_map_packet(current).kind is Q10MapPacketKind.CURRENT + assert parse_map_packet(clean_record).kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL + assert parse_map_packet(saved_map).kind is Q10MapPacketKind.SAVED_MAP_DETAIL + + +def test_parse_clean_record_historical_trace_with_unknown_tail() -> None: + """The bounded historical path is decoded without interpreting later bytes.""" + packet = parse_clean_record_detail( + _map_detail_payload(b"\x03\x01", [(10, -20), (-30, 40)], trailing=b"future-section") + ) + + assert packet.trace is not None + assert [(point.x, point.y) for point in packet.trace.points] == [(10, -20), (-30, 40)] + assert packet.trace.heading == 3 + assert packet.trace.robot_position == Q10Point(-30, 40) + + +def test_zero_point_historical_trace_with_following_section() -> None: + """A zero-point path remains valid when a later section follows it.""" + packet = parse_clean_record_detail(_map_detail_payload(b"\x03\x01", [], trailing=b"recorded-path")) + + assert packet.trace is not None + assert packet.trace.points == [] + + +def test_historical_trace_is_not_inferred_for_other_packet_kinds() -> None: + """The validated ``03 01`` layout is not assumed for current or saved maps.""" + current = parse_map_packet(_map_detail_payload(b"\x01\x01", [(10, -20)])) + saved_map = parse_map_packet(_map_detail_payload(b"\x04\x01", [(10, -20)])) + + assert current.kind is Q10MapPacketKind.CURRENT + assert saved_map.kind is Q10MapPacketKind.SAVED_MAP_DETAIL + + +@pytest.mark.parametrize( + "kwargs", + [ + {"version": 2}, + {"reserved": 1}, + {"prefix": 1}, + ], +) +def test_unsupported_historical_trace_header_is_ignored(kwargs: dict[str, Any]) -> None: + payload = _map_detail_payload(b"\x03\x01", [(10, -20)], **kwargs) + packet = parse_clean_record_detail(payload) + + assert packet.trace is None + + +def test_truncated_historical_trace_is_ignored() -> None: + payload = _map_detail_payload(b"\x03\x01", [(10, -20)])[:-2] + packet = parse_clean_record_detail(payload) + + assert packet.trace is None + + +def test_invalid_erase_section_is_ignored() -> None: + """An invalid erase header cannot become an anchor for later sections.""" + tail = b"\x01\xffopaque-tail" + payload = bytearray(FIXTURE.read_bytes() + tail) + payload[:2] = b"\x03\x01" + + packet = parse_clean_record_detail(bytes(payload)) + + assert packet.map.erase_zones == [] + assert packet.map.carpet_mask is None + assert packet.trace is None + + def test_carpet_mask_ignored_when_uncompressed_len_mismatches() -> None: """If the section doesn't line up (uncompressed_len != w*h) carpet is dropped.""" carpet = bytes([4] * 48) @@ -473,3 +605,36 @@ def test_real_fixture_header_calibration_is_keepalive() -> None: """The synthetic fixture carries no header origin, so callers fall back to a fit.""" cal = parse_map_packet(FIXTURE.read_bytes()).header_calibration assert cal is not None and cal.is_keepalive + + +@pytest.mark.parametrize("payload", [b"", b"\x01", b"\x00\x01", b"\xff\x01", b"\x01\x02"]) +def test_unknown_map_markers_are_not_current_maps(payload: bytes) -> None: + assert Q10MapPacketKind.from_payload(payload) is None + with pytest.raises(RoborockException): + parse_map_packet(payload) + + +def test_map_kind_unknown_fallback() -> None: + assert Q10MapPacketKind(255) is Q10MapPacketKind.unknown + assert Q10MapPacketKind.unknown.marker == b"" + + +@pytest.mark.parametrize( + "points, expected", + [ + ([(0, 0), (1000, 1000), (1001, 1001), (1002, 1002)], [(1000, 1000), (1001, 1001), (1002, 1002)]), + ([(0, 0), (1, 1), (2, 2)], [(0, 0), (1, 1), (2, 2)]), + ([(0, 0), (1000, 1000)], [(0, 0), (1000, 1000)]), + ], +) +def test_clean_record_path_stray_point_handling(points: list[tuple[int, int]], expected: list[tuple[int, int]]) -> None: + detail = parse_clean_record_detail(_map_detail_payload(b"\x03\x01", points)) + assert detail.trace is not None + assert [(point.x, point.y) for point in detail.trace.points] == expected + assert detail.map.grid + + +@pytest.mark.parametrize("marker", [b"\x01\x01", b"\x02\x01", b"\x04\x01"]) +def test_clean_record_parser_rejects_other_packet_kinds(marker: bytes) -> None: + with pytest.raises(RoborockException, match="not a Q10 clean-record"): + parse_clean_record_detail(marker + FIXTURE.read_bytes()[2:]) diff --git a/tests/map/test_b01_q10_render.py b/tests/map/test_b01_q10_render.py index c8436aa2f..fed6b1eb2 100644 --- a/tests/map/test_b01_q10_render.py +++ b/tests/map/test_b01_q10_render.py @@ -16,8 +16,10 @@ from roborock.map.b01_grid_layers import GridCalibration from roborock.map.b01_q10_map_parser import ( B01Q10MapParserConfig, + Q10CleanRecordDetail, Q10EraseZone, Q10HeaderCalibration, + Q10HistoricalTracePacket, Q10MapPacket, Q10Point, Q10TracePacket, @@ -58,7 +60,7 @@ def _packet() -> Q10MapPacket: def _render( packet: Q10MapPacket | None = None, *, - trace: Q10TracePacket | None = None, + trace: Q10TracePacket | Q10HistoricalTracePacket | None = None, overlays: Q10MapOverlays | None = None, ) -> bytes: return render_q10_map( @@ -117,6 +119,16 @@ def test_render_draws_path_and_position() -> None: assert rendered.getpixel(image_position) == (255, 255, 255, 255) +def test_render_accepts_historical_trace() -> None: + """A validated clean-record path uses the same calibrated drawing path.""" + packet, live_trace = _calibrated_inputs() + historical = Q10HistoricalTracePacket(points=live_trace.points, heading=live_trace.heading) + + archived = Q10CleanRecordDetail(map=packet, trace=historical) + assert _render(archived.map, trace=archived.trace) == _render(packet, trace=live_trace) + assert _render(archived.map) != _render(archived.map, trace=archived.trace) + + def test_render_draws_zones_and_virtual_walls() -> None: """Decoded DPS overlays are included in the composed image.""" packet, trace = _calibrated_inputs() diff --git a/tests/protocols/test_b01_q10_protocol.py b/tests/protocols/test_b01_q10_protocol.py index db2a8097f..16fe9a108 100644 --- a/tests/protocols/test_b01_q10_protocol.py +++ b/tests/protocols/test_b01_q10_protocol.py @@ -15,7 +15,7 @@ from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint from roborock.data.code_mappings import completed_warnings from roborock.exceptions import RoborockException -from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket +from roborock.map.b01_q10_map_parser import Q10CleanRecordDetail, Q10MapPacket, Q10MapPacketKind, Q10TracePacket from roborock.protocols.b01_q10_protocol import ( CleanParams, Q10DpsUpdate, @@ -139,6 +139,27 @@ def test_decode_message_map_packet() -> None: assert {room.id: room.name for room in decoded.rooms} == {2: "Living Room", 3: "Bedroom"} +@pytest.mark.parametrize( + ("marker", "kind"), + [ + (b"\x03\x01", Q10MapPacketKind.CLEAN_RECORD_DETAIL), + (b"\x04\x01", Q10MapPacketKind.SAVED_MAP_DETAIL), + ], +) +def test_decode_message_archived_map_packet(marker: bytes, kind: Q10MapPacketKind) -> None: + """The decoder recognizes both archived map-detail markers.""" + fixture = MAP_FIXTURE.read_bytes() + decoded = decode_message(_message(marker + fixture[2:], RoborockMessageProtocol.MAP_RESPONSE)) + + if kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL: + assert isinstance(decoded, Q10CleanRecordDetail) + assert decoded.map.kind is kind + assert decoded.trace is None + else: + assert isinstance(decoded, Q10MapPacket) + assert decoded.kind is kind + + def test_decode_message_trace_packet() -> None: """A MAP_RESPONSE 02 01 payload decodes into a Q10TracePacket.""" message = _message(TRACE_FIXTURE.read_bytes(), RoborockMessageProtocol.MAP_RESPONSE)