pymammotion 0.4.0a2__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -1,9 +1,11 @@
 import asyncio
+from collections.abc import Awaitable, Callable
 import logging
-from typing import Any, cast
+import time
+from typing import Any
 from uuid import UUID
 
-import betterproto
+import betterproto2
 from bleak import BleakGATTCharacteristic, BleakGATTServiceCollection, BLEDevice
 from bleak.exc import BleakDBusError
 from bleak_retry_connector import (
@@ -13,12 +15,12 @@ from bleak_retry_connector import (
     establish_connection,
 )
 
+from pymammotion.aliyun.model.dev_by_account_response import Device
 from pymammotion.bluetooth import BleMessage
-from pymammotion.data.state_manager import StateManager
+from pymammotion.data.mower_state_manager import MowerStateManager
 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
+from pymammotion.proto import LubaMsg
 
 DBUS_ERROR_BACKOFF_TIME = 0.25
 
@@ -69,9 +71,17 @@ async def _handle_retry(fut: asyncio.Future[None], func, command: bytes) -> None
 class MammotionBaseBLEDevice(MammotionBaseDevice):
     """Base class for Mammotion BLE devices."""
 
-    def __init__(self, state_manager: StateManager, device: BLEDevice, interface: int = 0, **kwargs: Any) -> None:
+    def __init__(
+        self,
+        state_manager: MowerStateManager,
+        cloud_device: Device,
+        device: BLEDevice,
+        interface: int = 0,
+        **kwargs: Any,
+    ) -> None:
         """Initialize MammotionBaseBLEDevice."""
-        super().__init__(state_manager)
+        super().__init__(state_manager, cloud_device)
+        self.command_sent_time = 0
         self._disconnect_strategy = True
         self._ble_sync_task = None
         self._prev_notification = None
@@ -82,23 +92,38 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         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._commands: MammotionCommand = MammotionCommand(device.name, 1)
         self.command_queue = asyncio.Queue()
         self._expected_disconnect = False
         self._connect_lock = asyncio.Lock()
         self._operation_lock = asyncio.Lock()
         self._key: str | None = None
+        self._cloud_device = cloud_device
         self.set_queue_callback(self.queue_command)
         loop = asyncio.get_event_loop()
         loop.create_task(self.process_queue())
 
+    def __del__(self) -> None:
+        """Cleanup."""
+        if self._disconnect_timer:
+            self._disconnect_timer.cancel()
+        if self._ble_sync_task:
+            self._ble_sync_task.cancel()
+
+        self._state_manager.ble_queue_command_callback.remove_subscribers(self.queue_command)
+
+    def set_notification_callback(self, func: Callable[[tuple[str, Any | None]], Awaitable[None]]) -> None:
+        self._state_manager.ble_on_notification_callback.add_subscribers(func)
+
+    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[None]]) -> None:
+        self._state_manager.ble_queue_command_callback.add_subscribers(func)
+
     def update_device(self, device: BLEDevice) -> None:
         """Update the BLE device."""
         self.ble_device = device
 
     async def _ble_sync(self) -> None:
         if self._client is not None and self._client.is_connected:
-            _LOGGER.debug("BLE SYNC")
             command_bytes = self._commands.send_todev_ble_sync(2)
             await self._message.post_custom_data_bytes(command_bytes)
 
@@ -120,10 +145,10 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         """Stop all tasks and disconnect."""
         if self._ble_sync_task:
             self._ble_sync_task.cancel()
-        if self._client is not None:
+        if self._client is not None and self._client.is_connected:
             await self._client.disconnect()
 
-    async def queue_command(self, key: str, **kwargs: Any) -> bytes | None:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         # Create a future to hold the result
         _LOGGER.debug("Queueing command: %s", key)
         future = asyncio.Future()
@@ -131,7 +156,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         command_bytes = getattr(self._commands, key)(**kwargs)
         await self.command_queue.put((key, command_bytes, future))
         # Wait for the future to be resolved
-        return await future
+        await future
         # return await self._send_command_with_args(key, **kwargs)
 
     async def process_queue(self) -> None:
@@ -220,10 +245,12 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     @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
+        return self.mower.report_data.connect.ble_rssi
+
+    @property
+    def client(self) -> BleakClientWithServiceCache | None:
+        """Return client."""
+        return self._client
 
     async def _ensure_connected(self) -> None:
         """Ensure connection to device is established."""
@@ -289,7 +316,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
             await self._ble_sync()
             self.schedule_ble_sync()
 
-    async def _send_command_locked(self, key: str, command: bytes) -> bytes:
+    async def _send_command_locked(self, key: str, command: bytes) -> None:
         """Send command to device and read response."""
         await self._ensure_connected()
         try:
@@ -314,65 +341,48 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
 
     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._message.clear_notification()
             try:
                 self._update_raw_data(data)
             except (KeyError, ValueError, IndexError, UnicodeDecodeError):
                 _LOGGER.exception("Error parsing message %s", data)
                 data = b""
-            finally:
-                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() == "":
+        res = betterproto2.which_one_of(new_msg, "LubaSubMsg")
+        if res[0] == "net":
+            if new_msg.net.todev_ble_sync != 0 or new_msg.net.toapp_wifi_iot_status is not None:
+                if new_msg.net.toapp_wifi_iot_status is not None and self._commands.get_device_product_key() == "":
                     self._commands.set_device_product_key(new_msg.net.toapp_wifi_iot_status.productkey)
 
-                return
+        await self._state_manager.notification(new_msg)
 
-        # 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)
+        if self._execute_timed_disconnect is None:
+            await self._execute_forced_disconnect()
 
         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:
+    async def _execute_command_locked(self, key: str, command: bytes) -> None:
         """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
+        self.command_sent_time = time.time()
 
     def get_address(self) -> str:
         """Return address of device."""
@@ -483,5 +493,5 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
             _LOGGER.debug("%s: Disconnect completed successfully", self.name)
         self._client = None
 
-    def set_disconnect_strategy(self, disconnect: bool) -> None:
+    def set_disconnect_strategy(self, *, disconnect: bool) -> None:
         self._disconnect_strategy = disconnect

pymammotion/mammotion/devices/mammotion_cloud.py

@@ -1,25 +1,27 @@
 import asyncio
+from asyncio import InvalidStateError
 import base64
+from collections import deque
+from collections.abc import Awaitable, Callable
 import json
 import logging
-from asyncio import TimerHandle
-from collections import deque
-from typing import Any, Awaitable, Callable, Optional, cast
+import time
+from typing import Any
 
-import betterproto
+import betterproto2
+from Tea.exceptions import UnretryableException
 
-from pymammotion import CloudIOTGateway, MammotionMQTT
+from pymammotion import AliyunMQTT, CloudIOTGateway, MammotionMQTT
 from pymammotion.aliyun.cloud_gateway import DeviceOfflineException
 from pymammotion.aliyun.model.dev_by_account_response import Device
-from pymammotion.data.mqtt.event import ThingEventMessage
-from pymammotion.data.mqtt.properties import ThingPropertiesMessage
-from pymammotion.data.state_manager import StateManager
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.data.mqtt.event import MammotionEventMessage, ThingEventMessage
+from pymammotion.data.mqtt.properties import MammotionPropertiesMessage, ThingPropertiesMessage
+from pymammotion.data.mqtt.status import ThingStatusMessage
 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
+from pymammotion.proto import LubaMsg
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,14 +29,18 @@ _LOGGER = logging.getLogger(__name__)
 class MammotionCloud:
     """Per account MQTT cloud."""
 
-    def __init__(self, mqtt_client: MammotionMQTT, cloud_client: CloudIOTGateway) -> None:
+    def __init__(self, mqtt_client: AliyunMQTT | MammotionMQTT, cloud_client: CloudIOTGateway) -> None:
+        """Initialize MammotionCloud."""
         self.cloud_client = cloud_client
+        self.command_sent_time = 0
         self.loop = asyncio.get_event_loop()
         self.is_ready = False
         self.command_queue = asyncio.Queue()
         self._waiting_queue = deque()
         self.mqtt_message_event = DataEvent()
         self.mqtt_properties_event = DataEvent()
+        self.mqtt_status_event = DataEvent()
+        self.mqtt_device_event = DataEvent()
         self.on_ready_event = DataEvent()
         self.on_disconnected_event = DataEvent()
         self.on_connected_event = DataEvent()
@@ -45,10 +51,8 @@ class MammotionCloud:
         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)))
-
     async def on_ready(self) -> None:
+        """Starts processing the queue and emits the ready event."""
         loop = asyncio.get_event_loop()
         loop.create_task(self.process_queue())
         await self.on_ready_event.data_event(None)
@@ -57,13 +61,15 @@ class MammotionCloud:
         return self._mqtt_client.is_connected
 
     def disconnect(self) -> None:
-        self._mqtt_client.disconnect()
+        """Disconnect the MQTT client."""
+        if self.is_connected:
+            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 send_command(self, iot_id: str, command: bytes) -> None:
+        await self._mqtt_client.send_cloud_command(iot_id, command)
 
     async def on_connected(self) -> None:
         """Callback for when MQTT connects."""
@@ -84,42 +90,42 @@ class MammotionCloud:
                 future.set_result(result)
             except Exception as ex:
                 # Set the exception on the future if something goes wrong
-                future.set_exception(ex)
+                try:
+                    future.set_exception(ex)
+                except InvalidStateError:
+                    """Dead end, log an error."""
+                    _LOGGER.exception("InvalidStateError while trying to bubble up exception")
             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:
+    async def _execute_command_locked(self, iot_id: str, key: str, command: bytes) -> None:
         """Execute command and read response."""
         assert self._mqtt_client is not None
         self._key = key
         _LOGGER.debug("Sending command: %s", key)
+        self.command_sent_time = time.time()
+        await self._mqtt_client.send_cloud_command(iot_id, command)
 
-        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:
-            _LOGGER.debug("command_locked 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:
+    async def _on_mqtt_message(self, topic: str, payload: bytes, iot_id: str) -> None:
         """Handle incoming MQTT messages."""
-        _LOGGER.debug("MQTT message received on topic %s: %s, iot_id: %s", topic, payload, iot_id)
+        # _LOGGER.debug("MQTT message received on topic %s: %s, iot_id: %s", topic, payload, iot_id)
+        json_str = payload.decode("utf-8")
+        dict_payload = json.loads(json_str)
+        await self._parse_mqtt_response(topic, dict_payload, iot_id)
+
+    async def _parse_mqtt_response(self, topic: str, payload: dict, iot_id: str) -> None:
+        """Parse and handle MQTT responses based on the topic.
 
-        json_str = json.dumps(payload)
-        payload = json.loads(json_str)
+        This function processes different types of MQTT messages received from various
+        topics. It logs debug information and calls appropriate callback methods for
+        each event type.
 
-        await self._handle_mqtt_message(topic, payload)
+        Args:
+            topic (str): The MQTT topic from which the message was received.
+            payload (dict): The payload data of the MQTT message.
 
-    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)
@@ -131,56 +137,85 @@ class MammotionCloud:
                 _LOGGER.debug("Protobuf event")
                 # Call the callbacks for each cloudDevice
                 await self.mqtt_message_event.data_event(event)
+            if event.method == "thing.events":
+                await self.mqtt_device_event.data_event(event)
             if event.method == "thing.properties":
                 await self.mqtt_properties_event.data_event(event)
                 _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)
+        elif topic.endswith("/app/down/thing/status"):
+            status = ThingStatusMessage.from_dict(payload)
+            await self.mqtt_status_event.data_event(status)
+        elif topic.endswith("app/down/thing/properties"):
+            property_event = ThingPropertiesMessage.from_dict(payload)
+            await self.mqtt_properties_event.data_event(property_event)
+
+        if topic.endswith("/thing/event/device_protobuf_msg_event/post"):
+            _LOGGER.debug("Mammotion Thing event received")
+            mammotion_event = MammotionEventMessage.from_dict(payload)
+            mammotion_event.params.iot_id = iot_id
+            await self.mqtt_message_event.data_event(mammotion_event)
+        elif topic.endswith("/thing/event/property/post"):
+            _LOGGER.debug("Mammotion Property event received")
+            mammotion_property_event = MammotionPropertiesMessage.from_dict(payload)
+            mammotion_property_event.params.iot_id = iot_id
+            await self.mqtt_properties_event.data_event(mammotion_property_event)
 
     def _disconnect(self) -> None:
         """Disconnect the MQTT client."""
         self._mqtt_client.disconnect()
 
     @property
-    def waiting_queue(self):
+    def waiting_queue(self) -> deque:
         return self._waiting_queue
 
 
 class MammotionBaseCloudDevice(MammotionBaseDevice):
     """Base class for Mammotion Cloud devices."""
 
-    def __init__(self, mqtt: MammotionCloud, cloud_device: Device, state_manager: StateManager) -> None:
+    def __init__(self, mqtt: MammotionCloud, cloud_device: Device, state_manager: MowerStateManager) -> None:
         """Initialize MammotionBaseCloudDevice."""
         super().__init__(state_manager, cloud_device)
-        self._ble_sync_task: TimerHandle | None = None
         self.stopped = False
-        self.on_ready_callback: Optional[Callable[[], Awaitable[None]]] = None
+        self.on_ready_callback: Callable[[], Awaitable[None]] | None = None
         self.loop = asyncio.get_event_loop()
         self._mqtt = mqtt
-        self.iot_id = cloud_device.iotId
+        self.iot_id = cloud_device.iot_id
         self.device = cloud_device
         self._command_futures = {}
-        self._commands: MammotionCommand = MammotionCommand(cloud_device.deviceName)
+        self._commands: MammotionCommand = MammotionCommand(
+            cloud_device.device_name,
+            int(mqtt.cloud_client.mammotion_http.response.data.userInformation.userAccount),
+        )
         self.currentID = ""
         self._mqtt.mqtt_message_event.add_subscribers(self._parse_message_for_device)
         self._mqtt.mqtt_properties_event.add_subscribers(self._parse_message_properties_for_device)
+        self._mqtt.mqtt_status_event.add_subscribers(self._parse_message_status_for_device)
+        self._mqtt.mqtt_device_event.add_subscribers(self._parse_device_event_for_device)
         self._mqtt.on_ready_event.add_subscribers(self.on_ready)
         self._mqtt.on_disconnected_event.add_subscribers(self.on_disconnect)
         self._mqtt.on_connected_event.add_subscribers(self.on_connect)
         self.set_queue_callback(self.queue_command)
 
-        if self._mqtt.is_ready:
-            self.run_periodic_sync_task()
-
     def __del__(self) -> None:
+        """Cleanup subscriptions."""
         self._mqtt.on_ready_event.remove_subscribers(self.on_ready)
         self._mqtt.on_disconnected_event.remove_subscribers(self.on_disconnect)
         self._mqtt.on_connected_event.remove_subscribers(self.on_connect)
         self._mqtt.mqtt_message_event.remove_subscribers(self._parse_message_for_device)
-        if self._ble_sync_task:
-            self._ble_sync_task.cancel()
+        self._mqtt.mqtt_properties_event.remove_subscribers(self._parse_message_properties_for_device)
+        self._mqtt.mqtt_status_event.remove_subscribers(self._parse_message_status_for_device)
+        self._mqtt.mqtt_device_event.remove_subscribers(self._parse_device_event_for_device)
+        self._state_manager.cloud_queue_command_callback.remove_subscribers(self.queue_command)
+
+    @property
+    def command_sent_time(self) -> float:
+        return self._mqtt.command_sent_time
+
+    def set_notification_callback(self, func: Callable[[tuple[str, Any | None]], Awaitable[None]]) -> None:
+        self._state_manager.cloud_on_notification_callback.add_subscribers(func)
+
+    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[None]]) -> None:
+        self._state_manager.cloud_queue_command_callback.add_subscribers(func)
 
     async def on_ready(self) -> None:
         """Callback for when MQTT is subscribed to events."""
@@ -189,55 +224,33 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         try:
             if self.on_ready_callback:
                 await self.on_ready_callback()
-        except DeviceOfflineException:
+        except (DeviceOfflineException, UnretryableException):
             _LOGGER.debug("Device is offline")
 
     async def on_disconnect(self) -> None:
-        if self._ble_sync_task:
-            self._ble_sync_task.cancel()
         self._mqtt.disconnect()
 
     async def on_connect(self) -> None:
-        await self._ble_sync()
-        if self._ble_sync_task is None or self._ble_sync_task.cancelled():
-            await self.run_periodic_sync_task()
+        """On connect callback"""
 
     async def stop(self) -> None:
         """Stop all tasks and disconnect."""
-        if self._ble_sync_task:
-            self._ble_sync_task.cancel()
+        # self._mqtt._mqtt_client.unsubscribe()
         self.stopped = True
 
     async def start(self) -> None:
-        await self._ble_sync()
-        if self._ble_sync_task is None or self._ble_sync_task.cancelled():
-            await self.run_periodic_sync_task()
+        """Start the device connection."""
         self.stopped = False
         if not self.mqtt.is_connected():
-            self.mqtt.connect_async()
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self.mqtt.connect_async)
+        # else:
+        #     self.mqtt._mqtt_client.thing_on_thing_enable(None)
 
     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)
+        pass
 
-    async def run_periodic_sync_task(self) -> None:
-        """Send ble sync to robot."""
-        try:
-            if not self._mqtt._operation_lock.locked() or not self.stopped:
-                await self._ble_sync()
-        finally:
-            if not self.stopped:
-                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:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         # Create a future to hold the result
         _LOGGER.debug("Queueing command: %s", key)
         future = asyncio.Future()
@@ -246,7 +259,8 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         await self._mqtt.command_queue.put((self.iot_id, key, command_bytes, future))
         # Wait for the future to be resolved
         try:
-            return await future
+            await future
+            return
         except asyncio.CancelledError:
             """Try again once."""
             future = asyncio.Future()
@@ -274,15 +288,37 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         return None
 
     async def _parse_message_properties_for_device(self, event: ThingPropertiesMessage) -> None:
-        if event.params.iotId != self.iot_id:
+        if event.params.iot_id != self.iot_id:
+            return
+        await self.state_manager.properties(event)
+
+    async def _parse_message_status_for_device(self, status: ThingStatusMessage) -> None:
+        if status.params.iot_id != self.iot_id:
             return
-        self.state_manager.properties(event)
+        await self.state_manager.status(status)
+
+    async def _parse_device_event_for_device(self, status: ThingStatusMessage) -> None:
+        """Process device event if it matches the device's IoT ID."""
+        if status.params.iot_id != self.iot_id:
+            return
+        await self.state_manager.device_event(status)
 
     async def _parse_message_for_device(self, event: ThingEventMessage) -> None:
-        _LOGGER.debug("_parse_message_for_device")
+        """Parses a message received from a device and updates internal state.
+
+        This function processes an incoming `ThingEventMessage`, checks if the message
+        is intended for this device, decodes the binary data, and updates raw data. It
+        then attempts to parse the binary data into a `LubaMsg`. If parsing fails, it
+        logs the exception. The function also handles setting the device product key if
+        not already set and processes specific sub-messages based on their types.
+
+        Args:
+            event (ThingEventMessage): The event message received from the device.
+
+        """
         params = event.params
         new_msg = LubaMsg()
-        if event.params.iotId != self.iot_id:
+        if event.params.iot_id != self.iot_id:
             return
         binary_data = base64.b64decode(params.value.content)
         try:
@@ -293,22 +329,15 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
 
         if (
             self._commands.get_device_product_key() == ""
-            and self._commands.get_device_name() == event.params.deviceName
+            and self._commands.get_device_name() == event.params.device_name
         ):
-            self._commands.set_device_product_key(event.params.productKey)
+            self._commands.set_device_product_key(event.params.product_key)
 
-        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):
+        res = betterproto2.which_one_of(new_msg, "LubaSubMsg")
+        if res[0] == "net":
+            if new_msg.net.todev_ble_sync != 0 or new_msg.net.toapp_wifi_iot_status is not None:
                 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 = 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)
 
     @property

pymammotion/mammotion/devices/mammotion_mower_ble.py

@@ -0,0 +1,49 @@
+"""Mower device with Bluetooth LE connectivity."""
+
+import logging
+from typing import Any
+
+from bleak import BLEDevice
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.mammotion.devices.mammotion_bluetooth import MammotionBaseBLEDevice
+from pymammotion.mammotion.devices.mower_device import MammotionMowerDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionMowerBLEDevice(MammotionBaseBLEDevice, MammotionMowerDevice):
+    """Mower device with BLE connectivity and map synchronization."""
+
+    def __init__(
+        self,
+        state_manager: MowerStateManager,
+        cloud_device: Device,
+        device: BLEDevice,
+        interface: int = 0,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize MammotionMowerBLEDevice.
+
+        Uses multiple inheritance to combine:
+        - MammotionBaseBLEDevice: BLE communication
+        - MammotionMowerDevice: Map sync callbacks
+        """
+        # Initialize base BLE device (which also initializes MammotionBaseDevice)
+        MammotionBaseBLEDevice.__init__(self, state_manager, cloud_device, device, interface, **kwargs)
+        # Set up mower-specific BLE callbacks
+        self._state_manager.ble_gethash_ack_callback = self.datahash_response
+        self._state_manager.ble_get_commondata_ack_callback = self.commdata_response
+        self._state_manager.ble_get_plan_callback = self.plan_callback
+
+    def __del__(self) -> None:
+        """Cleanup subscriptions and callbacks."""
+        # Clean up mower-specific callbacks
+        if hasattr(self, "_state_manager"):
+            self._state_manager.ble_gethash_ack_callback = None
+            self._state_manager.ble_get_commondata_ack_callback = None
+            self._state_manager.ble_get_plan_callback = None
+        # Call parent cleanup
+        if MammotionBaseBLEDevice.__del__:
+            super().__del__()