fix: removing local_api.py nonworking commands from api.py

Author: humbertogontijo

roborock/api.py

@@ -51,6 +51,7 @@
     RoborockCommand.GET_MAP_V1,
 ]
 
+
 def md5hex(message: str) -> str:
     md5 = hashlib.md5()
     md5.update(message.encode())
@@ -107,7 +108,7 @@ def _decode_msg(self, msg: bytes, local_key: str) -> dict[str, Any]:
         if self._prefixed:
             msg = msg[4:]
         if msg[0:3] != "1.0".encode():
-            raise RoborockException("Unknown protocol version")
+            raise RoborockException(f"Unknown protocol version {msg[0:3]}")
         if len(msg) == 17:
             [version, _seq, _random, timestamp, protocol] = struct.unpack(
                 "!3sIIIH", msg[0:17]
@@ -281,53 +282,75 @@ async def get_status(self, device_id: str) -> Status:
             return Status(status)
 
     async def get_dnd_timer(self, device_id: str) -> DNDTimer:
-        dnd_timer = await self.send_command(device_id, RoborockCommand.GET_DND_TIMER)
-        if isinstance(dnd_timer, dict):
-            return DNDTimer(dnd_timer)
+        try:
+            dnd_timer = await self.send_command(device_id, RoborockCommand.GET_DND_TIMER)
+            if isinstance(dnd_timer, dict):
+                return DNDTimer(dnd_timer)
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_clean_summary(self, device_id: str) -> CleanSummary:
-        clean_summary = await self.send_command(
-            device_id, RoborockCommand.GET_CLEAN_SUMMARY
-        )
-        if isinstance(clean_summary, dict):
-            return CleanSummary(clean_summary)
-        elif isinstance(clean_summary, bytes):
-            return CleanSummary({"clean_time": clean_summary})
+        try:
+            clean_summary = await self.send_command(
+                device_id, RoborockCommand.GET_CLEAN_SUMMARY
+            )
+            if isinstance(clean_summary, dict):
+                return CleanSummary(clean_summary)
+            elif isinstance(clean_summary, bytes):
+                return CleanSummary({"clean_time": clean_summary})
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_clean_record(self, device_id: str, record_id: int) -> CleanRecord:
-        clean_record = await self.send_command(
-            device_id, RoborockCommand.GET_CLEAN_RECORD, [record_id]
-        )
-        if isinstance(clean_record, dict):
-            return CleanRecord(clean_record)
+        try:
+            clean_record = await self.send_command(
+                device_id, RoborockCommand.GET_CLEAN_RECORD, [record_id]
+            )
+            if isinstance(clean_record, dict):
+                return CleanRecord(clean_record)
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_consumable(self, device_id: str) -> Consumable:
-        consumable = await self.send_command(device_id, RoborockCommand.GET_CONSUMABLE)
-        if isinstance(consumable, dict):
-            return Consumable(consumable)
+        try:
+            consumable = await self.send_command(device_id, RoborockCommand.GET_CONSUMABLE)
+            if isinstance(consumable, dict):
+                return Consumable(consumable)
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_washing_mode(self, device_id: str) -> RoborockDockWashingModeType:
-        washing_mode = await self.send_command(device_id, RoborockCommand.GET_WASH_TOWEL_MODE)
-        return WASH_MODE_MAP.get(washing_mode['wash_mode'])
+        try:
+            washing_mode = await self.send_command(device_id, RoborockCommand.GET_WASH_TOWEL_MODE)
+            return WASH_MODE_MAP.get(washing_mode['wash_mode'])
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_dust_collection_mode(self, device_id: str) -> RoborockDockDustCollectionType:
-        dust_collection = await self.send_command(device_id, RoborockCommand.GET_DUST_COLLECTION_MODE)
-        return DUST_COLLECTION_MAP.get(dust_collection['mode'])
+        try:
+            dust_collection = await self.send_command(device_id, RoborockCommand.GET_DUST_COLLECTION_MODE)
+            return DUST_COLLECTION_MAP.get(dust_collection['mode'])
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_mop_wash_mode(self, device_id: str) -> SmartWashParameters:
-        mop_wash_mode = await self.send_command(device_id, RoborockCommand.GET_SMART_WASH_PARAMS)
-        if isinstance(mop_wash_mode, dict):
-            return SmartWashParameters(mop_wash_mode)
+        try:
+            mop_wash_mode = await self.send_command(device_id, RoborockCommand.GET_SMART_WASH_PARAMS)
+            if isinstance(mop_wash_mode, dict):
+                return SmartWashParameters(mop_wash_mode)
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_dock_summary(self, device_id: str, dock_type: RoborockDockType) -> RoborockDockSummary:
-        collection_mode = await self.get_dust_collection_mode(device_id)
-        mop_wash = None
-        washing_mode = None
-        if dock_type == RoborockDockType.EMPTY_WASH_FILL_DOCK:
-            [mop_wash, washing_mode] = await asyncio.gather(
-                *[self.get_mop_wash_mode(device_id), self.get_washing_mode(device_id)])
+        try:
+            commands = [self.get_dust_collection_mode(device_id)]
+            if dock_type == RoborockDockType.EMPTY_WASH_FILL_DOCK:
+                commands += [self.get_mop_wash_mode(device_id), self.get_washing_mode(device_id)]
+            [collection_mode, mop_wash, washing_mode] = (list(await asyncio.gather(*commands)) + [None, None])[:3]
 
-        return RoborockDockSummary(collection_mode, washing_mode, mop_wash)
+            return RoborockDockSummary(collection_mode, washing_mode, mop_wash)
+        except RoborockTimeout as e:
+            _LOGGER.error(e)
 
     async def get_prop(self, device_id: str) -> RoborockDeviceProp:
         [status, dnd_timer, clean_summary, consumable] = await asyncio.gather(
@@ -338,17 +361,9 @@ async def get_prop(self, device_id: str) -> RoborockDeviceProp:
                 self.get_consumable(device_id),
             ]
         )
-        last_clean_record = None
-        # if clean_summary and clean_summary.records and len(clean_summary.records) > 0:
-        #     last_clean_record = await self.get_clean_record(
-        #         device_id, clean_summary.records[0]
-        #     )
-        dock_summary = None
-        if status and status.dock_type != RoborockDockType.NO_DOCK:
-            dock_summary = await self.get_dock_summary(device_id, status.dock_type)
         if any([status, dnd_timer, clean_summary, consumable]):
             return RoborockDeviceProp(
-                status, dnd_timer, clean_summary, consumable, last_clean_record, dock_summary
+                status, dnd_timer, clean_summary, consumable
             )
 
     async def get_multi_maps_list(self, device_id) -> MultiMapsList:

roborock/cloud_api.py

@@ -9,6 +9,7 @@
 from urllib.parse import urlparse
 
 import paho.mqtt.client as mqtt
+from roborock.code_mappings import RoborockDockType
 
 from roborock.api import md5hex, md5bin, RoborockClient, SPECIAL_COMMANDS
 from roborock.exceptions import (
@@ -21,7 +22,7 @@
 )
 from .roborock_queue import RoborockQueue
 from .typing import (
-    RoborockCommand,
+    RoborockCommand, RoborockDeviceProp,
 )
 from .util import run_in_executor
 
@@ -205,3 +206,17 @@ async def send_command(
         else:
             _LOGGER.debug(f"id={request_id} Response from {method}: {response}")
         return response
+
+    async def get_prop(self, device_id: str) -> RoborockDeviceProp:
+        device_prop = await super().get_prop(device_id)
+        last_clean_record = None
+        if device_prop.clean_summary and device_prop.clean_summary.records and len(device_prop.clean_summary.records) > 0:
+            last_clean_record = await self.get_clean_record(
+                device_id, device_prop.clean_summary.records[0]
+            )
+        device_prop.last_clean_record = last_clean_record
+        dock_summary = None
+        if device_prop.status and device_prop.status.dock_type != RoborockDockType.NO_DOCK:
+            dock_summary = await self.get_dock_summary(device_id, device_prop.status.dock_type)
+        device_prop.dock_summary = dock_summary
+        return device_prop

roborock/local_api.py

@@ -29,6 +29,7 @@ def __init__(self, ip: str, endpoint: str, device_localkey: dict[str, str]):
             device_id: RoborockSocketListener(ip, device_id, self.on_message)
             for device_id in device_localkey
         }
+        self._mutex = Lock()
 
     async def async_connect(self):
         await asyncio.gather(*[
@@ -39,28 +40,25 @@ async def async_connect(self):
     async def send_command(
             self, device_id: str, method: RoborockCommand, params: list = None
     ):
-        secured = True if method in SPECIAL_COMMANDS else False
-        request_id, timestamp, payload = self._get_payload(method, params, secured)
-        _LOGGER.debug(f"id={request_id} Requesting method {method} with {params}")
-        prefix = secured_prefix if method in SPECIAL_COMMANDS else get_prefix
-        protocol = 4
-        msg = self._encode_msg(device_id, protocol, timestamp, payload, prefix)
-        _LOGGER.debug(f"Requesting with prefix {prefix} and payload {payload}")
-        # Send the command to the Roborock device
-        listener = self.device_listener.get(device_id)
-        await listener.send_message(msg, self.device_localkey.get(device_id))
-        (response, err) = await self._async_response(request_id, 4)
-        if err:
-            raise CommandVacuumError(method, err) from err
-        _LOGGER.debug(f"id={request_id} Response from {method}: {response}")
-        return response
+        async with self._mutex:
+            secured = True if method in SPECIAL_COMMANDS else False
+            request_id, timestamp, payload = self._get_payload(method, params, secured)
+            _LOGGER.debug(f"id={request_id} Requesting method {method} with {params}")
+            prefix = secured_prefix if method in SPECIAL_COMMANDS else get_prefix
+            protocol = 4
+            msg = self._encode_msg(device_id, protocol, timestamp, payload, prefix)
+            # Send the command to the Roborock device
+            listener = self.device_listener.get(device_id)
+            await listener.send_message(msg)
+            (response, err) = await self._async_response(request_id, 4)
+            if err:
+                raise CommandVacuumError(method, err) from err
+            _LOGGER.debug(f"id={request_id} Response from {method}: {response}")
+            return response
 
 class RoborockSocket(socket.socket):
     _closed = None
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
     @property
     def is_closed(self):
         return self._closed
@@ -78,34 +76,37 @@ def __init__(self, ip: str, device_id: str, on_message: Callable[[str, bytes], C
         self.on_message = on_message
         self.timeout = timeout
         self.is_connected = False
-        self._lock = Lock()
+        self._mutex = Lock()
 
     async def _main_coro(self):
         while not self.socket.is_closed:
             try:
                 message = await self.loop.sock_recv(self.socket, 4096)
-                accepted = await self.on_message(self.device_id, message)
-                if accepted:
-                    self._lock.release() if self._lock.locked() else None
+                try:
+                    await self.on_message(self.device_id, message)
+                except Exception as e:
+                    _LOGGER.exception(e)
             except Exception as e:
                 _LOGGER.exception(e)
-                self.is_connected = False
-        await self.connect()
+                self.socket.close()
 
     async def connect(self):
-        async with async_timeout.timeout(self.timeout):
-            await self.loop.sock_connect(self.socket, (self.ip, 58867))
-            self.is_connected = True
-        self.loop.create_task(self._main_coro())
-
-    async def send_message(self, data: bytes, local_key: str):
+        async with self._mutex:
+            if not self.is_connected or self.socket.is_closed:
+                async with async_timeout.timeout(self.timeout):
+                    _LOGGER.info(f"Connecting to {self.ip}")
+                    await self.loop.sock_connect(self.socket, (self.ip, 58867))
+                    self.is_connected = True
+                self.loop.create_task(self._main_coro())
+
+    async def send_message(self, data: bytes):
         response = {}
+        await self.connect()
         try:
-            async with async_timeout.timeout(self.timeout):
-                await self._lock.acquire()
-                await self.loop.sock_sendall(self.socket, data)
+            async with self._mutex:
+                async with async_timeout.timeout(self.timeout):
+                    await self.loop.sock_sendall(self.socket, data)
         except (asyncio.TimeoutError, asyncio.CancelledError):
-            self._lock.release() if self._lock.locked() else None
             raise RoborockTimeout(
                 f"Timeout after {self.timeout} seconds waiting for response"
             ) from None

roborock/offline/offline.py

@@ -1,21 +1,31 @@
 import asyncio
+import logging
 
 from roborock.local_api import RoborockLocalClient
 from roborock.typing import RoborockCommand
 
-local_ip = "<device_ip>"
-local_key = "<device_localkey>"
+local_ip = "192.168.1.232"
+local_key = "nXTBj42ej5WxQopO"
 endpoint = "abc"
 
 
 async def main():
+    logging_config = {
+        "level": logging.DEBUG
+    }
+    logging.basicConfig(**logging_config)
     device_id = "1r9W0cAmDZ2COuVekgRhKA"
     client = RoborockLocalClient(local_ip, endpoint, {
         "1r9W0cAmDZ2COuVekgRhKA": local_key
     })
+    # print(client._decode_msg(bytes.fromhex('000000c7312e300000cf6a0000bff56424b659000400b0772b8ddc5645f5751d58d4a9805c37cc7c1989a5c76ca69130ce6672cbf27d231d9fb0a85ddb8eb2a999cc1f630f18f05f5425d6a291319c88da0851a3811f2646b0b5a34bd26a4f83c118d48340302383c9c9ee3b0063f3ad5a773f606ffd0358fdb573afa774859bfc993eea8b2695f3a5af5938a2af03b6be6b559f4bc9601ca65617838efdbc8ac5e30b8e7bcc06218f3cc5eb279263c44de63b506bb7953baf9288963ee987270d01b1b9481df058b2f161'), local_key))
     await client.async_connect()
-    response = await client.send_command(device_id, RoborockCommand.GET_STATUS)
-    print(response)
+    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)
 
 
 if __name__ == "__main__":