pymammotion 0.2.29__py3-none-any.whl → 0.2.31__py3-none-any.whl

pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -0,0 +1,447 @@
+import asyncio
+import logging
+from typing import Any, cast
+from uuid import UUID
+
+import betterproto
+from bleak import BleakGATTCharacteristic, BleakGATTServiceCollection, BLEDevice
+from bleak.exc import BleakDBusError
+from bleak_retry_connector import (
+    BLEAK_RETRY_EXCEPTIONS,
+    BleakClientWithServiceCache,
+    BleakNotFoundError,
+    establish_connection,
+)
+
+from pymammotion.bluetooth import BleMessage
+from pymammotion.data.model.device import MowingDevice
+from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
+from pymammotion.mammotion.devices.base import MammotionBaseDevice
+from pymammotion.proto import has_field
+from pymammotion.proto.luba_msg import LubaMsg
+
+DBUS_ERROR_BACKOFF_TIME = 0.25
+
+DISCONNECT_DELAY = 10
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CharacteristicMissingError(Exception):
+    """Raised when a characteristic is missing."""
+
+
+def _sb_uuid(comms_type: str = "service") -> UUID | str:
+    """Return Mammotion UUID.
+
+    Args:
+        comms_type (str): The type of communication (tx, rx, or service).
+
+    Returns:
+        UUID | str: The UUID for the specified communication type or an error message.
+
+    """
+    _uuid = {"tx": "ff01", "rx": "ff02", "service": "2A05"}
+
+    if comms_type in _uuid:
+        return UUID(f"0000{_uuid[comms_type]}-0000-1000-8000-00805f9b34fb")
+
+    return "Incorrect type, choose between: tx, rx or service"
+
+
+READ_CHAR_UUID = _sb_uuid(comms_type="rx")
+WRITE_CHAR_UUID = _sb_uuid(comms_type="tx")
+
+
+def _handle_timeout(fut: asyncio.Future[None]) -> None:
+    """Handle a timeout."""
+    if not fut.done():
+        fut.set_exception(asyncio.TimeoutError)
+
+
+async def _handle_retry(fut: asyncio.Future[None], func, command: bytes) -> None:
+    """Handle a retry."""
+    if not fut.done():
+        await func(command)
+
+
+class MammotionBaseBLEDevice(MammotionBaseDevice):
+    """Base class for Mammotion BLE devices."""
+
+    def __init__(self, mowing_state: MowingDevice, device: BLEDevice, interface: int = 0, **kwargs: Any) -> None:
+        """Initialize MammotionBaseBLEDevice."""
+        super().__init__(mowing_state)
+        self._disconnect_strategy = True
+        self._ble_sync_task = None
+        self._prev_notification = None
+        self._interface = f"hci{interface}"
+        self._device = device
+        self._mower = mowing_state
+        self._client: BleakClientWithServiceCache | None = None
+        self._read_char: BleakGATTCharacteristic | int | str | UUID = 0
+        self._write_char: BleakGATTCharacteristic | int | str | UUID = 0
+        self._disconnect_timer: asyncio.TimerHandle | None = None
+        self._message: BleMessage | None = None
+        self._commands: MammotionCommand = MammotionCommand(device.name)
+        self._expected_disconnect = False
+        self._connect_lock = asyncio.Lock()
+        self._operation_lock = asyncio.Lock()
+        self._key: str | None = None
+
+    def update_device(self, device: BLEDevice) -> None:
+        """Update the BLE device."""
+        self._device = device
+
+    async def _ble_sync(self) -> None:
+        command_bytes = self._commands.send_todev_ble_sync(2)
+        await self._message.post_custom_data_bytes(command_bytes)
+
+    async def run_periodic_sync_task(self) -> None:
+        """Send ble sync to robot."""
+        try:
+            await self._ble_sync()
+        finally:
+            self.schedule_ble_sync()
+
+    def schedule_ble_sync(self) -> None:
+        """Periodically sync to keep connection alive."""
+        if self._client is not None and self._client.is_connected:
+            self._ble_sync_task = self.loop.call_later(
+                130, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
+            )
+
+    async def queue_command(self, key: str, **kwargs: Any) -> bytes | None:
+        return await self._send_command_with_args(key, **kwargs)
+
+    async def _send_command_with_args(self, key: str, **kwargs) -> bytes | None:
+        """Send command to device and read response."""
+        if self._operation_lock.locked():
+            _LOGGER.debug(
+                "%s: Operation already in progress, waiting for it to complete; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+        async with self._operation_lock:
+            try:
+                command_bytes = getattr(self._commands, key)(**kwargs)
+                return await self._send_command_locked(key, command_bytes)
+            except BleakNotFoundError:
+                _LOGGER.exception(
+                    "%s: device not found, no longer in range, or poor RSSI: %s",
+                    self.name,
+                    self.rssi,
+                )
+                raise
+            except CharacteristicMissingError as ex:
+                _LOGGER.debug(
+                    "%s: characteristic missing: %s; RSSI: %s",
+                    self.name,
+                    ex,
+                    self.rssi,
+                    exc_info=True,
+                )
+            except BLEAK_RETRY_EXCEPTIONS:
+                _LOGGER.debug("%s: communication failed with:", self.name, exc_info=True)
+        return
+
+    async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
+        """Send command to device and read response."""
+        if self._operation_lock.locked():
+            _LOGGER.debug(
+                "%s: Operation already in progress, waiting for it to complete; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+        async with self._operation_lock:
+            try:
+                command_bytes = getattr(self._commands, key)()
+                return await self._send_command_locked(key, command_bytes)
+            except BleakNotFoundError:
+                _LOGGER.exception(
+                    "%s: device not found, no longer in range, or poor RSSI: %s",
+                    self.name,
+                    self.rssi,
+                )
+                raise
+            except CharacteristicMissingError as ex:
+                _LOGGER.debug(
+                    "%s: characteristic missing: %s; RSSI: %s",
+                    self.name,
+                    ex,
+                    self.rssi,
+                    exc_info=True,
+                )
+            except BLEAK_RETRY_EXCEPTIONS:
+                _LOGGER.debug("%s: communication failed with:", self.name, exc_info=True)
+        return
+
+    @property
+    def name(self) -> str:
+        """Return device name."""
+        return f"{self._device.name} ({self._device.address})"
+
+    @property
+    def rssi(self) -> int:
+        """Return RSSI of device."""
+        try:
+            return cast(self._mower.sys.toapp_report_data.connect.ble_rssi, int)
+        finally:
+            return 0
+
+    async def _ensure_connected(self) -> None:
+        """Ensure connection to device is established."""
+        if self._connect_lock.locked():
+            _LOGGER.debug(
+                "%s: Connection already in progress, waiting for it to complete; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+        if self._client and self._client.is_connected:
+            _LOGGER.debug(
+                "%s: Already connected before obtaining lock, resetting timer; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+            self._reset_disconnect_timer()
+            return
+        async with self._connect_lock:
+            # Check again while holding the lock
+            if self._client and self._client.is_connected:
+                _LOGGER.debug(
+                    "%s: Already connected after obtaining lock, resetting timer; RSSI: %s",
+                    self.name,
+                    self.rssi,
+                )
+                self._reset_disconnect_timer()
+                return
+            _LOGGER.debug("%s: Connecting; RSSI: %s", self.name, self.rssi)
+            client: BleakClientWithServiceCache = await establish_connection(
+                BleakClientWithServiceCache,
+                self._device,
+                self.name,
+                self._disconnected,
+                max_attempts=10,
+                ble_device_callback=lambda: self._device,
+            )
+            _LOGGER.debug("%s: Connected; RSSI: %s", self.name, self.rssi)
+            self._client = client
+            self._message = BleMessage(client)
+
+            try:
+                self._resolve_characteristics(client.services)
+            except CharacteristicMissingError as ex:
+                _LOGGER.debug(
+                    "%s: characteristic missing, clearing cache: %s; RSSI: %s",
+                    self.name,
+                    ex,
+                    self.rssi,
+                    exc_info=True,
+                )
+                await client.clear_cache()
+                self._cancel_disconnect_timer()
+                await self._execute_disconnect_with_lock()
+                raise
+
+            _LOGGER.debug(
+                "%s: Starting notify and disconnect timer; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+            self._reset_disconnect_timer()
+            await self._start_notify()
+            command_bytes = self._commands.send_todev_ble_sync(2)
+            await self._message.post_custom_data_bytes(command_bytes)
+            self.schedule_ble_sync()
+
+    async def _send_command_locked(self, key: str, command: bytes) -> bytes:
+        """Send command to device and read response."""
+        await self._ensure_connected()
+        try:
+            return await self._execute_command_locked(key, command)
+        except BleakDBusError as ex:
+            # Disconnect so we can reset state and try again
+            await asyncio.sleep(DBUS_ERROR_BACKOFF_TIME)
+            _LOGGER.debug(
+                "%s: RSSI: %s; Backing off %ss; Disconnecting due to error: %s",
+                self.name,
+                self.rssi,
+                DBUS_ERROR_BACKOFF_TIME,
+                ex,
+            )
+            await self._execute_forced_disconnect()
+            raise
+        except BLEAK_RETRY_EXCEPTIONS as ex:
+            # Disconnect so we can reset state and try again
+            _LOGGER.debug("%s: RSSI: %s; Disconnecting due to error: %s", self.name, self.rssi, ex)
+            await self._execute_forced_disconnect()
+            raise
+
+    async def _notification_handler(self, _sender: BleakGATTCharacteristic, data: bytearray) -> None:
+        """Handle notification responses."""
+        if self._message is None:
+            return
+        result = self._message.parseNotification(data)
+        if result == 0:
+            data = await self._message.parseBlufiNotifyData(True)
+            self._update_raw_data(data)
+            self._message.clearNotification()
+            _LOGGER.debug("%s: Received notification: %s", self.name, data)
+        else:
+            return
+        new_msg = LubaMsg().parse(data)
+        if betterproto.serialized_on_wire(new_msg.net):
+            if new_msg.net.todev_ble_sync != 0 or has_field(new_msg.net.toapp_wifi_iot_status):
+                if has_field(new_msg.net.toapp_wifi_iot_status) and self._commands.get_device_product_key() == "":
+                    self._commands.set_device_product_key(new_msg.net.toapp_wifi_iot_status.productkey)
+
+                return
+
+        # may or may not be correct, some work could be done here to correctly match responses
+        if self._notify_future and not self._notify_future.done():
+            self._notify_future.set_result(data)
+
+        self._reset_disconnect_timer()
+        await self._state_manager.notification(new_msg)
+
+    async def _start_notify(self) -> None:
+        """Start notification."""
+        _LOGGER.debug("%s: Subscribe to notifications; RSSI: %s", self.name, self.rssi)
+        await self._client.start_notify(self._read_char, self._notification_handler)
+
+    async def _execute_command_locked(self, key: str, command: bytes) -> bytes:
+        """Execute command and read response."""
+        assert self._client is not None
+        self._notify_future = self.loop.create_future()
+        self._key = key
+        _LOGGER.debug("%s: Sending command: %s", self.name, key)
+        await self._message.post_custom_data_bytes(command)
+
+        timeout = 2
+        timeout_handle = self.loop.call_at(self.loop.time() + timeout, _handle_timeout, self._notify_future)
+        timeout_expired = False
+        try:
+            notify_msg = await self._notify_future
+        except asyncio.TimeoutError:
+            timeout_expired = True
+            notify_msg = b""
+        finally:
+            if not timeout_expired:
+                timeout_handle.cancel()
+            self._notify_future = None
+
+        _LOGGER.debug("%s: Notification received: %s", self.name, notify_msg.hex())
+        return notify_msg
+
+    def get_address(self) -> str:
+        """Return address of device."""
+        return self._device.address
+
+    def _resolve_characteristics(self, services: BleakGATTServiceCollection) -> None:
+        """Resolve characteristics."""
+        self._read_char = services.get_characteristic(READ_CHAR_UUID)
+        if not self._read_char:
+            self._read_char = READ_CHAR_UUID
+            _LOGGER.error(CharacteristicMissingError(READ_CHAR_UUID))
+        self._write_char = services.get_characteristic(WRITE_CHAR_UUID)
+        if not self._write_char:
+            self._write_char = WRITE_CHAR_UUID
+            _LOGGER.error(CharacteristicMissingError(WRITE_CHAR_UUID))
+
+    def _reset_disconnect_timer(self) -> None:
+        """Reset disconnect timer."""
+        self._cancel_disconnect_timer()
+        self._expected_disconnect = False
+        self._disconnect_timer = self.loop.call_later(DISCONNECT_DELAY, self._disconnect_from_timer)
+
+    def _disconnected(self, client: BleakClientWithServiceCache) -> None:
+        """Disconnected callback."""
+        if self._expected_disconnect:
+            _LOGGER.debug("%s: Disconnected from device; RSSI: %s", self.name, self.rssi)
+            return
+        _LOGGER.warning(
+            "%s: Device unexpectedly disconnected; RSSI: %s",
+            self.name,
+            self.rssi,
+        )
+        self._cancel_disconnect_timer()
+
+    def _disconnect_from_timer(self) -> None:
+        """Disconnect from device."""
+        if self._operation_lock.locked() and self._client.is_connected:
+            _LOGGER.debug(
+                "%s: Operation in progress, resetting disconnect timer; RSSI: %s",
+                self.name,
+                self.rssi,
+            )
+            self._reset_disconnect_timer()
+            return
+        self._cancel_disconnect_timer()
+        self._timed_disconnect_task = asyncio.create_task(self._execute_timed_disconnect())
+
+    def _cancel_disconnect_timer(self) -> None:
+        """Cancel disconnect timer."""
+        if self._disconnect_timer:
+            self._disconnect_timer.cancel()
+            self._disconnect_timer = None
+
+    async def _execute_forced_disconnect(self) -> None:
+        """Execute forced disconnection."""
+        self._cancel_disconnect_timer()
+        _LOGGER.debug(
+            "%s: Executing forced disconnect",
+            self.name,
+        )
+        await self._execute_disconnect()
+
+    async def _execute_timed_disconnect(self) -> None:
+        """Execute timed disconnection."""
+        if not self._disconnect_strategy:
+            return
+        _LOGGER.debug(
+            "%s: Executing timed disconnect after timeout of %s",
+            self.name,
+            DISCONNECT_DELAY,
+        )
+        await self._execute_disconnect()
+
+    async def _execute_disconnect(self) -> None:
+        """Execute disconnection."""
+        _LOGGER.debug("%s: Executing disconnect", self.name)
+        async with self._connect_lock:
+            await self._execute_disconnect_with_lock()
+
+    async def _execute_disconnect_with_lock(self) -> None:
+        """Execute disconnection while holding the lock."""
+        assert self._connect_lock.locked(), "Lock not held"
+        _LOGGER.debug("%s: Executing disconnect with lock", self.name)
+        if self._disconnect_timer:  # If the timer was reset, don't disconnect
+            _LOGGER.debug("%s: Skipping disconnect as timer reset", self.name)
+            return
+        client = self._client
+        self._expected_disconnect = True
+
+        if not client:
+            _LOGGER.debug("%s: Already disconnected", self.name)
+            return
+        _LOGGER.debug("%s: Disconnecting", self.name)
+        try:
+            """We reset what command the robot last heard before disconnecting."""
+            if client is not None and client.is_connected:
+                command_bytes = self._commands.send_todev_ble_sync(2)
+                await self._message.post_custom_data_bytes(command_bytes)
+                await client.stop_notify(self._read_char)
+                await client.disconnect()
+        except BLEAK_RETRY_EXCEPTIONS as ex:
+            _LOGGER.warning(
+                "%s: Error disconnecting: %s; RSSI: %s",
+                self.name,
+                ex,
+                self.rssi,
+            )
+        else:
+            _LOGGER.debug("%s: Disconnect completed successfully", self.name)
+        self._client = None
+
+    def set_disconnect_strategy(self, disconnect: bool) -> None:
+        self._disconnect_strategy = disconnect

pymammotion/mammotion/devices/mammotion_cloud.py

@@ -0,0 +1,246 @@
+import asyncio
+import base64
+import json
+import logging
+from collections import deque
+from typing import Any, Awaitable, Callable, Optional, cast
+
+import betterproto
+
+from pymammotion import MammotionMQTT
+from pymammotion.aliyun.dataclass.dev_by_account_response import Device
+from pymammotion.data.model.device import MowingDevice
+from pymammotion.data.mqtt.event import ThingEventMessage
+from pymammotion.event.event import DataEvent
+from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
+from pymammotion.mammotion.devices.base import MammotionBaseDevice
+from pymammotion.mqtt.mammotion_future import MammotionFuture
+from pymammotion.proto import has_field
+from pymammotion.proto.luba_msg import LubaMsg
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionCloud:
+    """Per account MQTT cloud."""
+
+    def __init__(self, mqtt_client: MammotionMQTT) -> None:
+        self.loop = asyncio.get_event_loop()
+        self._ble_sync_task = None
+        self.is_ready = False
+        self.command_queue = asyncio.Queue()
+        self._waiting_queue = deque()
+        self.mqtt_message_event = DataEvent()
+        self.on_ready_event = DataEvent()
+        self._operation_lock = asyncio.Lock()
+        self._mqtt_client = mqtt_client
+        self._mqtt_client.on_connected = self.on_connected
+        self._mqtt_client.on_disconnected = self.on_disconnected
+        self._mqtt_client.on_message = self._on_mqtt_message
+        self._mqtt_client.on_ready = self.on_ready
+
+        # temporary for testing only
+        # self._start_sync_task = self.loop.call_later(30, lambda: asyncio.ensure_future(self.start_sync(0)))
+
+    def on_ready(self) -> None:
+        self.on_ready_event.data_event(None)
+
+    def is_connected(self) -> bool:
+        return self._mqtt_client.is_connected
+
+    def disconnect(self) -> None:
+        self._mqtt_client.disconnect()
+
+    def connect_async(self) -> None:
+        self._mqtt_client.connect_async()
+
+    def send_command(self, iot_id: str, command: bytes) -> None:
+        self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
+
+    async def on_connected(self) -> None:
+        """Callback for when MQTT connects."""
+
+    async def on_disconnected(self) -> None:
+        """Callback for when MQTT disconnects."""
+
+    async def _process_queue(self) -> None:
+        while True:
+            # Get the next item from the queue
+            iot_id, key, command, future = await self.command_queue.get()
+            try:
+                # Process the command using _execute_command_locked
+                result = await self._execute_command_locked(iot_id, key, command)
+                # Set the result on the future
+                future.set_result(result)
+            except Exception as ex:
+                # Set the exception on the future if something goes wrong
+                future.set_exception(ex)
+            finally:
+                # Mark the task as done
+                self.command_queue.task_done()
+
+    async def _execute_command_locked(self, iot_id: str, key: str, command: bytes) -> bytes:
+        """Execute command and read response."""
+        assert self._mqtt_client is not None
+        self._key = key
+        _LOGGER.debug("Sending command: %s", key)
+
+        await self.loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, iot_id, command)
+        future = MammotionFuture(iot_id)
+        self._waiting_queue.append(future)
+        timeout = 5
+        try:
+            notify_msg = await future.async_get(timeout)
+        except asyncio.TimeoutError:
+            notify_msg = b""
+
+        _LOGGER.debug("%s: Message received", iot_id)
+
+        return notify_msg
+
+    async def _on_mqtt_message(self, topic: str, payload: str, iot_id: str) -> None:
+        """Handle incoming MQTT messages."""
+        _LOGGER.debug("MQTT message received on topic %s: %s, iot_id: %s", topic, payload, iot_id)
+
+        json_str = json.dumps(payload)
+        payload = json.loads(json_str)
+
+        await self._handle_mqtt_message(topic, payload)
+
+    async def _parse_mqtt_response(self, topic: str, payload: dict) -> None:
+        """Parse the MQTT response."""
+        if topic.endswith("/app/down/thing/events"):
+            _LOGGER.debug("Thing event received")
+            event = ThingEventMessage.from_dicts(payload)
+            params = event.params
+            if params.get("identifier", None) is None:
+                return
+            if params.identifier == "device_protobuf_msg_event" and event.method == "thing.events":
+                _LOGGER.debug("Protobuf event")
+                # Call the callbacks for each cloudDevice
+                await self.mqtt_message_event.data_event(event)
+            if event.method == "thing.properties":
+                _LOGGER.debug(event)
+
+    async def _handle_mqtt_message(self, topic: str, payload: dict) -> None:
+        """Async handler for incoming MQTT messages."""
+        await self._parse_mqtt_response(topic=topic, payload=payload)
+
+    def _disconnect(self) -> None:
+        """Disconnect the MQTT client."""
+        self._mqtt_client.disconnect()
+
+    @property
+    def waiting_queue(self):
+        return self._waiting_queue
+
+
+class MammotionBaseCloudDevice(MammotionBaseDevice):
+    """Base class for Mammotion Cloud devices."""
+
+    def __init__(self, mqtt: MammotionCloud, cloud_device: Device, mowing_state: MowingDevice) -> None:
+        """Initialize MammotionBaseCloudDevice."""
+        super().__init__(mowing_state, cloud_device)
+        self.on_ready_callback: Optional[Callable[[], Awaitable[None]]] = None
+        self.loop = asyncio.get_event_loop()
+        self._mqtt = mqtt
+        self.iot_id = cloud_device.iotId
+        self.device = cloud_device
+        self._mower = mowing_state
+        self._command_futures = {}
+        self._commands: MammotionCommand = MammotionCommand(cloud_device.deviceName)
+        self.currentID = ""
+        self._mqtt.mqtt_message_event.add_subscribers(self._parse_message_for_device)
+        self._mqtt.on_ready_event.add_subscribers(self.on_ready)
+
+        if self._mqtt.is_ready:
+            self.run_periodic_sync_task()
+
+    async def on_ready(self) -> None:
+        """Callback for when MQTT is subscribed to events."""
+        loop = asyncio.get_event_loop()
+
+        await self._ble_sync()
+        await self.run_periodic_sync_task()
+        loop.create_task(self._process_queue())
+        if self.on_ready_callback:
+            await self.on_ready_callback()
+
+    async def _ble_sync(self) -> None:
+        command_bytes = self._commands.send_todev_ble_sync(3)
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._mqtt.send_command, self.iot_id, command_bytes)
+
+    async def run_periodic_sync_task(self) -> None:
+        """Send ble sync to robot."""
+        try:
+            if not self._mqtt._operation_lock.locked():
+                await self._ble_sync()
+        finally:
+            self.schedule_ble_sync()
+
+    def schedule_ble_sync(self) -> None:
+        """Periodically sync to keep connection alive."""
+        if self._mqtt is not None and self._mqtt.is_connected:
+            self._ble_sync_task = self.loop.call_later(
+                160, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
+            )
+
+    async def queue_command(self, key: str, **kwargs: Any) -> bytes:
+        # Create a future to hold the result
+        _LOGGER.debug("Queueing command: %s", key)
+        future = asyncio.Future()
+        # Put the command in the queue as a tuple (key, command, future)
+        command_bytes = getattr(self._commands, key)(**kwargs)
+        await self._mqtt.command_queue.put((self.iot_id, key, command_bytes, future))
+        # Wait for the future to be resolved
+        return await future
+
+    def _extract_message_id(self, payload: dict) -> str:
+        """Extract the message ID from the payload."""
+        return payload.get("id", "")
+
+    def _extract_encoded_message(self, payload: dict) -> str:
+        """Extract the encoded message from the payload."""
+        try:
+            content = payload.get("data", {}).get("data", {}).get("params", {}).get("content", "")
+            return str(content)
+        except AttributeError:
+            _LOGGER.error("Error extracting encoded message. Payload: %s", payload)
+            return ""
+
+    @staticmethod
+    def dequeue_by_iot_id(queue, iot_id):
+        for item in queue:
+            if item.iot_id == iot_id:
+                queue.remove(item)
+                return item
+        return None
+
+    async def _parse_message_for_device(self, event: ThingEventMessage) -> None:
+        params = event.params
+        if event.params.iotId != self.iot_id:
+            return
+        binary_data = base64.b64decode(params.value.content.proto)
+        self._update_raw_data(cast(bytes, binary_data))
+        new_msg = LubaMsg().parse(cast(bytes, binary_data))
+
+        if (
+            self._commands.get_device_product_key() == ""
+            and self._commands.get_device_name() == event.params.deviceName
+        ):
+            self._commands.set_device_product_key(event.params.productKey)
+
+        if betterproto.serialized_on_wire(new_msg.net):
+            if new_msg.net.todev_ble_sync != 0 or has_field(new_msg.net.toapp_wifi_iot_status):
+                return
+
+        if len(self._mqtt.waiting_queue) > 0:
+            fut: MammotionFuture = self.dequeue_by_iot_id(self._mqtt.waiting_queue, self.iot_id)
+            if fut is None:
+                return
+            while fut.fut.cancelled() and len(self._mqtt.waiting_queue) > 0:
+                fut: MammotionFuture = self.dequeue_by_iot_id(self._mqtt.waiting_queue, self.iot_id)
+            if not fut.fut.cancelled():
+                fut.resolve(cast(bytes, binary_data))
+        await self._state_manager.notification(new_msg)