chore: fix cloud_api.py

Author: humbertogontijo

roborock/api.py

@@ -92,22 +92,21 @@ async def request(
 
 class RoborockClient:
 
-    def __init__(self, endpoint: str, device_localkey: dict[str, str], prefixed=False) -> None:
+    def __init__(self, endpoint: str, device_localkey: dict[str, str]) -> None:
         self.device_localkey = device_localkey
         self._seq = 1
         self._random = 4711
         self._id_counter = 10000
         self._salt = "TXdfu$jyZ#TZHsg4"
-        self._endpoint = base64.b64encode(md5bin(endpoint)[8:14]).decode()
+        self._endpoint = endpoint
         self._nonce = secrets.token_bytes(16)
-        self._prefixed = prefixed
         self._waiting_queue: dict[int, RoborockQueue] = {}
         self._status_listeners: list[Callable[[str, str], None]] = []
 
     def _decode_msg(self, msg: bytes, local_key: str) -> dict[str, Any]:
-        if self._prefixed:
+        if msg[4:7] == "1.0".encode():
             msg = msg[4:]
-        if msg[0:3] != "1.0".encode():
+        elif msg[0:3] != "1.0".encode():
             raise RoborockException(f"Unknown protocol version {msg[0:3]}")
         if len(msg) == 17:
             [version, _seq, _random, timestamp, protocol] = struct.unpack(
@@ -118,31 +117,27 @@ def _decode_msg(self, msg: bytes, local_key: str) -> dict[str, Any]:
                 "timestamp": timestamp,
                 "protocol": protocol,
             }
-        # crc32 = binascii.crc32(msg[0: len(msg) - 4])
         [version, _seq, _random, timestamp, protocol, payload_len] = struct.unpack(
             "!3sIIIHH", msg[0:19]
         )
-        if not payload_len:
-            return {
-                "version": version,
-                "timestamp": timestamp,
-                "protocol": protocol,
-            }
-        [payload, expected_crc32] = struct.unpack_from(f"!{payload_len}sI", msg, 19)
-        # if crc32 != expected_crc32:
-        #     raise RoborockException(f"Wrong CRC32 {crc32}, expected {expected_crc32}")
+        extra_len = len(msg) - 23 - payload_len
+        [payload, expected_crc32, extra] = struct.unpack_from(f"!{payload_len}sI{extra_len}s", msg, 19)
+        if not extra_len:
+            crc32 = binascii.crc32(msg[0: 19 + payload_len])
+            if crc32 != expected_crc32:
+                raise RoborockException(f"Wrong CRC32 {crc32}, expected {expected_crc32}")
 
         aes_key = md5bin(encode_timestamp(timestamp) + local_key + self._salt)
         decipher = AES.new(aes_key, AES.MODE_ECB)
-        decrypted_payload = unpad(decipher.decrypt(payload), AES.block_size)
+        decrypted_payload = unpad(decipher.decrypt(payload), AES.block_size) if payload else extra
         return {
             "version": version,
             "timestamp": timestamp,
             "protocol": protocol,
-            "payload": decrypted_payload,
+            "payload": decrypted_payload
         }
 
-    def _encode_msg(self, device_id, protocol, timestamp, payload, prefix='') -> bytes:
+    def _encode_msg(self, device_id, protocol, timestamp, payload, prefix=None) -> bytes:
         local_key = self.device_localkey[device_id]
         aes_key = md5bin(encode_timestamp(timestamp) + local_key + self._salt)
         cipher = AES.new(aes_key, AES.MODE_ECB)
@@ -157,13 +152,13 @@ def _encode_msg(self, device_id, protocol, timestamp, payload, prefix='') -> byt
             encrypted_len,
             encrypted
         ]
-        if self._prefixed:
+        if prefix:
             values = [prefix] + values
         msg = struct.pack(
-            f"!{'I' if self._prefixed else ''}3sIIIHH{encrypted_len}s",
+            f"!{'I' if prefix else ''}3sIIIHH{encrypted_len}s",
             *values
         )
-        crc32 = binascii.crc32(msg[4:] if self._prefixed else msg)
+        crc32 = binascii.crc32(msg[4:] if prefix else msg)
         msg += struct.pack("!I", crc32)
         return msg
 
@@ -258,7 +253,7 @@ def _get_payload(
         if secured:
             inner["security"] = {
                 "endpoint": self._endpoint,
-                "nonce": "39344139463753454b4851444f4a4442",
+                "nonce": self._nonce.hex().upper(),
             }
         payload = bytes(
             json.dumps(

roborock/cloud_api.py

@@ -36,9 +36,10 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
 
     def __init__(self, user_data: UserData, device_localkey: dict[str, str]) -> None:
         rriot = user_data.rriot
-        self._mqtt_user = rriot.user
-        RoborockClient.__init__(self, rriot.endpoint, device_localkey)
+        endpoint = base64.b64encode(md5bin(rriot.endpoint)[8:14]).decode()
+        RoborockClient.__init__(self, endpoint, device_localkey)
         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_host = url.hostname
@@ -94,7 +95,7 @@ async def on_message(self, _client, _, msg, __=None) -> None:
         async with self._mutex:
             self._last_device_msg_in = mqtt.time_func()
         device_id = msg.topic.split("/").pop()
-        super().on_message(device_id, msg)
+        await super().on_message(device_id, msg.payload)
 
     @run_in_executor()
     async def on_disconnect(self, _client: mqtt.Client, _, rc, __=None) -> None:

roborock/local_api.py

@@ -23,8 +23,8 @@
 
 class RoborockLocalClient(RoborockClient):
 
-    def __init__(self, ip: str, endpoint: str, device_localkey: dict[str, str]):
-        super().__init__(endpoint, device_localkey, True)
+    def __init__(self, ip: str, device_localkey: dict[str, str]):
+        super().__init__("abc", device_localkey)
         self.device_listener: dict[str, RoborockSocketListener] = {
             device_id: RoborockSocketListener(ip, device_id, self.on_message)
             for device_id in device_localkey

roborock/offline/offline.py

@@ -2,11 +2,9 @@
 import logging
 
 from roborock.local_api import RoborockLocalClient
-from roborock.typing import RoborockCommand
 
-local_ip = "192.168.1.232"
-local_key = "nXTBj42ej5WxQopO"
-endpoint = "abc"
+local_ip = "<local_ip>"
+local_key = "<local_key>"
 
 
 async def main():
@@ -15,17 +13,12 @@ async def main():
     }
     logging.basicConfig(**logging_config)
     device_id = "1r9W0cAmDZ2COuVekgRhKA"
-    client = RoborockLocalClient(local_ip, endpoint, {
+    client = RoborockLocalClient(local_ip, {
         "1r9W0cAmDZ2COuVekgRhKA": local_key
     })
-    # print(client._decode_msg(bytes.fromhex('000000c7312e300000cf6a0000bff56424b659000400b0772b8ddc5645f5751d58d4a9805c37cc7c1989a5c76ca69130ce6672cbf27d231d9fb0a85ddb8eb2a999cc1f630f18f05f5425d6a291319c88da0851a3811f2646b0b5a34bd26a4f83c118d48340302383c9c9ee3b0063f3ad5a773f606ffd0358fdb573afa774859bfc993eea8b2695f3a5af5938a2af03b6be6b559f4bc9601ca65617838efdbc8ac5e30b8e7bcc06218f3cc5eb279263c44de63b506bb7953baf9288963ee987270d01b1b9481df058b2f161'), local_key))
     await client.async_connect()
-    dnd_timer = await client.get_clean_record(device_id, 1680313530)
-    print(dnd_timer)
-    # clean_summary = await client.get_clean_summary(device_id)
-    # print(clean_summary)
-    # consumable = await client.get_consumable(device_id)
-    # print(consumable)
+    props = await client.get_prop(device_id)
+    print(props)
 
 
 if __name__ == "__main__":