pymammotion 0.5.33__py3-none-any.whl → 0.5.40__py3-none-any.whl

pymammotion/http/http.py

@@ -1,35 +1,58 @@
 import csv
+import random
 import time
 from typing import cast
 
 from aiohttp import ClientSession
+import jwt
 
 from pymammotion.const import MAMMOTION_API_DOMAIN, MAMMOTION_CLIENT_ID, MAMMOTION_CLIENT_SECRET, MAMMOTION_DOMAIN
 from pymammotion.http.encryption import EncryptionUtils
 from pymammotion.http.model.camera_stream import StreamSubscriptionResponse, VideoResourceResponse
-from pymammotion.http.model.http import CheckDeviceVersion, ErrorInfo, LoginResponseData, Response
+from pymammotion.http.model.http import (
+    CheckDeviceVersion,
+    DeviceInfo,
+    DeviceRecords,
+    ErrorInfo,
+    JWTTokenInfo,
+    LoginResponseData,
+    MQTTConnection,
+    Response,
+)
 from pymammotion.http.model.response_factory import response_factory
 from pymammotion.http.model.rtk import RTK
 
 
 class MammotionHTTP:
-    def __init__(self) -> None:
-        self.expires_in = 0
+    def __init__(self, account: str | None = None, password: str | None = None) -> None:
+        self.device_info: list[DeviceInfo] = []
+        self.mqtt_credentials: MQTTConnection | None = None
+        self.device_records: DeviceRecords = DeviceRecords(records=[], current=0, total=0, size=0, pages=0)
+        self.expires_in = 0.0
         self.code = 0
         self.msg = None
-        self.account = None
-        self._password = None
+        self.account = account
+        self._password = password
         self.response: Response | None = None
         self.login_info: LoginResponseData | None = None
+        self.jwt_info: JWTTokenInfo = JWTTokenInfo("", "")
         self._headers = {"User-Agent": "okhttp/4.9.3", "App-Version": "Home Assistant,1.14.2.29"}
         self.encryption_utils = EncryptionUtils()
 
+        # Add this method to generate a 10-digit random number
+        def get_10_random() -> str:
+            """Generate a 10-digit random number as a string."""
+            return "".join([str(random.randint(0, 9)) for _ in range(7)])
+
+        # Replace the line in the __init__ method with:
+        self.client_id = f"{int(time.time() * 1000)}_{get_10_random()}_1"
+
     @staticmethod
     def generate_headers(token: str) -> dict:
         return {"Authorization": f"Bearer {token}"}
 
     async def handle_expiry(self, resp: Response) -> Response:
-        if resp.code == 401:
+        if resp.code == 401 and self.account and self._password:
             return await self.login(self.account, self._password)
         return resp
 
@@ -89,7 +112,9 @@ class MammotionHTTP:
             ) as resp:
                 data = await resp.json()
 
+                self.login_info.access_token = data["data"].get("accessToken", self.login_info.access_token)
                 self.login_info.authorization_code = data["data"].get("code", self.login_info.authorization_code)
+                await self.get_mqtt_credentials()
                 return Response.from_dict(data)
 
     async def pair_devices_mqtt(self, mower_name: str, rtk_name: str) -> Response:
@@ -163,6 +188,7 @@ class MammotionHTTP:
     ) -> Response[StreamSubscriptionResponse]:
         # Prepare the payload with cameraStates based on is_yuka flag
         """Fetches stream subscription data for a given IoT device."""
+
         payload = {"deviceId": iot_id, "mode": 0, "cameraStates": []}
 
         # Add appropriate cameraStates based on the is_yuka flag
@@ -264,6 +290,88 @@ class MammotionHTTP:
 
                 return response_factory(Response[list[RTK]], data)
 
+    async def get_user_device_list(self) -> Response[list[DeviceInfo]]:
+        """Fetches device list for a user, older devices / aliyun."""
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
+            async with session.get(
+                "/device-server/v1/device/list",
+                headers={
+                    **self._headers,
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                },
+            ) as resp:
+                resp_dict = await resp.json()
+                response = response_factory(Response[list[DeviceInfo]], resp_dict)
+                self.device_info = response.data if response.data else self.device_info
+                return response
+
+    async def get_user_device_page(self) -> Response[DeviceRecords]:
+        """Fetches device list for a user, is either new API or for newer devices."""
+        async with ClientSession(self.jwt_info.iot) as session:
+            async with session.post(
+                "/v1/user/device/page",
+                json={
+                    "iotId": "",
+                    "pageNumber": 1,
+                    "pageSize": 100,
+                },
+                headers={
+                    **self._headers,
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                    "Client-Id": self.client_id,
+                    "Client-Type": "1",
+                },
+            ) as resp:
+                if resp.status != 200:
+                    return Response.from_dict({"code": resp.status, "msg": "get device list failed"})
+                resp_dict = await resp.json()
+                response = response_factory(Response[DeviceRecords], resp_dict)
+                self.device_records = response.data if response.data else self.device_records
+                return response
+
+    async def get_mqtt_credentials(self) -> Response[MQTTConnection]:
+        """Get mammotion mqtt credentials"""
+        async with ClientSession(self.jwt_info.iot) as session:
+            async with session.post(
+                "/v1/mqtt/auth/jwt",
+                headers={
+                    **self._headers,
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                },
+            ) as resp:
+                if resp.status != 200:
+                    return Response.from_dict({"code": resp.status, "msg": "get mqtt failed"})
+                resp_dict = await resp.json()
+                response = response_factory(Response[MQTTConnection], resp_dict)
+                self.mqtt_credentials = response.data
+                return response
+
+    async def mqtt_invoke(self, content: str, device_name: str, iot_id: str) -> Response[dict]:
+        """Send mqtt commands to devices."""
+        async with ClientSession(self.jwt_info.iot) as session:
+            async with session.post(
+                "/v1/mqtt/rpc/thing/service/invoke",
+                json={"args": {"content": content, "deviceName": device_name, "iotId": iot_id, "productKey": ""}},
+                headers={
+                    **self._headers,
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                    "Client-Id": self.client_id,
+                    "Client-Type": "1",
+                },
+            ) as resp:
+                if resp.status != 200:
+                    return Response.from_dict({"code": resp.status, "msg": "get mqtt failed"})
+                resp_dict = await resp.json()
+                return response_factory(Response[dict], resp_dict)
+
     async def refresh_login(self) -> Response[LoginResponseData]:
         if self.expires_in > time.time():
             res = await self.refresh_token()
@@ -297,7 +405,7 @@ class MammotionHTTP:
                     return Response.from_dict({"code": resp.status, "msg": "Login failed"})
                 data = await resp.json()
                 login_response = response_factory(Response[LoginResponseData], data)
-                if login_response.data is None:
+                if login_response is None or login_response.data is None:
                     print(login_response)
                     return Response.from_dict({"code": resp.status, "msg": "Login failed"})
                 self.login_info = login_response.data
@@ -308,6 +416,9 @@ class MammotionHTTP:
                 self.response = login_response
                 self.msg = login_response.msg
                 self.code = login_response.code
+                decoded_token = jwt.decode(self.response.data.access_token, options={"verify_signature": False})
+                if isinstance(decoded_token, dict):
+                    self.jwt_info = JWTTokenInfo(iot=decoded_token.get("iot", ""), robot=decoded_token.get("robot", ""))
                 # TODO catch errors from mismatch user / password elsewhere
                 # Assuming the data format matches the expected structure
                 return login_response

pymammotion/http/model/http.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Annotated, Generic, Literal, TypeVar
 
 from mashumaro import DataClassDictMixin
@@ -68,9 +68,76 @@ class ErrorInfo(DataClassDictMixin):
 
 
 @dataclass
-class Response(DataClassDictMixin, Generic[DataT]):
+class SettingVo(DataClassORJSONMixin):
+    """Device setting configuration."""
+
+    type: int = 0
+    is_switch: Annotated[int, Alias("isSwitch")] = 0
+
+
+@dataclass
+class LocationVo(DataClassORJSONMixin):
+    """Device location information."""
+
+    date_time: Annotated[str, Alias("dateTime")] = ""
+    date_timestamp: Annotated[int, Alias("dateTimestamp")] = 0
+    location: list[float] = field(default_factory=lambda: [0.0, 0.0])
+
+
+@dataclass
+class DeviceInfo:
+    """Complete device information."""
+
+    iot_id: Annotated[str, Alias("iotId")] = ""
+    device_id: Annotated[str, Alias("deviceId")] = ""
+    device_name: Annotated[str, Alias("deviceName")] = ""
+    device_type: Annotated[str, Alias("deviceType")] = ""
+    series: str = ""
+    product_series: Annotated[str, Alias("productSeries")] = ""
+    icon_code: Annotated[str, Alias("iconCode")] = ""
+    generation: int = 0
+    status: int = 0
+    is_subscribe: Annotated[int, Alias("isSubscribe")] = 0
+    setting_vos: Annotated[list[SettingVo], Alias("settingVos")] = field(default_factory=list)
+    active_time: Annotated[str, Alias("activeTime")] = ""
+    active_timestamp: Annotated[int, Alias("activeTimestamp")] = 0
+    location_vo: Annotated[LocationVo | None, Alias("locationVo")] = None
+
+
+@dataclass
+class DeviceRecord(DataClassORJSONMixin):
+    identity_id: Annotated[str, Alias("identityId")]
+    iot_id: Annotated[str, Alias("iotId")]
+    product_key: Annotated[str, Alias("productKey")]
+    device_name: Annotated[str, Alias("deviceName")]
+    owned: int
+    status: int
+    bind_time: Annotated[int, Alias("bindTime")]
+    create_time: Annotated[str, Alias("createTime")]
+
+
+@dataclass
+class DeviceRecords(DataClassORJSONMixin):
+    records: list[DeviceRecord]
+    total: int
+    size: int
+    current: int
+    pages: int
+
+
+@dataclass
+class MQTTConnection(DataClassORJSONMixin):
+    host: str
+    jwt: str
+    client_id: Annotated[str, Alias("clientId")]
+    username: str
+
+
+@dataclass
+class Response(DataClassORJSONMixin, Generic[DataT]):
     code: int
     msg: str
+    request_id: Annotated[str, Alias("requestId")] | None = None
     data: DataT | None = None
 
     class Config(BaseConfig):
@@ -90,6 +157,14 @@ class LoginResponseUserInformation(DataClassORJSONMixin):
         omit_none = True
 
 
+@dataclass
+class JWTTokenInfo(DataClassORJSONMixin):
+    """specifically for newer devices and mqtt"""
+
+    iot: str  # iot domain e.g api-iot-business-eu-dcdn.mammotion.com
+    robot: str  # e.g api-robot-eu.mammotion.com
+
+
 @dataclass
 class LoginResponseData(DataClassORJSONMixin):
     access_token: str

pymammotion/http/model/response_factory.py

@@ -7,19 +7,20 @@ T = TypeVar("T")
 
 def deserialize_data(value, target_type):
     """Deserialize data into a specified target type.
-    
+
     The function handles deserialization of basic types, lists, and unions. It
     recursively processes list elements and supports optional types by handling
     Union[T, None]. For custom types with a `from_dict` method, it calls this
     method for deserialization. If the target type is unknown or unsupported, it
     returns the value unchanged.
-    
+
     Args:
         value: The data to be deserialized.
         target_type (type): The desired type into which the data should be deserialized.
-    
+
     Returns:
         The deserialized data in the specified target type.
+
     """
     if value is None:
         return None
@@ -35,7 +36,12 @@ def deserialize_data(value, target_type):
         # Support Optional[T] = Union[T, None]
         non_none_types = [t for t in args if t is not type(None)]
         if len(non_none_types) == 1:
-            return deserialize_data(value, non_none_types[0])
+            target = non_none_types[0]
+            # Handle Response[list[type]] case
+            if get_origin(target) is list and get_args(target):
+                item_type = get_args(target)[0]
+                return [deserialize_data(v, item_type) for v in value]
+            return deserialize_data(value, target)
 
     if hasattr(target_type, "from_dict"):
         return target_type.from_dict(value)

pymammotion/mammotion/commands/mammotion_command.py

@@ -44,6 +44,12 @@ class MammotionCommand(
         # 1 multipoint turn
         return self.read_write_device(6, context, 1)
 
+    def get_error_code(self) -> bytes:
+        return self.read_write_device(5, 2, 1)
+
+    def get_error_timestamp(self) -> bytes:
+        return self.read_write_device(5, 3, 1)
+
     def get_device_product_key(self) -> str:
         return self._product_key
 

pymammotion/mammotion/commands/messages/navigation.py

@@ -33,7 +33,7 @@ logger = logging.getLogger(__name__)
 
 
 class MessageNavigation(AbstractMessage, ABC):
-    def send_order_msg_nav(self, build) -> bytes:
+    def send_order_msg_nav(self, build: MctlNav) -> bytes:
         luba_msg = LubaMsg(
             msgtype=MsgCmdType.NAV,
             sender=MsgDevice.DEV_MOBILEAPP,
@@ -206,9 +206,9 @@ class MessageNavigation(AbstractMessage, ABC):
             reserved=plan_bean.reserved,
             weeks=plan_bean.weeks,
             start_date=plan_bean.start_date,
-            trigger_type=plan_bean.job_type,
-            day=plan_bean.interval_days,
-            toward_included_angle=plan_bean.demond_angle,
+            trigger_type=plan_bean.trigger_type,
+            day=plan_bean.day,
+            toward_included_angle=plan_bean.toward_included_angle,
             toward_mode=0,
         )
         logger.debug(f"Send read job plan command planBean={plan_bean}")
@@ -262,7 +262,7 @@ class MessageNavigation(AbstractMessage, ABC):
             toapp_map_name_msg=NavMapNameMsg(
                 hash=0,
                 result=0,
-                device_id=device_id,  # iotId or ???
+                device_id=device_id,  # iot_id
                 rw=0,
             )
         )
@@ -390,7 +390,7 @@ class MessageNavigation(AbstractMessage, ABC):
         generate_route_information}")
         return self.send_order_msg_nav(MctlNav(bidire_reqconver_path=build))
 
-    def modify_generate_route_information(self, generate_route_information: GenerateRouteInformation) -> bytes:
+    def modify_route_information(self, generate_route_information: GenerateRouteInformation) -> bytes:
         logger.debug(f"Generate route data source: {generate_route_information}")
         build = NavReqCoverPath(
             pver=1,
@@ -432,7 +432,11 @@ class MessageNavigation(AbstractMessage, ABC):
         return self.send_order_msg_nav(build)
 
     def get_line_info_list(self, hash_list: list[int], transaction_id: int) -> bytes:
+        """Get route information (mow path) corresponding to the specified hash list based on time.
+        e.g transaction_id = int(time.time() * 1000)
+        """
         logger.debug(f"Sending==========Get route command: {hash_list}")
+
         build = MctlNav(
             app_request_cover_paths=AppRequestCoverPathsT(
                 pver=1, hash_list=hash_list, transaction_id=transaction_id, sub_cmd=0

pymammotion/mammotion/devices/__init__.py

@@ -1,5 +1,29 @@
-"""mqtt init."""
+"""Mammotion devices module."""
 
-from .mammotion import MammotionBaseBLEDevice
+from .mammotion import Mammotion, MammotionDeviceManager
+from .mammotion_bluetooth import MammotionBaseBLEDevice
+from .mammotion_cloud import MammotionBaseCloudDevice, MammotionCloud
+from .mammotion_mower_ble import MammotionMowerBLEDevice
+from .mammotion_mower_cloud import MammotionMowerCloudDevice
+from .mower_device import MammotionMowerDevice
+from .mower_manager import MammotionMowerDeviceManager
+from .rtk_ble import MammotionRTKBLEDevice
+from .rtk_cloud import MammotionRTKCloudDevice
+from .rtk_device import MammotionRTKDevice
+from .rtk_manager import MammotionRTKDeviceManager
 
-__all__ = ["MammotionBaseBLEDevice"]
+__all__ = [
+    "Mammotion",
+    "MammotionDeviceManager",
+    "MammotionMowerDeviceManager",
+    "MammotionBaseBLEDevice",
+    "MammotionBaseCloudDevice",
+    "MammotionCloud",
+    "MammotionMowerBLEDevice",
+    "MammotionMowerCloudDevice",
+    "MammotionMowerDevice",
+    "MammotionRTKBLEDevice",
+    "MammotionRTKCloudDevice",
+    "MammotionRTKDevice",
+    "MammotionRTKDeviceManager",
+]

pymammotion/mammotion/devices/base.py

@@ -1,4 +1,4 @@
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 import asyncio
 import logging
 from typing import Any
@@ -6,35 +6,18 @@ from typing import Any
 import betterproto2
 
 from pymammotion.aliyun.model.dev_by_account_response import Device
-from pymammotion.data.model import RegionData
 from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.model.raw_data import RawMowerData
-from pymammotion.data.state_manager import StateManager
-from pymammotion.proto import LubaMsg, NavGetCommDataAck, NavGetHashListAck, NavPlanJobSet, SvgMessageAckT
-from pymammotion.utility.device_type import DeviceType
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.proto import LubaMsg
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def find_next_integer(lst: list[int], current_hash: int) -> int | None:
-    try:
-        # Find the index of the current integer
-        current_index = lst.index(current_hash)
-
-        # Check if there is a next integer in the list
-        if current_index + 1 < len(lst):
-            return lst[current_index + 1]
-        else:
-            return None  # Or raise an exception or handle it in some other way
-    except ValueError:
-        # Handle the case where current_int is not in the list
-        return None  # Or raise an exception or handle it in some other way
-
-
-class MammotionBaseDevice:
+class MammotionBaseDevice(ABC):
     """Base class for Mammotion devices."""
 
-    def __init__(self, state_manager: StateManager, cloud_device: Device) -> None:
+    def __init__(self, state_manager: MowerStateManager, cloud_device: Device) -> None:
         """Initialize MammotionBaseDevice."""
         self.loop = asyncio.get_event_loop()
         self._state_manager = state_manager
@@ -43,57 +26,6 @@ class MammotionBaseDevice:
         self._notify_future: asyncio.Future[bytes] | None = None
         self._cloud_device = cloud_device
 
-    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 None
-            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:
-        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)
-
     def _update_raw_data(self, data: bytes) -> None:
         """Update raw and model data from notifications."""
         tmp_msg = LubaMsg().parse(data)
@@ -127,7 +59,7 @@ class MammotionBaseDevice:
             nav[nav_sub_msg[0]] = nav_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["nav"] = nav
 
-    def _update_sys_data(self, tmp_msg) -> None:
+    def _update_sys_data(self, tmp_msg: LubaMsg) -> None:
         """Update system data."""
         sys_sub_msg = betterproto2.which_one_of(tmp_msg.sys, "SubSysMsg")
         if sys_sub_msg[1] is None:
@@ -137,7 +69,7 @@ class MammotionBaseDevice:
         sys[sys_sub_msg[0]] = sys_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["sys"] = sys
 
-    def _update_driver_data(self, tmp_msg) -> None:
+    def _update_driver_data(self, tmp_msg: LubaMsg) -> None:
         """Update driver data."""
         drv_sub_msg = betterproto2.which_one_of(tmp_msg.driver, "SubDrvMsg")
         if drv_sub_msg[1] is None:
@@ -147,7 +79,7 @@ class MammotionBaseDevice:
         drv[drv_sub_msg[0]] = drv_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["driver"] = drv
 
-    def _update_net_data(self, tmp_msg) -> None:
+    def _update_net_data(self, tmp_msg: LubaMsg) -> None:
         """Update network data."""
         net_sub_msg = betterproto2.which_one_of(tmp_msg.net, "NetSubType")
         if net_sub_msg[1] is None:
@@ -160,7 +92,7 @@ class MammotionBaseDevice:
             net[net_sub_msg[0]] = net_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["net"] = net
 
-    def _update_mul_data(self, tmp_msg) -> None:
+    def _update_mul_data(self, tmp_msg: LubaMsg) -> None:
         """Update mul data."""
         mul_sub_msg = betterproto2.which_one_of(tmp_msg.mul, "SubMul")
         if mul_sub_msg[1] is None:
@@ -170,7 +102,7 @@ class MammotionBaseDevice:
         mul[mul_sub_msg[0]] = mul_sub_msg[1].to_dict(casing=betterproto2.Casing.SNAKE)
         self._raw_data["mul"] = mul
 
-    def _update_ota_data(self, tmp_msg) -> None:
+    def _update_ota_data(self, tmp_msg: LubaMsg) -> None:
         """Update OTA data."""
         ota_sub_msg = betterproto2.which_one_of(tmp_msg.ota, "SubOtaMsg")
         if ota_sub_msg[1] is None:
@@ -191,71 +123,17 @@ class MammotionBaseDevice:
         return self._state_manager.get_device()
 
     @abstractmethod
-    async def queue_command(self, key: str, **kwargs: any) -> bytes | None:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         """Queue commands to mower."""
 
     @abstractmethod
-    async def _ble_sync(self):
+    async def _ble_sync(self) -> None:
         """Send ble sync command every 3 seconds or sooner."""
 
     @abstractmethod
-    def stop(self):
+    def stop(self) -> None:
         """Stop everything ready for destroying."""
 
-    async def start_sync(self, retry: int) -> None:
-        """Start synchronization with the device."""
-        await self.queue_command("get_device_base_info")
-        await self.queue_command("get_device_product_model")
-        await self.queue_command("get_report_cfg")
-        """RTK and dock location."""
-        await self.queue_command("read_write_device", rw_id=5, context=1, rw=1)
-        await self.async_read_settings()
-
-    async def start_map_sync(self) -> None:
-        """Start sync of map data."""
-
-        self.mower.map.update_hash_lists(self.mower.map.hashlist)
-
-        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.iotId)
-
-        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]
-
-        # don't know why but total frame on svg is wrong
-        # for hash, frame in self.mower.map.svg.items():
-        #     missing_frames = self.mower.map.find_missing_frames(frame)
-        #     if len(missing_frames) > 0:
-        #         del self.mower.map.svg[hash]
-
-        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)
-
-        # sub_cmd 3 is job hashes??
-        # sub_cmd 4 is dump location (yuka)
-        # jobs list
-        #
-        # await self.queue_command("get_all_boundary_hash_list", sub_cmd=3)
-
     async def async_read_settings(self) -> None:
         """Read settings from device."""
         # no cutting in rain nav_sys_param_cmd (id 3 context 1/0)
@@ -276,10 +154,10 @@ class MammotionBaseDevice:
         await self.queue_command("read_write_device", rw_id=5, rw=1, context=2)
         await self.queue_command("read_write_device", rw_id=5, rw=1, context=3)
 
-    async def command(self, key: str, **kwargs):
+    async def command(self, key: str, **kwargs: Any) -> None:
         """Send a command to the device."""
-        return await self.queue_command(key, **kwargs)
+        await self.queue_command(key, **kwargs)
 
     @property
-    def state_manager(self):
+    def state_manager(self) -> MowerStateManager:
         return self._state_manager