Skip to content

Commit 2f2ed78

Browse files
author
Harry Coureau
committed
fix: use DPS conversion for Q10 room settings
1 parent e37ec5a commit 2f2ed78

5 files changed

Lines changed: 253 additions & 118 deletions

File tree

‎roborock/devices/traits/b01/q10/room_cleaning.py‎

Lines changed: 49 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,20 @@
22

33
import logging
44
from collections.abc import Sequence
5-
from dataclasses import dataclass
5+
from dataclasses import dataclass, field
66
from typing import Any
77

8-
from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
8+
from roborock.data.b01_q10.b01_q10_code_mappings import (
9+
B01_Q10_DP,
10+
Q10CleanCount,
11+
Q10RoomCleanType,
12+
Q10RoomFanLevel,
13+
YXCleanLine,
14+
YXWaterLevel,
15+
)
916
from roborock.data.b01_q10.b01_q10_containers import Q10RoomCleanSettings
1017
from roborock.data.containers import RoborockBase
18+
from roborock.devices.traits.common import DpsDataConverter
1119
from roborock.exceptions import RoborockException
1220
from roborock.protocols.b01_q10_protocol import decode_room_clean_settings, encode_room_clean_settings
1321

@@ -16,17 +24,52 @@
1624

1725
_LOGGER = logging.getLogger(__name__)
1826

27+
_ROOM_SETTING_MODES = (
28+
("fan_level", Q10RoomFanLevel, Q10RoomFanLevel.UNKNOWN.code),
29+
("water_level", YXWaterLevel, YXWaterLevel.UNKNOWN.code),
30+
("clean_type", Q10RoomCleanType, Q10RoomCleanType.UNKNOWN.code),
31+
("clean_count", Q10CleanCount, Q10CleanCount.UNKNOWN.code),
32+
("clean_line", YXCleanLine, YXCleanLine.UNKNOWN.code),
33+
)
34+
35+
36+
def _normalize_settings(
37+
records: list[dict[str, int]], current: list[Q10RoomCleanSettings] | None, complete: bool
38+
) -> list[dict[str, int]]:
39+
"""Normalize mode codes and merge compact records before model conversion."""
40+
settings = []
41+
for record in records:
42+
room = {"room_id": record["room_id"]}
43+
for field_name, mode_type, unknown_code in _ROOM_SETTING_MODES:
44+
code = record[field_name]
45+
room[field_name] = code if mode_type.from_code_optional(code) is not None else unknown_code
46+
settings.append(room)
47+
if complete:
48+
return settings
49+
50+
by_room = {
51+
room.room_id: {
52+
"room_id": room.room_id,
53+
**{field_name: getattr(room, field_name).code for field_name, _, _ in _ROOM_SETTING_MODES},
54+
}
55+
for room in (current or [])
56+
}
57+
by_room.update((room["room_id"], room) for room in settings)
58+
return list(by_room.values())
59+
1960

2061
@dataclass
2162
class RoomCleaning(RoborockBase):
2263
"""Current customized room-cleaning state."""
2364

24-
settings: list[Q10RoomCleanSettings] | None = None
65+
settings: list[Q10RoomCleanSettings] | None = field(default=None, metadata={"dps": B01_Q10_DP.CUSTOMER_CLEAN})
2566

2667

2768
class RoomCleaningTrait(RoomCleaning, UpdatableTrait):
2869
"""Read and control Q10 per-room cleaning settings."""
2970

71+
_CONVERTER = DpsDataConverter.from_dataclass(RoomCleaning)
72+
3073
def __init__(self, command: CommandTrait) -> None:
3174
RoomCleaning.__init__(self)
3275
UpdatableTrait.__init__(self, command, _LOGGER)
@@ -54,16 +97,9 @@ def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None:
5497
if not isinstance(payload, str):
5598
return
5699
try:
57-
update = decode_room_clean_settings(payload)
100+
records, complete = decode_room_clean_settings(payload)
58101
except RoborockException:
59102
_LOGGER.debug("Ignoring malformed Q10 customized-room settings", exc_info=True)
60103
return
61-
if update.complete:
62-
settings = list(update.settings)
63-
else:
64-
by_room = {room.room_id: room for room in (self.settings or [])}
65-
by_room.update((room.room_id, room) for room in update.settings)
66-
settings = list(by_room.values())
67-
if settings != self.settings:
68-
self.settings = settings
69-
self._notify_update()
104+
settings = _normalize_settings(records, self.settings, complete)
105+
super().update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: settings})

‎roborock/protocols/b01_q10_protocol.py‎

Lines changed: 21 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -92,14 +92,6 @@ def encode_clean_params(params: CleanParams) -> str:
9292
_Q10_CUSTOM_ROOM_NAME_SIZE = 20
9393

9494

95-
@dataclass(frozen=True)
96-
class Q10RoomCleanUpdate:
97-
"""Decoded Q10 customized-room settings push."""
98-
99-
settings: tuple[Q10RoomCleanSettings, ...]
100-
complete: bool
101-
102-
10395
def encode_room_clean_settings(settings: Sequence[Q10RoomCleanSettings]) -> str:
10496
"""Encode the compact six-byte-per-room ``dpCustomerClean`` write."""
10597
selected = tuple(settings)
@@ -131,8 +123,8 @@ def encode_room_clean_settings(settings: Sequence[Q10RoomCleanSettings]) -> str:
131123
return b64encode(payload).decode()
132124

133125

134-
def decode_room_clean_settings(payload: str) -> Q10RoomCleanUpdate:
135-
"""Decode a compact echo or complete ``dpCustomerClean`` response.
126+
def decode_room_clean_settings(payload: str) -> tuple[list[dict[str, int]], bool]:
127+
"""Decode room field dictionaries and whether a ``dpCustomerClean`` push is complete.
136128
137129
Complete records contain 26 property bytes, a 20-byte name block, one
138130
vertex-count byte, then four bytes per vertex. Relevant property offsets
@@ -147,7 +139,7 @@ def decode_room_clean_settings(payload: str) -> Q10RoomCleanUpdate:
147139

148140
count = raw[0]
149141
if count == 0 and len(raw) == 1:
150-
return Q10RoomCleanUpdate((), complete=True)
142+
return [], True
151143
if len(raw) == 1 + count * _Q10_CUSTOM_ROOM_COMPACT_SIZE:
152144
offset = 1
153145
rooms = []
@@ -158,17 +150,17 @@ def decode_room_clean_settings(payload: str) -> Q10RoomCleanUpdate:
158150
raise RoborockException("Invalid Q10 customized-room payload: duplicate room id")
159151
room_ids.add(room_id)
160152
rooms.append(
161-
Q10RoomCleanSettings(
162-
room_id=room_id,
163-
fan_level=(Q10RoomFanLevel.from_code_optional(raw[offset + 1]) or Q10RoomFanLevel.UNKNOWN),
164-
water_level=(YXWaterLevel.from_code_optional(raw[offset + 2]) or YXWaterLevel.UNKNOWN),
165-
clean_type=(Q10RoomCleanType.from_code_optional(raw[offset + 3]) or Q10RoomCleanType.UNKNOWN),
166-
clean_count=(Q10CleanCount.from_code_optional(raw[offset + 4]) or Q10CleanCount.UNKNOWN),
167-
clean_line=(YXCleanLine.from_code_optional(raw[offset + 5]) or YXCleanLine.UNKNOWN),
168-
)
153+
{
154+
"room_id": room_id,
155+
"fan_level": raw[offset + 1],
156+
"water_level": raw[offset + 2],
157+
"clean_type": raw[offset + 3],
158+
"clean_count": raw[offset + 4],
159+
"clean_line": raw[offset + 5],
160+
}
169161
)
170162
offset += _Q10_CUSTOM_ROOM_COMPACT_SIZE
171-
return Q10RoomCleanUpdate(tuple(rooms), complete=False)
163+
return rooms, False
172164

173165
offset = 1
174166
rooms = []
@@ -183,22 +175,22 @@ def decode_room_clean_settings(payload: str) -> Q10RoomCleanUpdate:
183175
room_ids.add(room_id)
184176
clean_count = int.from_bytes(raw[offset + 5 : offset + 7], "big")
185177
rooms.append(
186-
Q10RoomCleanSettings(
187-
room_id=room_id,
188-
fan_level=(Q10RoomFanLevel.from_code_optional(raw[offset + 8]) or Q10RoomFanLevel.UNKNOWN),
189-
water_level=(YXWaterLevel.from_code_optional(raw[offset + 9]) or YXWaterLevel.UNKNOWN),
190-
clean_type=(Q10RoomCleanType.from_code_optional(raw[offset + 7]) or Q10RoomCleanType.UNKNOWN),
191-
clean_count=(Q10CleanCount.from_code_optional(clean_count) or Q10CleanCount.UNKNOWN),
192-
clean_line=(YXCleanLine.from_code_optional(raw[offset + 11]) or YXCleanLine.UNKNOWN),
193-
)
178+
{
179+
"room_id": room_id,
180+
"fan_level": raw[offset + 8],
181+
"water_level": raw[offset + 9],
182+
"clean_type": raw[offset + 7],
183+
"clean_count": clean_count,
184+
"clean_line": raw[offset + 11],
185+
}
194186
)
195187
vertex_count = raw[offset + _Q10_CUSTOM_ROOM_PROPERTIES_SIZE + _Q10_CUSTOM_ROOM_NAME_SIZE]
196188
offset = minimum_end + vertex_count * 4
197189
if offset > len(raw):
198190
raise RoborockException("Invalid Q10 customized-room payload: truncated vertices")
199191
if offset != len(raw):
200192
raise RoborockException("Invalid Q10 customized-room payload: trailing data")
201-
return Q10RoomCleanUpdate(tuple(rooms), complete=True)
193+
return rooms, True
202194

203195

204196
_Q10_ZONE_RECORD_SIZE = 38

‎tests/devices/traits/b01/q10/test_room_cleaning.py‎

Lines changed: 127 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
"""Tests for customized Q10 room-cleaning commands and pushed settings."""
22

33
import base64
4+
import pathlib
5+
from dataclasses import replace
46

57
import pytest
68

@@ -52,7 +54,7 @@ async def test_set_settings_publishes_then_requests_full_settings(
5254
settings = (_settings(),)
5355
await q10_api.room_cleaning.set_settings(settings)
5456
assert fake_channel.published_commands == [
55-
(B01_Q10_DP.COMMON, {"62": encode_room_clean_settings(settings)}),
57+
(B01_Q10_DP.COMMON, {"62": "AQMDAwECAg=="}),
5658
(B01_Q10_DP.COMMON, {"63": 0}),
5759
]
5860
assert q10_api.room_cleaning.settings is None
@@ -137,3 +139,127 @@ def test_first_empty_push_is_reported(q10_api: Q10PropertiesApi) -> None:
137139
assert trait.settings == []
138140
assert trait.as_dict() == {"settings": []}
139141
assert notified == [True]
142+
143+
144+
@pytest.mark.parametrize("complete", [False, True])
145+
@pytest.mark.parametrize(
146+
("field", "compact_offset", "full_offset", "width"),
147+
[
148+
("fan_level", 1, 8, 1),
149+
("water_level", 2, 9, 1),
150+
("clean_type", 3, 7, 1),
151+
("clean_count", 4, 5, 2),
152+
("clean_line", 5, 11, 1),
153+
],
154+
)
155+
def test_unknown_mode_codes_use_enum_fallback(
156+
q10_api: Q10PropertiesApi, field: str, compact_offset: int, full_offset: int, width: int, complete: bool
157+
) -> None:
158+
trait = q10_api.room_cleaning
159+
payload = _complete_payload(_settings()) if complete else "AQMDAwECAg=="
160+
raw = bytearray(base64.b64decode(payload))
161+
offset = full_offset + 1 if complete else compact_offset + 1
162+
code_width = width if complete else 1
163+
raw[offset : offset + code_width] = (99).to_bytes(code_width, "big")
164+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: base64.b64encode(raw).decode()})
165+
expected = _settings()
166+
setattr(expected, field, type(getattr(expected, field)).UNKNOWN)
167+
assert trait.settings == [expected]
168+
# A compact update must preserve the cached unknown code during conversion.
169+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AQkDAwECAg=="})
170+
assert trait.settings == [expected, _settings(9)]
171+
172+
173+
@pytest.mark.parametrize("complete", [False, True])
174+
def test_zero_mode_codes_are_preserved(q10_api: Q10PropertiesApi, complete: bool) -> None:
175+
settings = replace(_settings(), water_level=YXWaterLevel.OFF, clean_line=YXCleanLine.FAST)
176+
payload = _complete_payload(settings) if complete else "AQMDAAECAA=="
177+
q10_api.room_cleaning.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: payload})
178+
assert q10_api.room_cleaning.settings == [settings]
179+
180+
181+
@pytest.mark.parametrize("populated", [False, True])
182+
@pytest.mark.parametrize("payload", [None, 1, {}, [], "invalid", "", "AQAA"])
183+
def test_invalid_push_does_not_change_settings(q10_api: Q10PropertiesApi, populated: bool, payload: object) -> None:
184+
trait = q10_api.room_cleaning
185+
if populated:
186+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AQMDAwECAg=="})
187+
before = trait.settings
188+
notified: list[bool] = []
189+
trait.add_update_listener(lambda: notified.append(True))
190+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: payload})
191+
trait.update_from_dps({B01_Q10_DP.BATTERY: 100})
192+
assert trait.settings == before
193+
assert not notified
194+
195+
196+
def test_malformed_later_record_is_atomic(q10_api: Q10PropertiesApi) -> None:
197+
trait = q10_api.room_cleaning
198+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AQMDAwECAg=="})
199+
notified: list[bool] = []
200+
trait.add_update_listener(lambda: notified.append(True))
201+
first = base64.b64decode(_complete_payload(_settings(9)))[1:]
202+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: base64.b64encode(b"\x02" + first + b"\x00").decode()})
203+
assert trait.settings == [_settings(3)]
204+
assert not notified
205+
206+
207+
def test_compact_update_preserves_existing_room_order(q10_api: Q10PropertiesApi) -> None:
208+
trait = q10_api.room_cleaning
209+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AgMDAwECAgkDAwECAg=="})
210+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AgkEAwECAgEBAwECAg=="})
211+
assert trait.settings == [
212+
_settings(3),
213+
_settings(9, fan=Q10RoomFanLevel.MAX),
214+
_settings(1, fan=Q10RoomFanLevel.QUIET),
215+
]
216+
217+
218+
def test_sanitized_full_capture_builds_typed_models(q10_api: Q10PropertiesApi) -> None:
219+
payload = (
220+
pathlib.Path("tests/protocols/testdata/b01_q10_protocol/customer_clean_full_sanitized.b64").read_text().strip()
221+
)
222+
q10_api.room_cleaning.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: payload})
223+
assert q10_api.room_cleaning.settings == [
224+
_settings(1, fan=Q10RoomFanLevel.QUIET),
225+
_settings(2, fan=Q10RoomFanLevel.MAX_PLUS),
226+
replace(
227+
_settings(3, fan=Q10RoomFanLevel.MAX_PLUS),
228+
water_level=YXWaterLevel.MEDIUM,
229+
clean_type=Q10RoomCleanType.VACUUM,
230+
),
231+
replace(
232+
_settings(4, fan=Q10RoomFanLevel.MAX_PLUS),
233+
water_level=YXWaterLevel.MEDIUM,
234+
clean_type=Q10RoomCleanType.VACUUM,
235+
),
236+
_settings(5, fan=Q10RoomFanLevel.QUIET),
237+
_settings(6, fan=Q10RoomFanLevel.MAX_PLUS),
238+
]
239+
240+
241+
@pytest.mark.parametrize("method", ["set_settings", "clean_rooms"])
242+
async def test_commands_leave_reported_settings_unchanged(q10_api: Q10PropertiesApi, method: str) -> None:
243+
q10_api.room_cleaning.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AQMDAwECAg=="})
244+
target = q10_api.room_cleaning if method == "set_settings" else q10_api.vacuum
245+
await getattr(target, method)((_settings(9),))
246+
assert q10_api.room_cleaning.settings == [_settings(3)]
247+
248+
249+
def test_populated_diagnostics_use_model_field_names_and_enum_labels(q10_api: Q10PropertiesApi) -> None:
250+
trait = q10_api.room_cleaning
251+
trait.update_from_dps({B01_Q10_DP.CUSTOMER_CLEAN: "AQMDAwECAg=="})
252+
expected = {
253+
"settings": [
254+
{
255+
"roomId": 3,
256+
"fanLevel": "turbo",
257+
"waterLevel": "high",
258+
"cleanType": "vac_and_mop",
259+
"cleanCount": "twice",
260+
"cleanLine": "fine",
261+
}
262+
]
263+
}
264+
assert trait.as_dict() == expected
265+
assert q10_api.as_dict()["room_cleaning"] == expected

‎tests/devices/traits/b01/q10/test_vacuum.py‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,6 @@
2424
from roborock.devices.traits.b01.q10.vacuum import VacuumTrait
2525
from roborock.exceptions import RoborockException
2626
from roborock.map.b01_q10_map_parser import Q10Point, Q10TracePacket
27-
from roborock.protocols.b01_q10_protocol import encode_room_clean_settings
2827

2928
from .conftest import FakeB01Q10Channel
3029

@@ -290,7 +289,7 @@ async def test_clean_rooms_sends_settings_mode_and_start_in_order(
290289
settings = (_room_settings(3), _room_settings(9))
291290
await q10_api.vacuum.clean_rooms(settings)
292291
assert fake_channel.published_commands == [
293-
(B01_Q10_DP.COMMON, {"62": encode_room_clean_settings(settings)}),
292+
(B01_Q10_DP.COMMON, {"62": "AgMDAwECAgkDAwECAg=="}),
294293
(B01_Q10_DP.CLEAN_MODE, 4),
295294
(B01_Q10_DP.START_CLEAN, {"cmd": 2, "clean_paramters": [3, 9]}),
296295
]
@@ -314,7 +313,14 @@ async def send(command, params=None):
314313
with pytest.raises(RoborockException, match="publish failed"):
315314
await q10_api.vacuum.clean_rooms((_room_settings(),))
316315
assert calls == fail_on
317-
assert len(fake_channel.published_commands) == fail_on - 1
316+
assert (
317+
fake_channel.published_commands
318+
== [
319+
(B01_Q10_DP.COMMON, {"62": "AQMDAwECAg=="}),
320+
(B01_Q10_DP.CLEAN_MODE, 4),
321+
(B01_Q10_DP.START_CLEAN, {"cmd": 2, "clean_paramters": [3]}),
322+
][: fail_on - 1]
323+
)
318324

319325

320326
async def test_clean_rooms_cancels_active_goto(

0 commit comments

Comments
 (0)