pymammotion 0.3.7__py3-none-any.whl → 0.4.0__py3-none-any.whl

pymammotion/mammotion/commands/messages/network.py

@@ -1,11 +1,11 @@
 # === sendOrderMsg_Net  ===
-import time
 from abc import ABC
+import time
 
 from pymammotion import logger
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
 from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
-from pymammotion.proto.dev_net import (
+from pymammotion.proto import (
     DevNet,
     DrvDebugDdsZmq,
     DrvDevInfoReq,
@@ -18,11 +18,14 @@ from pymammotion.proto.dev_net import (
     DrvWifiUpload,
     GetNetworkInfoReq,
     IotConctrlType,
+    LubaMsg,
     MnetCfg,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
     NetType,
     SetMnetCfgReq,
 )
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
 
 
 class MessageNetwork(AbstractMessage, ABC):
@@ -31,10 +34,10 @@ class MessageNetwork(AbstractMessage, ABC):
     @staticmethod
     def send_order_msg_net(build: DevNet) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_ESP,
+            msgtype=MsgCmdType.ESP,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_COMM_ESP,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,
@@ -48,13 +51,13 @@ class MessageNetwork(AbstractMessage, ABC):
         comm_esp = DevNet(todev_ble_sync=sync_type)
         return self.send_order_msg_net(comm_esp)
 
-    def get_device_base_info(self) -> bytes:
+    def get_device_version_main(self) -> bytes:
         net = DevNet(todev_devinfo_req=DrvDevInfoReq())
         net.todev_devinfo_req.req_ids.append(DrvDevInfoReqId(id=1, type=6))
 
         return self.send_order_msg_net(net)
 
-    def get_device_version_main(self) -> bytes:
+    def get_device_base_info(self) -> bytes:
         net = DevNet(todev_devinfo_req=DrvDevInfoReq())
 
         for i in range(1, 8):
@@ -76,7 +79,7 @@ class MessageNetwork(AbstractMessage, ABC):
 
     def set_zmq_enable(self) -> bytes:
         build = DevNet(
-            todev_set_dds2zmq=DrvDebugDdsZmq(
+            todev_set_dds2_zmq=DrvDebugDdsZmq(
                 is_enable=True,
                 rx_topic_name="perception_post_result",
                 tx_zmq_url="tcp://0.0.0.0:5555",
@@ -164,7 +167,7 @@ class MessageNetwork(AbstractMessage, ABC):
             todev_ble_sync=1,
             todev_set_mnet_cfg_req=SetMnetCfgReq(
                 cfg=MnetCfg(
-                    type=NetType.NET_TYPE_WIFI,
+                    type=NetType.WIFI,
                     inet_enable=new_4g_status,
                     mnet_enable=new_4g_status,
                 )
@@ -177,7 +180,7 @@ class MessageNetwork(AbstractMessage, ABC):
     def set_device_wifi_enable_status(self, new_wifi_status: bool) -> bytes:
         build = DevNet(
             todev_ble_sync=1,
-            todev__wifi__configuration=DrvWifiSet(config_param=4, wifi_enable=new_wifi_status),
+            todev_wifi_configuration=DrvWifiSet(config_param=4, wifi_enable=new_wifi_status),
         )
         logger.debug(f"szNetwork: Send command - set network (on/off status). newWifiStatus={new_wifi_status}")
         return self.send_order_msg_net(build)
@@ -185,7 +188,7 @@ class MessageNetwork(AbstractMessage, ABC):
     def wifi_connectinfo_update(self) -> bytes:
         build = DevNet(
             todev_ble_sync=1,
-            todev__wifi_msg_upload=DrvWifiUpload(wifi_msg_upload=1),
+            todev_wifi_msg_upload=DrvWifiUpload(wifi_msg_upload=1),
         )
         logger.debug("Send command - get Wifi connection information")
         return self.send_order_msg_net(build)
@@ -193,17 +196,17 @@ class MessageNetwork(AbstractMessage, ABC):
     def wifi_connectinfo_update2(self) -> None:
         hash_map = {"getMsgCmd": 1}
         # self.post_custom_data(self.get_json_string(
-        #     68, hash_map))  # ToDo: Fix this
+        #     68, hash_map))  # TODO: Fix this
 
     def get_record_wifi_list(self) -> bytes:
-        build = DevNet(todev_ble_sync=1, todev__wifi_list_upload=DrvWifiList())
+        build = DevNet(todev_ble_sync=1, todev_wifi_list_upload=DrvWifiList())
         logger.debug("Send command - get memorized WiFi list upload command")
         return self.send_order_msg_net(build)
 
     def close_clear_connect_current_wifi(self, ssid: str, status: int) -> bytes:
         build = DevNet(
             todev_ble_sync=1,
-            todev__wifi__configuration=DrvWifiSet(config_param=status, confssid=ssid),
+            todev_wifi_configuration=DrvWifiSet(config_param=status, confssid=ssid),
         )
         logger.debug(
             f"Send command - set network (disconnect, direct connect, forget, no operation reconnect) operation command (downlink ssid={ssid}, status={status})"

pymammotion/mammotion/commands/messages/ota.py

@@ -2,17 +2,16 @@
 from abc import ABC
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import luba_msg_pb2, mctrl_ota_pb2
-from pymammotion.proto.luba_msg import MsgCmdType, MsgDevice
+from pymammotion.proto import GetInfoReq, InfoType, LubaMsg, MctlOta, MsgAttr, MsgCmdType, MsgDevice
 
 
 class MessageOta(AbstractMessage, ABC):
     def send_order_msg_ota(self, ota):
-        luba_msg = luba_msg_pb2.LubaMsg(
-            msgtype=luba_msg_pb2.MSG_CMD_TYPE_EMBED_OTA,
-            sender=luba_msg_pb2.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_EMBED_OTA, MsgDevice.DEV_MAINCTL),
-            msgattr=luba_msg_pb2.MSG_ATTR_REQ,
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.EMBED_OTA,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.EMBED_OTA, MsgDevice.DEV_MAINCTL),
+            msgattr=MsgAttr.MSG_ATTR_REQ,
             seqs=1,
             version=1,
             subtype=1,
@@ -22,17 +21,13 @@ class MessageOta(AbstractMessage, ABC):
         return luba_msg.SerializeToString()
 
     def get_device_ota_info(self, log_type: int):
-        todev_get_info_req = mctrl_ota_pb2.MctlOta(
-            todev_get_info_req=mctrl_ota_pb2.getInfoReq(type=mctrl_ota_pb2.IT_OTA)
-        )
+        todev_get_info_req = MctlOta(todev_get_info_req=GetInfoReq(type=InfoType.IT_OTA))
 
         print("===Send command to get upgrade details===logType:" + str(log_type))
         return self.send_order_msg_ota(todev_get_info_req)
 
-    def get_device_info_new(self):
+    def get_device_info_new(self) -> bytes:
         """New device call for OTA upgrade information."""
-        todev_get_info_req = mctrl_ota_pb2.MctlOta(
-            todev_get_info_req=mctrl_ota_pb2.getInfoReq(type=mctrl_ota_pb2.IT_BASE)
-        )
+        todev_get_info_req = MctlOta(todev_get_info_req=GetInfoReq(type=InfoType.IT_BASE))
         print("Send to get OTA upgrade information", "Get device information")
         return self.send_order_msg_ota(todev_get_info_req)

pymammotion/mammotion/commands/messages/system.py

@@ -1,17 +1,20 @@
 # === sendOrderMsg_Sys ===
+from abc import ABC
 import datetime
 import time
-from abc import ABC
 
 from pymammotion import logger
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
 from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
-from pymammotion.proto.mctrl_sys import (
+from pymammotion.proto import (
     DeviceProductTypeInfoT,
     LoraCfgReq,
+    LubaMsg,
     MctlSys,
     MCtrlSimulationCmdData,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
     ReportInfoCfg,
     RptAct,
     RptInfoType,
@@ -26,12 +29,12 @@ from pymammotion.utility.device_type import DeviceType
 class MessageSystem(AbstractMessage, ABC):
     messageNavigation: MessageNavigation = MessageNavigation()
 
-    def send_order_msg_sys(self, sys):
+    def send_order_msg_sys(self, sys) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgtype=MsgCmdType.EMBED_SYS,
+            msgattr=MsgAttr.REQ,
             sender=MsgDevice.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_EMBED_SYS, MsgDevice.DEV_MAINCTL),
+            rcver=self.get_msg_device(MsgCmdType.EMBED_SYS, MsgDevice.DEV_MAINCTL),
             sys=sys,
             seqs=1,
             version=1,
@@ -42,10 +45,10 @@ class MessageSystem(AbstractMessage, ABC):
         return luba_msg.SerializeToString()
 
     @staticmethod
-    def send_order_msg_sys_legacy(sys):
+    def send_order_msg_sys_legacy(sys) -> bytes:
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgtype=MsgCmdType.EMBED_SYS,
+            msgattr=MsgAttr.REQ,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_MAINCTL,
             sys=sys,
@@ -57,12 +60,12 @@ class MessageSystem(AbstractMessage, ABC):
 
         return luba_msg.SerializeToString()
 
-    def reset_system(self):
+    def reset_system(self) -> bytes:
         build = MctlSys(todev_reset_system=1)
         logger.debug("Send command - send factory reset")
         return self.send_order_msg_sys(build)
 
-    def set_blade_control(self, on_off: int):
+    def set_blade_control(self, on_off: int) -> bytes:
         mctlsys = MctlSys()
         sys_knife_control = SysKnifeControl()
         sys_knife_control.knife_status = on_off
@@ -70,10 +73,10 @@ class MessageSystem(AbstractMessage, ABC):
 
         return self.send_order_msg_sys(mctlsys)
 
-    def get_device_product_model(self):
+    def get_device_product_model(self) -> bytes:
         return self.send_order_msg_sys(MctlSys(device_product_type_info=DeviceProductTypeInfoT(result=1)))
 
-    def read_and_set_sidelight(self, is_sidelight: bool, operate: int):
+    def read_and_set_sidelight(self, is_sidelight: bool, operate: int) -> bytes:
         """Read state of sidelight as well as set it."""
         if is_sidelight:
             build = TimeCtrlLight(
@@ -102,7 +105,7 @@ class MessageSystem(AbstractMessage, ABC):
             is_sidelight}, operate:{operate}, timeCtrlLight:{build}")
         return self.send_order_msg_sys(build2)
 
-    def test_tool_order_to_sys(self, sub_cmd: int, param_id: int, param_value: list[int]):
+    def test_tool_order_to_sys(self, sub_cmd: int, param_id: int, param_value: list[int]) -> bytes:
         build = MCtrlSimulationCmdData(sub_cmd=sub_cmd, param_id=param_id, param_value=param_value)
         logger.debug(f"Send tool test command: subCmd={sub_cmd}, param_id:{
             param_id}, param_value={param_value}")
@@ -111,20 +114,20 @@ class MessageSystem(AbstractMessage, ABC):
             param_id}, param_value={param_value}")
         return self.send_order_msg_sys(build2)
 
-    def read_and_set_rtk_paring_code(self, op: int, cgf: str | None = None):
+    def read_and_set_rtk_paring_code(self, op: int, cgf: str | None = None) -> bytes:
         logger.debug(f"Send read and write base station configuration quality op:{
             op}, cgf:{cgf}")
         return self.send_order_msg_sys(MctlSys(todev_lora_cfg_req=LoraCfgReq(op=op, cfg=cgf)))
 
-    def allpowerfull_rw(self, id: int, context: int, rw: int) -> bytes:
-        if (id == 6 or id == 3 or id == 7) and DeviceType.is_luba_2(self.get_device_name()):
-            return self.messageNavigation.allpowerfull_rw_adapter_x3(id, context, rw)
-        build = MctlSys(bidire_comm_cmd=SysCommCmd(id=id, context=context, rw=rw))
-        logger.debug(f"Send command - 9 general read and write command id={id}, context={context}, rw={rw}")
-        if id == 5:
+    def allpowerfull_rw(self, rw_id: int, context: int, rw: int) -> bytes:
+        if (rw_id == 6 or rw_id == 3 or rw_id == 7) and DeviceType.is_luba_2(self.get_device_name()):
+            return self.messageNavigation.allpowerfull_rw_adapter_x3(rw_id, context, rw)
+        build = MctlSys(bidire_comm_cmd=SysCommCmd(id=rw_id, context=context, rw=rw))
+        logger.debug(f"Send command - 9 general read and write command id={rw_id}, context={context}, rw={rw}")
+        if rw_id == 5:
             # TODO investigate if the original code makes any difference to this call.
             """
-            LubaMsgOuterClass.LubaMsg.Builder protoBufBuilderSet = getProtoBufBuilderSet(LubaMsgOuterClass.MsgCmdType.MSG_CMD_TYPE_EMBED_SYS, LubaMsgOuterClass.MsgDevice.DEV_MAINCTL, LubaMsgOuterClass.MsgAttr.MSG_ATTR_REQ);
+            LubaMsgOuterClass.LubaMsg.Builder protoBufBuilderSet = getProtoBufBuilderSet(LubaMsgOuterClass.MsgCmdType.EMBED_SYS, LubaMsgOuterClass.MsgDevice.DEV_MAINCTL, LubaMsgOuterClass.MsgAttr.REQ);
             protoBufBuilderSet.setSys(build);
             sendMsg(protoBufBuilderSet, 122, true, "发送指令--9通用读写命令id=" + i + ",context=" + i2 + ",rw=" + i3);
             """
@@ -197,7 +200,7 @@ class MessageSystem(AbstractMessage, ABC):
     #         test_id}, testDuration={test_duration}", "Factory tool logger.debug222", True)
     #     return self.send_order_msg_sys(build2)
 
-    def send_sys_set_date_time(self):
+    def send_sys_set_date_time(self) -> bytes:
         calendar = datetime.datetime.now()
         i = calendar.year
         i2 = calendar.month
@@ -231,7 +234,7 @@ class MessageSystem(AbstractMessage, ABC):
         )
         return self.send_order_msg_sys(build)
 
-    def get_device_version_info(self):
+    def get_device_version_info(self) -> bytes:
         return self.send_order_msg_sys(MctlSys(todev_get_dev_fw_info=1))
 
     def read_and_set_rtk_pairing_code(self, op: int, cfg: str) -> bytes:
@@ -298,10 +301,10 @@ class MessageSystem(AbstractMessage, ABC):
         mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC)
 
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
+            msgtype=MsgCmdType.EMBED_SYS,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_MAINCTL,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,
@@ -334,10 +337,10 @@ class MessageSystem(AbstractMessage, ABC):
         mctl_sys.todev_report_cfg.sub.append(RptInfoType.RIT_BASESTATION_INFO)
 
         luba_msg = LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
+            msgtype=MsgCmdType.EMBED_SYS,
             sender=MsgDevice.DEV_MOBILEAPP,
             rcver=MsgDevice.DEV_MAINCTL,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            msgattr=MsgAttr.REQ,
             seqs=1,
             version=1,
             subtype=1,

pymammotion/mammotion/commands/messages/video.py

@@ -1,20 +1,19 @@
 # === sendOrderMsg_Video ===
-import time
 from abc import ABC
+import time
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import luba_msg_pb2, luba_mul_pb2
-from pymammotion.proto.luba_msg import MsgAttr, MsgCmdType, MsgDevice
+from pymammotion.proto import LubaMsg, MsgAttr, MsgCmdType, MsgDevice, MulCameraPosition, MulSetVideo, SocMul
 from pymammotion.utility.device_type import DeviceType
 
 
 class MessageVideo(AbstractMessage, ABC):
     async def send_order_msg_video(self, mul):
-        luba_msg = luba_msg_pb2.LubaMsg(
-            msgtype=luba_msg_pb2.MSG_CMD_TYPE_MUL,
-            msgattr=MsgAttr.MSG_ATTR_REQ,
-            sender=luba_msg_pb2.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_MUL, MsgDevice.SOC_MODULE_MULTIMEDIA),
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.MUL,
+            msgattr=MsgAttr.REQ,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.MUL, MsgDevice.SOC_MODULE_MULTIMEDIA),
             mul=mul,
             seqs=1,
             version=1,
@@ -25,10 +24,6 @@ class MessageVideo(AbstractMessage, ABC):
         return luba_msg.SerializeToString()
 
     def device_agora_join_channel_with_position(self, enter_state: int):
-        position = (
-            luba_mul_pb2.MUL_CAMERA_POSITION.ALL
-            if DeviceType.is_yuka(self.get_device_name())
-            else luba_mul_pb2.MUL_CAMERA_POSITION.LEFT
-        )
-        mctl_sys = luba_mul_pb2.SocMul(set_video=luba_mul_pb2.MulSetVideo(position=position, vi_switch=enter_state))
+        position = MulCameraPosition.ALL if DeviceType.is_yuka(self.get_device_name()) else MulCameraPosition.LEFT
+        mctl_sys = SocMul(set_video=MulSetVideo(position=position, vi_switch=enter_state))
         return self.send_order_msg_video(mctl_sys)

pymammotion/mammotion/devices/base.py

@@ -1,16 +1,16 @@
+from abc import abstractmethod
 import asyncio
 import logging
-from abc import abstractmethod
-from typing import Any, Awaitable, Callable
+from typing import Any
 
 import betterproto
 
 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.luba_msg import LubaMsg
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
+from pymammotion.proto import LubaMsg, NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,19 +36,12 @@ class MammotionBaseDevice:
     def __init__(self, state_manager: StateManager, cloud_device: Device | None = None) -> None:
         """Initialize MammotionBaseDevice."""
         self.loop = asyncio.get_event_loop()
-        self._raw_data = LubaMsg().to_dict(casing=betterproto.Casing.SNAKE)
         self._state_manager = state_manager
-        self._state_manager.gethash_ack_callback = self.datahash_response
-        self._state_manager.get_commondata_ack_callback = self.commdata_response
+        self._raw_data = dict()
+        self._raw_mower_data: RawMowerData = RawMowerData()
         self._notify_future: asyncio.Future[bytes] | None = None
         self._cloud_device = cloud_device
 
-    def set_notification_callback(self, func: Callable[[tuple[str, Any | None]], Awaitable[None]]) -> None:
-        self._state_manager.on_notification_callback = func
-
-    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[bytes]]) -> None:
-        self._state_manager.queue_command_callback = func
-
     async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
         """Handle datahash responses."""
         current_frame = hash_ack.current_frame
@@ -108,7 +101,7 @@ class MammotionBaseDevice:
             case "ota":
                 self._update_ota_data(tmp_msg)
 
-        self.mower.update_raw(self._raw_data)
+        self._raw_mower_data.update_raw(self._raw_data)
 
     def _update_nav_data(self, tmp_msg) -> None:
         """Update navigation data."""

pymammotion/mammotion/devices/mammotion.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 from enum import Enum
+import logging
 from typing import Any
 
 from bleak.backends.device import BLEDevice
@@ -14,7 +14,7 @@ from pymammotion.aliyun.model.dev_by_account_response import Device
 from pymammotion.data.model.account import Credentials
 from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.state_manager import StateManager
-from pymammotion.http.http import connect_http
+from pymammotion.http.http import MammotionHTTP
 from pymammotion.mammotion.devices.mammotion_bluetooth import MammotionBaseBLEDevice
 from pymammotion.mammotion.devices.mammotion_cloud import MammotionBaseCloudDevice, MammotionCloud
 from pymammotion.mqtt import MammotionMQTT
@@ -84,9 +84,15 @@ class MammotionMixedDeviceManager:
     def replace_cloud(self, cloud_device: MammotionBaseCloudDevice) -> None:
         self._cloud_device = cloud_device
 
+    def remove_cloud(self) -> None:
+        del self._cloud_device
+
     def replace_ble(self, ble_device: MammotionBaseBLEDevice) -> None:
         self._ble_device = ble_device
 
+    def remove_ble(self) -> None:
+        del self._ble_device
+
     def replace_mqtt(self, mqtt: MammotionCloud) -> None:
         device = self._cloud_device.device
         self._cloud_device = MammotionBaseCloudDevice(mqtt, cloud_device=device, state_manager=self._state_manager)
@@ -98,7 +104,7 @@ class MammotionMixedDeviceManager:
         return self._ble_device is not None
 
 
-class MammotionDevices:
+class MammotionDeviceManager:
     devices: dict[str, MammotionMixedDeviceManager] = {}
 
     def add_device(self, mammotion_device: MammotionMixedDeviceManager) -> None:
@@ -151,10 +157,10 @@ async def create_devices(
 class Mammotion:
     """Represents a Mammotion account and its devices."""
 
-    devices = MammotionDevices()
+    device_manager = MammotionDeviceManager()
     mqtt_list: dict[str, MammotionCloud] = dict()
 
-    _instance: Mammotion = None
+    _instance: Mammotion | None = None
 
     def __new__(cls, *args: Any, **kwargs: Any):
         if not cls._instance:
@@ -169,7 +175,7 @@ class Mammotion:
         self, ble_device: BLEDevice, preference: ConnectionPreference = ConnectionPreference.BLUETOOTH
     ) -> None:
         if ble_device:
-            self.devices.add_device(
+            self.device_manager.add_device(
                 MammotionMixedDeviceManager(name=ble_device.name, ble_device=ble_device, preference=preference)
             )
 
@@ -205,9 +211,9 @@ class Mammotion:
 
     def add_cloud_devices(self, mqtt_client: MammotionCloud) -> None:
         for device in mqtt_client.cloud_client.devices_by_account_response.data.data:
-            mower_device = self.devices.get_device(device.deviceName)
+            mower_device = self.device_manager.get_device(device.deviceName)
             if device.deviceName.startswith(("Luba-", "Yuka-")) and mower_device is None:
-                self.devices.add_device(
+                self.device_manager.add_device(
                     MammotionMixedDeviceManager(
                         name=device.deviceName,
                         cloud_device=device,
@@ -222,7 +228,7 @@ class Mammotion:
                     mower_device.replace_mqtt(mqtt_client)
 
     def set_disconnect_strategy(self, disconnect: bool) -> None:
-        for device_name, device in self.devices.devices.items():
+        for device_name, device in self.device_manager.devices.items():
             if device.ble() is not None:
                 ble_device: MammotionBaseBLEDevice = device.ble()
                 ble_device.set_disconnect_strategy(disconnect)
@@ -230,7 +236,8 @@ class Mammotion:
     async def login(self, account: str, password: str) -> CloudIOTGateway:
         """Login to mammotion cloud."""
         cloud_client = CloudIOTGateway()
-        mammotion_http = await connect_http(account, password)
+        mammotion_http = MammotionHTTP()
+        await mammotion_http.login(account, password)
         country_code = mammotion_http.login_info.userInformation.domainAbbreviation
         _LOGGER.debug("CountryCode: " + country_code)
         _LOGGER.debug("AuthCode: " + mammotion_http.login_info.authorization_code)
@@ -248,10 +255,10 @@ class Mammotion:
         return cloud_client
 
     async def remove_device(self, name: str) -> None:
-        await self.devices.remove_device(name)
+        await self.device_manager.remove_device(name)
 
     def get_device_by_name(self, name: str) -> MammotionMixedDeviceManager:
-        return self.devices.get_device(name)
+        return self.device_manager.get_device(name)
 
     async def send_command(self, name: str, key: str):
         """Send a command to the device."""
@@ -295,7 +302,9 @@ class Mammotion:
         device = self.get_device_by_name(name)
         if device.preference is ConnectionPreference.WIFI:
             if device.has_cloud():
-                _stream_response = await device.cloud().mqtt.cloud_client.get_stream_subscription(device.cloud().iot_id)
+                _stream_response = await device.cloud().mqtt.cloud_client.mammotion_http.get_stream_subscription(
+                    device.cloud().iot_id
+                )
                 _LOGGER.debug(_stream_response)
                 return _stream_response
 

pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Awaitable, Callable
 import logging
 from typing import Any, cast
 from uuid import UUID
@@ -17,8 +18,7 @@ from pymammotion.bluetooth import BleMessage
 from pymammotion.data.state_manager import StateManager
 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, has_field
 
 DBUS_ERROR_BACKOFF_TIME = 0.25
 
@@ -89,9 +89,17 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         self._operation_lock = asyncio.Lock()
         self._key: str | None = None
         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
         loop = asyncio.get_event_loop()
         loop.create_task(self.process_queue())
 
+    def set_notification_callback(self, func: Callable[[tuple[str, Any | None]], Awaitable[None]]) -> None:
+        self._state_manager.ble_on_notification_callback = func
+
+    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[bytes]]) -> None:
+        self._state_manager.ble_queue_command_callback = func
+
     def update_device(self, device: BLEDevice) -> None:
         """Update the BLE device."""
         self.ble_device = device
@@ -325,7 +333,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
                 _LOGGER.exception("Error parsing message %s", data)
                 data = b""
             finally:
-                self._message.clearNotification()
+                self._message.clear_notification()
 
             _LOGGER.debug("%s: Received notification: %s", self.name, data)
         else:
@@ -338,12 +346,15 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
 
                 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."""