From b8bdf3a363b56c725a4b62db1461b9d2b032422c Mon Sep 17 00:00:00 2001 From: Harry Coureau Date: Sat, 29 Aug 2026 21:06:39 +0100 Subject: [PATCH 1/3] fix: request Q10 maps without starting cleaning --- roborock/cli.py | 27 +++------- roborock/devices/traits/b01/q10/map.py | 29 ++++------ tests/devices/traits/b01/q10/test_map.py | 67 ++++-------------------- 3 files changed, 27 insertions(+), 96 deletions(-) diff --git a/roborock/cli.py b/roborock/cli.py index 1969c5b7..a83caa15 100644 --- a/roborock/cli.py +++ b/roborock/cli.py @@ -594,9 +594,9 @@ async def maps(ctx, device_id: str): await _display_v1_trait(context, device_id, lambda v1: v1.maps) -# The Q10 publishes its map asynchronously after a dpMultiMap list/get request. -# Firmware throttles pushes to ~once per 60-70s, so rapid re-requests may not be -# answered immediately. This bounds how long a one-shot CLI command waits. +# The Q10 publishes its current map asynchronously after a REQUEST_DPS. Firmware +# throttles pushes to ~once per 60-70s, so rapid re-requests may not be answered +# immediately. This bounds how long a one-shot CLI command waits. _Q10_MAP_PUSH_TIMEOUT = 30.0 @@ -609,10 +609,9 @@ async def _await_q10_map_push( ) -> bool: """Request Q10 map content and wait for usable map-trait state. - A Q10 needs a saved-map ID before it can request content. The map list and - content have independent refresh schedules, so the list is requested only - when no ID is stored. The content then arrives as a later ``MAP_RESPONSE`` - and is published through the standard trait update interface. + The read-only ``REQUEST_DPS`` request returns immediately; current map + content arrives as a later ``MAP_RESPONSE`` and is published through the + standard trait update interface. """ loop = asyncio.get_running_loop() updated: asyncio.Future[None] = loop.create_future() @@ -624,20 +623,6 @@ def on_update() -> None: unsub = properties.map.add_update_listener(on_update) try: async with asyncio.timeout(timeout): - if properties.maps.current_map_id is None: - map_list_updated: asyncio.Future[None] = loop.create_future() - - def on_map_list_update() -> None: - if properties.maps.current_map_id is not None and not map_list_updated.done(): - map_list_updated.set_result(None) - - unsub_maps = properties.maps.add_update_listener(on_map_list_update) - try: - await properties.maps.refresh() - if properties.maps.current_map_id is None: - await map_list_updated - finally: - unsub_maps() await properties.map.refresh() await updated return True diff --git a/roborock/devices/traits/b01/q10/map.py b/roborock/devices/traits/b01/q10/map.py index 2d51e441..5890e688 100644 --- a/roborock/devices/traits/b01/q10/map.py +++ b/roborock/devices/traits/b01/q10/map.py @@ -7,10 +7,10 @@ * restricted zones, virtual walls and dock state arrive as ordinary DPS values. ``MapDpsTrait`` owns the low-level map-specific DPS read model. -``MapContentTrait`` uses a stored ID from ``MapsTrait`` only when it requests -content. It combines the latest map and trace packets with the map DPS state -through the pure functions in :mod:`roborock.map.b01_q10_render`. Map-list -updates do not refresh content. +``MapContentTrait`` requests a current-map push through ``REQUEST_DPS`` and +combines the latest map and trace packets with the map DPS state through the +pure functions in :mod:`roborock.map.b01_q10_render`. Saved-map list/detail +operations remain on ``MapsTrait``. """ import logging @@ -107,20 +107,13 @@ def __init__( self._map_dps.add_update_listener(self._map_dps_updated) async def refresh(self) -> None: - """Request content for the first map in the latest saved-map list.""" - if (map_id := self._maps.current_map_id) is None: - raise RoborockException("Cannot request Q10 map content before the map list is available") - # Map lists and map content can change at different times. Reuse the - # stored ID so a content refresh does not also refresh the list. - await self._command.send( - B01_Q10_DP.COMMON, - { - str(B01_Q10_DP.MULTI_MAP.code): { - "op": "get", - "id": map_id, - } - }, - ) + """Request a safe asynchronous current-map/status push. + + Some ss07 firmware treats ``dpMultiMap op:get`` as an active + cleaning/relocation command. ``REQUEST_DPS`` is the device's read-only + current-map request and does not depend on a saved-map ID. + """ + await self._command.send(B01_Q10_DP.REQUEST_DPS, params={}) @property def image_content(self) -> bytes | None: diff --git a/tests/devices/traits/b01/q10/test_map.py b/tests/devices/traits/b01/q10/test_map.py index 972123fe..ef6aa18f 100644 --- a/tests/devices/traits/b01/q10/test_map.py +++ b/tests/devices/traits/b01/q10/test_map.py @@ -140,34 +140,6 @@ async def refresh_map() -> None: self.map.refresh = refresh_map # type: ignore[method-assign] -class _FakeQ10PropertiesWithoutMapId: - def __init__(self) -> None: - command = cast(CommandTrait, Mock(spec=CommandTrait)) - self.maps = MapsTrait(command) - self.map = MapContentTrait(MapDpsTrait(), self.maps, command) - self.maps_refresh_count = 0 - self.map_refresh_count = 0 - - async def refresh_maps() -> None: - self.maps_refresh_count += 1 - self.maps.update_from_dps( - { - B01_Q10_DP.MULTI_MAP: { - "data": [{"id": "12345"}], - "op": "list", - "result": 1, - } - } - ) - - async def refresh_map() -> None: - self.map_refresh_count += 1 - self.map.update_from_trace_packet(parse_trace_packet(TRACE_SESSION_FIXTURE.read_bytes())) - - self.maps.refresh = refresh_maps # type: ignore[method-assign] - self.map.refresh = refresh_map # type: ignore[method-assign] - - async def test_await_q10_map_push_waits_for_fresh_update() -> None: """A cached trace alone is not treated as a successful new map push.""" properties = _FakeQ10Properties() @@ -196,21 +168,6 @@ async def test_await_q10_map_push_returns_true_after_update() -> None: assert len(properties.map.path) == 14 -async def test_await_q10_map_push_requests_map_list_only_on_first_use() -> None: - """Content gets the list first only when no stored map ID is available.""" - properties = _FakeQ10PropertiesWithoutMapId() - - got_trace = await _await_q10_map_push( - cast(Q10PropertiesApi, properties), - lambda: bool(properties.map.path), - timeout=0.01, - ) - - assert got_trace is True - assert properties.maps_refresh_count == 1 - assert properties.map_refresh_count == 1 - - async def test_await_q10_map_push_can_fall_back_to_cached_map_on_timeout() -> None: properties = _FakeQ10Properties() properties.map.update_from_map_packet(parse_map_packet(FIXTURE.read_bytes())) @@ -286,7 +243,7 @@ async def test_subscribe_loop_routes_trace_push( assert q10_api.map.robot_position is not None -async def test_map_list_and_content_refresh_are_independent( +async def test_map_list_and_current_content_refresh_are_independent( q10_api: Q10PropertiesApi, mock_channel: FakeB01Q10Channel, message_queue: asyncio.Queue[Q10Message], @@ -320,15 +277,7 @@ async def test_map_list_and_content_refresh_are_independent( await q10_api.map.refresh() - assert mock_channel.published_commands[1] == ( - B01_Q10_DP.COMMON, - { - str(B01_Q10_DP.MULTI_MAP.code): { - "op": "get", - "id": "12345", - } - }, - ) + assert mock_channel.published_commands[1] == (B01_Q10_DP.REQUEST_DPS, {}) assert q10_api.maps.current_map_id == "12345" @@ -355,10 +304,14 @@ async def test_empty_map_list_does_not_request_content( assert mock_channel.published_commands == [] -async def test_map_content_refresh_requires_stored_map_id(q10_api: Q10PropertiesApi) -> None: - """Content cannot be requested until the map list supplies an ID.""" - with pytest.raises(RoborockException, match="map list is available"): - await q10_api.map.refresh() +async def test_map_content_refresh_does_not_require_stored_map_id( + q10_api: Q10PropertiesApi, + mock_channel: FakeB01Q10Channel, +) -> None: + """Current-map refresh is read-only and independent of saved-map state.""" + await q10_api.map.refresh() + + assert mock_channel.published_commands == [(B01_Q10_DP.REQUEST_DPS, {})] async def test_map_content_refresh_requests_are_not_rate_limited(q10_api: Q10PropertiesApi) -> None: From 95d268e5373e44466cfff20bc815774ac4a431ff Mon Sep 17 00:00:00 2001 From: Harry Coureau Date: Mon, 31 Aug 2026 15:03:14 +0100 Subject: [PATCH 2/3] feat: parse Q10 archived map packets --- roborock/map/b01_q10_map_parser.py | 216 ++++++++++++++++++++--- roborock/map/b01_q10_render.py | 8 +- roborock/protocols/b01_q10_protocol.py | 17 +- tests/map/test_b01_q10_map_parser.py | 135 ++++++++++++++ tests/map/test_b01_q10_render.py | 11 +- tests/protocols/test_b01_q10_protocol.py | 18 +- 6 files changed, 362 insertions(+), 43 deletions(-) diff --git a/roborock/map/b01_q10_map_parser.py b/roborock/map/b01_q10_map_parser.py index 2f162c64..2c105e22 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 @@ -29,6 +31,7 @@ from vacuum_map_parser_base.config.image_config import ImageConfig from vacuum_map_parser_base.map_data import ImageData, MapData, Point +from roborock.data.code_mappings import RoborockEnum from roborock.data.containers import RoborockBase from roborock.exceptions import RoborockException @@ -66,9 +69,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, @@ -83,6 +83,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 @@ -194,10 +195,30 @@ def charger_pixels(self) -> tuple[float, float] | None: ) +class Q10MapPacketKind(RoborockEnum): + """Semantic kind identified by a Q10 map packet's two-byte marker.""" + + 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 bytes((self.value, 1)) + + @classmethod + def from_payload(cls, payload: bytes) -> "Q10MapPacketKind | None": + """Return the recognized kind for a payload marker.""" + return next((kind for kind in cls if payload[:2] == kind.marker), None) + + @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 @@ -211,6 +232,8 @@ class Q10MapPacket: """Carpet mask decoded from the packet tail: a full ``width*height`` grid in the same (top-down) pixel space as :attr:`grid`, where a non-zero cell is carpet (the value is the carpet kind). ``None`` if the packet carried none.""" + historical_trace: "Q10HistoricalTracePacket | None" = None + """Cleaning path embedded in a clean-record detail packet, if present.""" @property def layers(self) -> GridLayers: @@ -266,6 +289,27 @@ 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) + version: int = 0 + opaque_value: int = 0 + 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 + + # 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: @@ -275,18 +319,27 @@ 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_OPAQUE_VALUE_OFFSET = 2 +_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 @@ -301,12 +354,22 @@ 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_clean_record_map_packet(payload: bytes) -> bool: + """Return True for a Q10 clean-record detail (``03 01``) packet.""" + return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.CLEAN_RECORD_DETAIL + + +def is_saved_map_packet(payload: bytes) -> bool: + """Return True for a Q10 saved-map detail (``04 01``) packet.""" + return Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.SAVED_MAP_DETAIL 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: @@ -318,6 +381,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 = [ @@ -348,11 +414,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 | None = None) -> 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. When + ``max_output_size`` is supplied, expansion beyond it is rejected before + allocating the excess output. """ index = 0 output = bytearray() @@ -380,6 +448,8 @@ def read_length(value: int) -> int: end = index + literal_length if end > len(data): raise RoborockException("Truncated LZ4 block while reading literals") + if max_output_size is not None and len(output) + literal_length > max_output_size: + raise RoborockException("LZ4 block exceeds maximum output size") output.extend(data[index:end]) index = end @@ -394,6 +464,8 @@ def read_length(value: int) -> int: raise RoborockException("Invalid LZ4 back-reference offset") match_length = read_length(token & 0x0F) + 4 + if max_output_size is not None and len(output) + match_length > max_output_size: + raise RoborockException("LZ4 block exceeds maximum output size") for _ in range(match_length): output.append(output[-offset]) @@ -458,8 +530,9 @@ 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 a Q10 current or archived map into typed source data.""" + 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") @@ -467,6 +540,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" @@ -475,7 +550,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 @@ -486,9 +564,14 @@ 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) + if kind is Q10MapPacketKind.CLEAN_RECORD_DETAIL and carpet_end is not None: + historical_trace, _ = _parse_clean_record_trace(tail, carpet_end) + else: + historical_trace = None header_calibration = _parse_header_calibration(payload) return Q10MapPacket( + kind=kind, map_id=map_id, width=width, height=height, @@ -497,6 +580,7 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket: erase_zones=erase_zones, header_calibration=header_calibration, carpet_mask=carpet_mask, + historical_trace=historical_trace, ) @@ -569,7 +653,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]`` @@ -578,23 +673,88 @@ 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 - return mask if len(mask) == width * height else None + return None, None + if len(mask) != width * height: + return None, None + return mask, block_end + + +def _parse_carpet_mask(tail: bytes, width: int, height: int) -> bytes | None: + """Decode only the optional carpet mask (compatibility helper).""" + return _parse_carpet_block(tail, width, height)[0] + + +def _parse_clean_record_trace( + tail: bytes, + offset: int, +) -> tuple[Q10HistoricalTracePacket | None, int | 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, None + offset += _HISTORICAL_TRACE_PREFIX_LENGTH + header_end = offset + _HISTORICAL_TRACE_HEADER_LENGTH + if header_end > len(tail): + return None, 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, 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, None + coordinates = struct.iter_unpack(">hh", memoryview(tail)[header_end:points_end]) + return ( + Q10HistoricalTracePacket( + points=[Q10Point(x=x, y=y) for x, y in coordinates], + version=version, + opaque_value=int.from_bytes( + tail[ + offset + _HISTORICAL_TRACE_OPAQUE_VALUE_OFFSET : offset + _HISTORICAL_TRACE_OPAQUE_VALUE_OFFSET + 4 + ], + "big", + ), + heading=int.from_bytes( + tail[offset + _HISTORICAL_TRACE_HEADING_OFFSET : offset + _HISTORICAL_TRACE_HEADING_OFFSET + 2], + "big", + signed=True, + ), + ), + points_end, + ) 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 0e61452f..a24df43c 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 c0cf6b9b..864ca2b8 100644 --- a/roborock/protocols/b01_q10_protocol.py +++ b/roborock/protocols/b01_q10_protocol.py @@ -9,9 +9,8 @@ from roborock.exceptions import RoborockException from roborock.map.b01_q10_map_parser import ( Q10MapPacket, + Q10MapPacketKind, Q10TracePacket, - is_map_packet, - is_trace_packet, parse_map_packet, parse_trace_packet, ) @@ -113,18 +112,18 @@ class Q10DpsUpdate: 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): + if Q10MapPacketKind.from_payload(payload) is Q10MapPacketKind.TRACE: return parse_trace_packet(payload) + if Q10MapPacketKind.from_payload(payload) is not None: + return parse_map_packet(payload) return None return Q10DpsUpdate(dps=decode_rpc_response(message)) diff --git a/tests/map/test_b01_q10_map_parser.py b/tests/map/test_b01_q10_map_parser.py index c0200ff5..8b7a216c 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,9 +11,13 @@ 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_clean_record_map_packet, is_map_packet, + is_saved_map_packet, is_trace_packet, lz4_block_decompress, parse_map_packet, @@ -107,6 +112,13 @@ def test_lz4_block_back_reference() -> None: assert lz4_block_decompress(block) == 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: assert is_map_packet(b"\x01\x01rest") assert not is_map_packet(b"\x02\x01rest") # trace packet @@ -356,6 +368,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 +385,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 +418,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 +472,84 @@ 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 is_clean_record_map_packet(clean_record) + assert is_saved_map_packet(saved_map) + 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_map_packet(_map_detail_payload(b"\x03\x01", [(10, -20), (-30, 40)], trailing=b"future-section")) + + assert packet.historical_trace is not None + assert [(point.x, point.y) for point in packet.historical_trace.points] == [(10, -20), (-30, 40)] + assert packet.historical_trace.version == 1 + assert packet.historical_trace.opaque_value == 2 + assert packet.historical_trace.heading == 3 + assert packet.historical_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_map_packet(_map_detail_payload(b"\x03\x01", [], trailing=b"recorded-path")) + + assert packet.historical_trace is not None + assert packet.historical_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.historical_trace is None + assert saved_map.historical_trace is None + + +@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_map_packet(payload) + + assert packet.historical_trace is None + + +def test_truncated_historical_trace_is_ignored() -> None: + payload = _map_detail_payload(b"\x03\x01", [(10, -20)])[:-2] + packet = parse_map_packet(payload) + + assert packet.historical_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_map_packet(bytes(payload)) + + assert packet.erase_zones == [] + assert packet.carpet_mask is None + assert packet.historical_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) diff --git a/tests/map/test_b01_q10_render.py b/tests/map/test_b01_q10_render.py index c8436aa2..4dd9013d 100644 --- a/tests/map/test_b01_q10_render.py +++ b/tests/map/test_b01_q10_render.py @@ -18,6 +18,7 @@ B01Q10MapParserConfig, Q10EraseZone, Q10HeaderCalibration, + Q10HistoricalTracePacket, Q10MapPacket, Q10Point, Q10TracePacket, @@ -58,7 +59,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 +118,14 @@ 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) + + assert _render(packet, trace=historical) == _render(packet, trace=live_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 5fddc41a..adf62f8c 100644 --- a/tests/protocols/test_b01_q10_protocol.py +++ b/tests/protocols/test_b01_q10_protocol.py @@ -13,7 +13,7 @@ from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP, YXWaterLevel 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 Q10MapPacket, Q10MapPacketKind, Q10TracePacket from roborock.protocols.b01_q10_protocol import ( Q10DpsUpdate, decode_message, @@ -69,6 +69,22 @@ 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)) + + 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) From eaac14189e00d8612825e831820b89d25579b764 Mon Sep 17 00:00:00 2001 From: Harry Coureau Date: Mon, 31 Aug 2026 15:06:07 +0100 Subject: [PATCH 3/3] feat: expose Q10 map archives --- roborock/cli.py | 15 +- roborock/data/b01_q10/b01_q10_containers.py | 4 +- roborock/devices/device_manager.py | 8 +- roborock/devices/traits/b01/q10/__init__.py | 45 +++- .../devices/traits/b01/q10/clean_history.py | 84 ++++++- roborock/devices/traits/b01/q10/map.py | 33 ++- roborock/devices/traits/b01/q10/maps.py | 84 ++++++- .../traits/b01/q10/test_clean_history.py | 53 ++++ tests/devices/traits/b01/q10/test_map.py | 229 ++++++++++++++++-- 9 files changed, 505 insertions(+), 50 deletions(-) diff --git a/roborock/cli.py b/roborock/cli.py index a83caa15..f33a1a6b 100644 --- a/roborock/cli.py +++ b/roborock/cli.py @@ -597,12 +597,13 @@ async def maps(ctx, device_id: str): # The Q10 publishes its current map asynchronously after a REQUEST_DPS. Firmware # throttles pushes to ~once per 60-70s, so rapid re-requests may not be answered # immediately. This bounds how long a one-shot CLI command waits. -_Q10_MAP_PUSH_TIMEOUT = 30.0 +_Q10_MAP_PUSH_TIMEOUT = 75.0 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, @@ -615,9 +616,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) @@ -647,6 +649,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 @@ -695,8 +698,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() @@ -708,9 +711,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 @@ -873,6 +877,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 00384e09..c88aa4b7 100644 --- a/roborock/data/b01_q10/b01_q10_containers.py +++ b/roborock/data/b01_q10/b01_q10_containers.py @@ -88,7 +88,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 cdc8b0ae..0858d210 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 c2b66f71..d675b44b 100644 --- a/roborock/devices/traits/b01/q10/__init__.py +++ b/roborock/devices/traits/b01/q10/__init__.py @@ -8,7 +8,12 @@ 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, + Q10MapPacket, + Q10MapPacketKind, + Q10TracePacket, +) from roborock.protocols.b01_q10_protocol import Q10DpsUpdate, Q10Message from .button_light import ButtonLightTrait @@ -92,7 +97,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) @@ -107,9 +117,16 @@ 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.clean_history = CleanHistoryTrait(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, + ) # Read-model traits updated from the device's DPS push stream. self._updatable_traits = [ self.status, @@ -157,7 +174,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.CLEAN_RECORD_DETAIL: + self.clean_history.update_from_map_packet(message) + elif message.kind is Q10MapPacketKind.SAVED_MAP_DETAIL: + self.maps.update_from_map_packet(message) elif isinstance(message, Q10TracePacket): self.map.update_from_trace_packet(message) elif isinstance(message, Q10DpsUpdate): @@ -178,6 +200,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 fde2bb2f..224af7b6 100644 --- a/roborock/devices/traits/b01/q10/clean_history.py +++ b/roborock/devices/traits/b01/q10/clean_history.py @@ -22,6 +22,15 @@ 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, + 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 +124,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_packet: Q10MapPacket | 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 +159,47 @@ 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_trace(self) -> Q10HistoricalTracePacket | None: + """Historical path embedded in the selected clean-record detail.""" + return self.detail_packet.historical_trace if self.detail_packet 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 +210,25 @@ def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None: return self._apply(push) + def update_from_map_packet(self, packet: Q10MapPacket) -> None: + """Store and render a pushed clean-record detail map.""" + if packet.kind is not Q10MapPacketKind.CLEAN_RECORD_DETAIL: + raise ValueError(f"Expected a Q10 clean-record detail packet, got {packet.kind.value}") + self.detail_record = self._pending_detail_record + self._pending_detail_record = None + self.detail_packet = packet + try: + self.detail_image_content = render_q10_map( + packet, + packet.historical_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 5890e688..d7b52010 100644 --- a/roborock/devices/traits/b01/q10/map.py +++ b/roborock/devices/traits/b01/q10/map.py @@ -24,6 +24,7 @@ from roborock.map.b01_q10_map_parser import ( B01Q10MapParserConfig, Q10MapPacket, + Q10MapPacketKind, Q10Point, Q10Room, Q10TracePacket, @@ -33,7 +34,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} @@ -83,15 +83,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, @@ -99,11 +97,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: @@ -120,6 +119,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.""" @@ -142,18 +151,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 d0945776..9683d711 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/tests/devices/traits/b01/q10/test_clean_history.py b/tests/devices/traits/b01/q10/test_clean_history.py index 10fce2b6..fb4c78da 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_map_packet from .conftest import FakeB01Q10Channel @@ -175,3 +179,52 @@ 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_map_packet(b"\x03\x01" + fixture[2:]) + + clean_history.update_from_map_packet(packet) + + assert clean_history.detail_record is record + assert clean_history.detail_packet is packet diff --git a/tests/devices/traits/b01/q10/test_map.py b/tests/devices/traits/b01/q10/test_map.py index ef6aa18f..828ac540 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,6 +22,8 @@ from roborock.devices.traits.b01.q10.maps import MapsTrait from roborock.exceptions import RoborockException from roborock.map.b01_q10_map_parser import ( + B01Q10MapParserConfig, + Q10MapPacketKind, Q10Point, Q10TracePacket, parse_map_packet, @@ -38,19 +39,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 +74,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_map_packet(b"\x03\x01" + payload[2:]) + + with pytest.raises(ValueError, match="Expected a current Q10 map packet"): + _map_trait().update_from_map_packet(archived) + + 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()) @@ -120,7 +120,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: @@ -148,6 +148,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, ) @@ -161,6 +162,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, ) @@ -175,6 +177,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, ) @@ -230,6 +233,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_map_packet(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_map_packet(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_map_packet(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], @@ -332,6 +415,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( @@ -489,8 +672,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()) @@ -503,13 +686,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) @@ -519,7 +702,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