pymammotion 0.5.27__py3-none-any.whl → 0.5.44__py3-none-any.whl

pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -17,7 +17,7 @@ from bleak_retry_connector import (
 
 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 LubaMsg
@@ -72,10 +72,16 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     """Base class for Mammotion BLE devices."""
 
     def __init__(
-        self, state_manager: StateManager, cloud_device: Device, device: BLEDevice, interface: int = 0, **kwargs: Any
+        self,
+        state_manager: MowerStateManager,
+        cloud_device: Device,
+        device: BLEDevice,
+        interface: int = 0,
+        **kwargs: Any,
     ) -> None:
         """Initialize MammotionBaseBLEDevice."""
         super().__init__(state_manager, cloud_device)
+        self.command_sent_time = 0
         self._disconnect_strategy = True
         self._ble_sync_task = None
         self._prev_notification = None
@@ -94,9 +100,6 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         self._key: str | None = None
         self._cloud_device = cloud_device
         self.set_queue_callback(self.queue_command)
-        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
         loop = asyncio.get_event_loop()
         loop.create_task(self.process_queue())
 

pymammotion/mammotion/devices/mammotion_cloud.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import InvalidStateError, TimerHandle
+from asyncio import InvalidStateError
 import base64
 from collections import deque
 from collections.abc import Awaitable, Callable
@@ -11,18 +11,17 @@ from typing import Any
 import betterproto2
 from Tea.exceptions import UnretryableException
 
-from pymammotion import CloudIOTGateway, MammotionMQTT
-from pymammotion.aliyun.cloud_gateway import CheckSessionException, DeviceOfflineException, SetupException
+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.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.data.state_manager import StateManager
 from pymammotion.event.event import DataEvent
 from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
 from pymammotion.mammotion.devices.base import MammotionBaseDevice
 from pymammotion.proto import LubaMsg
-from pymammotion.utility.constant.device_constant import NO_REQUEST_MODES
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,9 +29,10 @@ _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()
@@ -69,7 +69,7 @@ class MammotionCloud:
         self._mqtt_client.connect_async()
 
     async def send_command(self, iot_id: str, command: bytes) -> None:
-        await self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
+        await self._mqtt_client.send_cloud_command(iot_id, command)
 
     async def on_connected(self) -> None:
         """Callback for when MQTT connects."""
@@ -104,19 +104,17 @@ class MammotionCloud:
         assert self._mqtt_client is not None
         self._key = key
         _LOGGER.debug("Sending command: %s", key)
-        await self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
         self.command_sent_time = time.time()
+        await self._mqtt_client.send_cloud_command(iot_id, command)
 
-    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)
 
-        json_str = json.dumps(payload)
-        payload = json.loads(json_str)
-
-        await self._parse_mqtt_response(topic, payload)
-
-    async def _parse_mqtt_response(self, topic: str, payload: dict) -> None:
+    async def _parse_mqtt_response(self, topic: str, payload: dict, iot_id: str) -> None:
         """Parse and handle MQTT responses based on the topic.
 
         This function processes different types of MQTT messages received from various
@@ -151,31 +149,41 @@ class MammotionCloud:
             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: 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,
+            cloud_device.device_name,
             int(mqtt.cloud_client.mammotion_http.response.data.userInformation.userAccount),
         )
         self.currentID = ""
@@ -186,15 +194,10 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         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._state_manager.cloud_gethash_ack_callback = self.datahash_response
-        self._state_manager.cloud_get_commondata_ack_callback = self.commdata_response
-        self._state_manager.cloud_get_plan_callback = self.plan_callback
         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)
@@ -202,16 +205,12 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         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_gethash_ack_callback = None
-        self._state_manager.cloud_get_commondata_ack_callback = None
-        self._state_manager.cloud_get_plan_callback = None
-        if self._ble_sync_task:
-            self._ble_sync_task.cancel()
-
-    def __del__(self) -> None:
-        """Cleanup."""
         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)
 
@@ -229,26 +228,18 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
             _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():
             loop = asyncio.get_running_loop()
@@ -257,35 +248,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         #     self.mqtt._mqtt_client.thing_on_thing_enable(None)
 
     async def _ble_sync(self) -> None:
-        if (
-            self.stopped
-            or self.mqtt.is_connected is False
-            or self.state_manager.get_device().report_data.dev.sys_status in NO_REQUEST_MODES
-        ):
-            return
-
-        command_bytes = self._commands.send_todev_ble_sync(3)
-        try:
-            await self._mqtt.send_command(self.iot_id, command_bytes)
-        except (CheckSessionException, SetupException, DeviceOfflineException):
-            if self._ble_sync_task:
-                self._ble_sync_task.cancel()
-
-    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())
-            )
+        pass
 
     async def queue_command(self, key: str, **kwargs: Any) -> None:
         # Create a future to hold the result
@@ -296,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()
@@ -324,18 +288,18 @@ 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.iotId != self.iot_id:
+        if status.params.iot_id != self.iot_id:
             return
         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.iotId != self.iot_id:
+        if status.params.iot_id != self.iot_id:
             return
         await self.state_manager.device_event(status)
 
@@ -354,7 +318,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         """
         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:
@@ -365,9 +329,9 @@ 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)
 
         res = betterproto2.which_one_of(new_msg, "LubaSubMsg")
         if res[0] == "net":

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__()

pymammotion/mammotion/devices/mammotion_mower_cloud.py

@@ -0,0 +1,39 @@
+"""Mower device with cloud MQTT connectivity."""
+
+import logging
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.mammotion.devices.mammotion_cloud import MammotionBaseCloudDevice, MammotionCloud
+from pymammotion.mammotion.devices.mower_device import MammotionMowerDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionMowerCloudDevice(MammotionBaseCloudDevice, MammotionMowerDevice):
+    """Mower device with cloud connectivity and map synchronization."""
+
+    def __init__(self, mqtt: MammotionCloud, cloud_device: Device, state_manager: MowerStateManager) -> None:
+        """Initialize MammotionMowerCloudDevice.
+
+        Uses multiple inheritance to combine:
+        - MammotionBaseCloudDevice: MQTT communication
+        - MammotionMowerDevice: Map sync callbacks
+        """
+        # Initialize base cloud device (which also initializes MammotionBaseDevice)
+        super().__init__(mqtt, cloud_device, state_manager)
+        # Initialize mower device callbacks (but skip base device init as it's already done)
+        # We manually set the callbacks that MammotionMowerDevice would set
+        self._state_manager.cloud_gethash_ack_callback = self.datahash_response
+        self._state_manager.cloud_get_commondata_ack_callback = self.commdata_response
+        self._state_manager.cloud_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.cloud_gethash_ack_callback = None
+            self._state_manager.cloud_get_commondata_ack_callback = None
+            self._state_manager.cloud_get_plan_callback = None
+        # Call parent cleanup
+        super().__del__()

pymammotion/mammotion/devices/managers/managers.py

@@ -0,0 +1,81 @@
+from abc import ABC, abstractmethod
+
+from bleak import BLEDevice
+
+from pymammotion import CloudIOTGateway
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model.device import MowingDevice, RTKDevice
+from pymammotion.data.model.enums import ConnectionPreference
+from pymammotion.mammotion.devices.mammotion_bluetooth import MammotionBaseBLEDevice
+from pymammotion.mammotion.devices.mammotion_cloud import MammotionBaseCloudDevice, MammotionCloud
+
+
+class AbstractDeviceManager(ABC):
+    """Abstract base class for device managers."""
+
+    def __init__(
+        self,
+        name: str,
+        iot_id: str,
+        cloud_client: CloudIOTGateway,
+        cloud_device: Device,
+        preference: ConnectionPreference = ConnectionPreference.BLUETOOTH,
+    ) -> None:
+        self.name = name
+        self.iot_id = iot_id
+        self.cloud_client = cloud_client
+        self._device: Device = cloud_device
+        self.mammotion_http = cloud_client.mammotion_http
+        self.preference = preference
+
+    @property
+    @abstractmethod
+    def state(self) -> MowingDevice | RTKDevice:
+        """Return the state of the device."""
+
+    @state.setter
+    @abstractmethod
+    def state(self, value: MowingDevice | RTKDevice) -> None:
+        """Set the device state."""
+
+    @property
+    @abstractmethod
+    def ble(self) -> MammotionBaseBLEDevice | None:
+        """Return BLE device interface."""
+
+    @property
+    @abstractmethod
+    def cloud(self) -> MammotionBaseCloudDevice | None:
+        """Return cloud device interface."""
+
+    @abstractmethod
+    def has_queued_commands(self) -> bool:
+        """Check if there are queued commands."""
+
+    @abstractmethod
+    def add_ble(self, ble_device: BLEDevice) -> MammotionBaseBLEDevice:
+        """Add BLE device."""
+
+    @abstractmethod
+    def add_cloud(self, mqtt: MammotionCloud) -> MammotionBaseCloudDevice:
+        """Add cloud device."""
+
+    @abstractmethod
+    def replace_cloud(self, cloud_device: MammotionBaseCloudDevice) -> None:
+        """Replace cloud device."""
+
+    @abstractmethod
+    def remove_cloud(self) -> None:
+        """Remove cloud device."""
+
+    @abstractmethod
+    def replace_ble(self, ble_device: MammotionBaseBLEDevice) -> None:
+        """Replace BLE device."""
+
+    @abstractmethod
+    def remove_ble(self) -> None:
+        """Remove BLE device."""
+
+    @abstractmethod
+    def replace_mqtt(self, mqtt: MammotionCloud) -> None:
+        """Replace MQTT connection."""

pymammotion/mammotion/devices/mower_device.py

@@ -0,0 +1,121 @@
+"""Mower-specific device class with map synchronization callbacks."""
+
+from abc import ABC
+import logging
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model import RegionData
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.mammotion.devices.base import MammotionBaseDevice
+from pymammotion.proto import NavGetCommDataAck, NavGetHashListAck, NavPlanJobSet, SvgMessageAckT
+from pymammotion.utility.device_type import DeviceType
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def find_next_integer(lst: list[int], current_hash: int) -> int | None:
+    """Find the next integer in a list after the current hash."""
+    try:
+        current_index = lst.index(current_hash)
+        if current_index + 1 < len(lst):
+            return lst[current_index + 1]
+        else:
+            return None
+    except ValueError:
+        return None
+
+
+class MammotionMowerDevice(MammotionBaseDevice, ABC):
+    """Mower device with map synchronization support."""
+
+    def __init__(self, state_manager: MowerStateManager, cloud_device: Device) -> None:
+        """Initialize MammotionMowerDevice."""
+        super().__init__(state_manager, cloud_device)
+        # Register mower-specific callbacks
+        self._state_manager.cloud_gethash_ack_callback = self.datahash_response
+        self._state_manager.cloud_get_commondata_ack_callback = self.commdata_response
+        self._state_manager.cloud_get_plan_callback = self.plan_callback
+
+    async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
+        """Handle datahash responses for root level hashs."""
+        current_frame = hash_ack.current_frame
+
+        missing_frames = self.mower.map.missing_root_hash_frame(hash_ack)
+        if len(missing_frames) == 0:
+            if len(self.mower.map.missing_hashlist(hash_ack.sub_cmd)) > 0:
+                data_hash = self.mower.map.missing_hashlist(hash_ack.sub_cmd).pop(0)
+                await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+            return
+
+        if current_frame != missing_frames[0] - 1:
+            current_frame = missing_frames[0] - 1
+        await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=current_frame)
+
+    async def commdata_response(self, common_data: NavGetCommDataAck | SvgMessageAckT) -> None:
+        """Handle common data responses."""
+        total_frame = common_data.total_frame
+        current_frame = common_data.current_frame
+
+        missing_frames = self.mower.map.missing_frame(common_data)
+        if len(missing_frames) == 0:
+            # get next in hash ack list
+            data_hash = (
+                self.mower.map.missing_hashlist(common_data.sub_cmd).pop(0)
+                if len(self.mower.map.missing_hashlist(common_data.sub_cmd)) > 0
+                else None
+            )
+            if data_hash is None:
+                return
+
+            await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+        else:
+            if current_frame != missing_frames[0] - 1:
+                current_frame = missing_frames[0] - 1
+
+            region_data = RegionData()
+            region_data.hash = common_data.data_hash if isinstance(common_data, SvgMessageAckT) else common_data.hash
+            region_data.action = common_data.action if isinstance(common_data, NavGetCommDataAck) else 0
+            region_data.type = common_data.type
+            region_data.sub_cmd = common_data.sub_cmd
+            region_data.total_frame = total_frame
+            region_data.current_frame = current_frame
+            await self.queue_command("get_regional_data", regional_data=region_data)
+
+    async def plan_callback(self, plan: NavPlanJobSet) -> None:
+        """Handle plan job responses."""
+        if plan.plan_index < plan.total_plan_num - 1:
+            index = plan.plan_index + 1
+            await self.queue_command("read_plan", sub_cmd=2, plan_index=index)
+
+    async def start_map_sync(self) -> None:
+        """Start sync of map data."""
+        if location := next((loc for loc in self.mower.report_data.locations if loc.pos_type == 5), None):
+            self.mower.map.update_hash_lists(self.mower.map.hashlist, location.bol_hash)
+
+        await self.queue_command("send_todev_ble_sync", sync_type=3)
+
+        if self._cloud_device and len(self.mower.map.area_name) == 0 and not DeviceType.is_luba1(self.mower.name):
+            await self.queue_command("get_area_name_list", device_id=self._cloud_device.iot_id)
+
+        if len(self.mower.map.root_hash_lists) == 0 or len(self.mower.map.missing_hashlist()) > 0:
+            await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
+
+        if len(self.mower.map.plan) == 0 or list(self.mower.map.plan.values())[0].total_plan_num != len(
+            self.mower.map.plan
+        ):
+            await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
+
+        for hash_id, frame in list(self.mower.map.area.items()):
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.area[hash_id]
+
+        for hash_id, frame in list(self.mower.map.path.items()):
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.path[hash_id]
+
+        for hash_id, frame in list(self.mower.map.obstacle.items()):
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.obstacle[hash_id]