fix: changing code mappings

Author: humbertogontijo

roborock/api.py

@@ -23,8 +23,7 @@
 from roborock.exceptions import (
     RoborockException, RoborockTimeout, VacuumError,
 )
-from .code_mappings import RoborockDockType, \
-    STATE_CODE_TO_STATUS
+from .code_mappings import RoborockDockTypeCode
 from .containers import (
     UserData,
     Status,
@@ -131,15 +130,6 @@ async def on_message(self, messages: list[RoborockMessage]) -> None:
                                         await queue.async_put(
                                             (result, None), timeout=QUEUE_TIMEOUT
                                         )
-                        elif data_point_number == "121":
-                            status = STATE_CODE_TO_STATUS.get(data_point)
-                            _LOGGER.debug(f"Status updated to {status}")
-                            for listener in self._status_listeners:
-                                listener(data.seq, status)
-                        else:
-                            _LOGGER.debug(
-                                f"Unknown data point number received {data_point_number} with {data_point}"
-                            )
                 elif protocol == 301:
                     payload = data.payload[0:24]
                     [endpoint, _, request_id, _] = struct.unpack("<15sBH6s", payload)
@@ -205,13 +195,13 @@ async def send_command(
     async def get_status(self, device_id: str) -> Status:
         status = await self.send_command(device_id, RoborockCommand.GET_STATUS)
         if isinstance(status, dict):
-            return Status(status)
+            return Status.from_dict(status)
 
     async def get_dnd_timer(self, device_id: str) -> DNDTimer:
         try:
             dnd_timer = await self.send_command(device_id, RoborockCommand.GET_DND_TIMER)
             if isinstance(dnd_timer, dict):
-                return DNDTimer(dnd_timer)
+                return DNDTimer.from_dict(dnd_timer)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
@@ -221,9 +211,9 @@ async def get_clean_summary(self, device_id: str) -> CleanSummary:
                 device_id, RoborockCommand.GET_CLEAN_SUMMARY
             )
             if isinstance(clean_summary, dict):
-                return CleanSummary(clean_summary)
+                return CleanSummary.from_dict(clean_summary)
             elif isinstance(clean_summary, bytes):
-                return CleanSummary({"clean_time": clean_summary})
+                return CleanSummary(clean_time=int.from_bytes(clean_summary, 'big'))
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
@@ -233,46 +223,46 @@ async def get_clean_record(self, device_id: str, record_id: int) -> CleanRecord:
                 device_id, RoborockCommand.GET_CLEAN_RECORD, [record_id]
             )
             if isinstance(clean_record, dict):
-                return CleanRecord(clean_record)
+                return CleanRecord.from_dict(clean_record)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
     async def get_consumable(self, device_id: str) -> Consumable:
         try:
             consumable = await self.send_command(device_id, RoborockCommand.GET_CONSUMABLE)
             if isinstance(consumable, dict):
-                return Consumable(consumable)
+                return Consumable.from_dict(consumable)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
     async def get_wash_towel_mode(self, device_id: str) -> WashTowelMode:
         try:
             washing_mode = await self.send_command(device_id, RoborockCommand.GET_WASH_TOWEL_MODE)
             if isinstance(washing_mode, dict):
-                return WashTowelMode(washing_mode)
+                return WashTowelMode.from_dict(washing_mode)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
     async def get_dust_collection_mode(self, device_id: str) -> DustCollectionMode:
         try:
             dust_collection = await self.send_command(device_id, RoborockCommand.GET_DUST_COLLECTION_MODE)
             if isinstance(dust_collection, dict):
-                return DustCollectionMode(dust_collection)
+                return DustCollectionMode.from_dict(dust_collection)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
     async def get_smart_wash_params(self, device_id: str) -> SmartWashParams:
         try:
             mop_wash_mode = await self.send_command(device_id, RoborockCommand.GET_SMART_WASH_PARAMS)
             if isinstance(mop_wash_mode, dict):
-                return SmartWashParams(mop_wash_mode)
+                return SmartWashParams.from_dict(mop_wash_mode)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
-    async def get_dock_summary(self, device_id: str, dock_type: RoborockDockType) -> RoborockDockSummary:
+    async def get_dock_summary(self, device_id: str, dock_type: RoborockDockTypeCode) -> RoborockDockSummary:
         try:
             commands = [self.get_dust_collection_mode(device_id)]
-            if dock_type == RoborockDockType.EMPTY_WASH_FILL_DOCK:
+            if dock_type == RoborockDockTypeCode.EMPTY_WASH_FILL_DOCK:
                 commands += [self.get_wash_towel_mode(device_id), self.get_smart_wash_params(device_id)]
             [
                 dust_collection_mode,
@@ -302,7 +292,7 @@ async def get_prop(self, device_id: str) -> RoborockDeviceProp | None:
                 device_id, clean_summary.records[0]
             )
         dock_summary = None
-        if status and status.dock_type != RoborockDockType.NO_DOCK:
+        if status and status.dock_type != RoborockDockTypeCode.NO_DOCK:
             dock_summary = await self.get_dock_summary(device_id, status.dock_type)
         if any([status, dnd_timer, clean_summary, consumable]):
             return RoborockDeviceProp(
@@ -316,15 +306,15 @@ async def get_multi_maps_list(self, device_id) -> MultiMapsList:
                 device_id, RoborockCommand.GET_MULTI_MAPS_LIST
             )
             if isinstance(multi_maps_list, dict):
-                return MultiMapsList(multi_maps_list)
+                return MultiMapsList.from_dict(multi_maps_list)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
     async def get_networking(self, device_id) -> NetworkInfo:
         try:
             networking_info = await self.send_command(device_id, RoborockCommand.GET_NETWORK_INFO)
             if isinstance(networking_info, dict):
-                return NetworkInfo(networking_info)
+                return NetworkInfo.from_dict(networking_info)
         except RoborockTimeout as e:
             _LOGGER.error(e)
 
@@ -390,7 +380,7 @@ async def pass_login(self, password: str) -> UserData:
 
         if login_response.get("code") != 200:
             raise RoborockException(login_response.get("msg"))
-        return UserData(login_response.get("data"))
+        return UserData.from_dict(login_response.get("data"))
 
     async def code_login(self, code) -> UserData:
         base_url = await self._get_base_url()
@@ -409,7 +399,7 @@ async def code_login(self, code) -> UserData:
 
         if login_response.get("code") != 200:
             raise RoborockException(login_response.get("msg"))
-        return UserData(login_response.get("data"))
+        return UserData.from_dict(login_response.get("data"))
 
     async def get_home_data(self, user_data: UserData) -> HomeData:
         base_url = await self._get_base_url()
@@ -430,8 +420,8 @@ async def get_home_data(self, user_data: UserData) -> HomeData:
         nonce = secrets.token_urlsafe(6)
         prestr = ":".join(
             [
-                rriot.user,
-                rriot.password,
+                rriot.u,
+                rriot.s,
                 nonce,
                 str(timestamp),
                 hashlib.md5(("/user/homes/" + str(home_id)).encode()).hexdigest(),
@@ -440,17 +430,17 @@ async def get_home_data(self, user_data: UserData) -> HomeData:
             ]
         )
         mac = base64.b64encode(
-            hmac.new(rriot.h_unknown.encode(), prestr.encode(), hashlib.sha256).digest()
+            hmac.new(rriot.h.encode(), prestr.encode(), hashlib.sha256).digest()
         ).decode()
         home_request = PreparedRequest(
-            rriot.reference.api,
+            rriot.r.a,
             {
-                "Authorization": f'Hawk id="{rriot.user}", s="{rriot.password}", ts="{timestamp}", nonce="{nonce}", '
+                "Authorization": f'Hawk id="{rriot.u}", s="{rriot.s}", ts="{timestamp}", nonce="{nonce}", '
                                  f'mac="{mac}"',
             },
         )
         home_response = await home_request.request("get", "/user/homes/" + str(home_id))
         if not home_response.get("success"):
             raise RoborockException(home_response)
         home_data = home_response.get("result")
-        return HomeData(home_data)
+        return HomeData.from_dict(home_data)

roborock/cloud_api.py

@@ -35,25 +35,25 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
 
     def __init__(self, user_data: UserData, devices_info: dict[str, RoborockDeviceInfo]) -> None:
         rriot = user_data.rriot
-        endpoint = base64.b64encode(md5bin(rriot.endpoint)[8:14]).decode()
+        endpoint = base64.b64encode(md5bin(rriot.k)[8:14]).decode()
         RoborockClient.__init__(self, endpoint, devices_info)
         mqtt.Client.__init__(self, protocol=mqtt.MQTTv5)
-        self._mqtt_user = rriot.user
-        self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.endpoint)[2:10]
-        url = urlparse(rriot.reference.mqtt)
+        self._mqtt_user = rriot.u
+        self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.k)[2:10]
+        url = urlparse(rriot.r.m)
         self._mqtt_host = url.hostname
         self._mqtt_port = url.port
         self._mqtt_ssl = url.scheme == "ssl"
         if self._mqtt_ssl:
             super().tls_set()
-        self._mqtt_password = rriot.password
-        self._hashed_password = md5hex(self._mqtt_password + ":" + rriot.endpoint)[16:]
+        self._mqtt_password = rriot.s
+        self._hashed_password = md5hex(self._mqtt_password + ":" + rriot.k)[16:]
         super().username_pw_set(self._hashed_user, self._hashed_password)
         self._seq = 1
         self._random = 4711
         self._id_counter = 2
         self._salt = "TXdfu$jyZ#TZHsg4"
-        self._endpoint = base64.b64encode(md5bin(rriot.endpoint)[8:14]).decode()
+        self._endpoint = base64.b64encode(md5bin(rriot.k)[8:14]).decode()
         self._nonce = secrets.token_bytes(16)
         self._waiting_queue: dict[int, RoborockQueue] = {}
         self._mutex = Lock()