pymammotion 0.5.34__py3-none-any.whl → 0.5.41__py3-none-any.whl

pymammotion/homeassistant/mower_api.py

@@ -0,0 +1,446 @@
+"""Thin api layer between home assistant and pymammotion."""
+
+import asyncio
+from datetime import datetime, timedelta
+from logging import getLogger
+from typing import Any
+
+from pymammotion.aliyun.cloud_gateway import (
+    EXPIRED_CREDENTIAL_EXCEPTIONS,
+    DeviceOfflineException,
+    FailedRequestException,
+    GatewayTimeoutException,
+    NoConnectionException,
+)
+from pymammotion.data.model import GenerateRouteInformation
+from pymammotion.data.model.device import MowingDevice
+from pymammotion.data.model.device_config import OperationSettings, create_path_order
+from pymammotion.mammotion.devices import MammotionMowerDeviceManager
+from pymammotion.mammotion.devices.mammotion import Mammotion
+from pymammotion.proto import RptAct, RptInfoType
+from pymammotion.utility.device_type import DeviceType
+
+logger = getLogger(__name__)
+
+
+class HomeAssistantMowerApi:
+    """API for interacting with Mammotion Mowers for Home Assistant."""
+
+    def __init__(self) -> None:
+        self.update_failures = 0
+        self._mammotion = Mammotion()
+        self._map_lock = asyncio.Lock()
+        self._last_call_times: dict[str, datetime] = {}
+        self._call_intervals = {
+            "check_maps": timedelta(minutes=1),
+            "read_settings": timedelta(minutes=5),
+            "get_errors": timedelta(minutes=1),
+            "get_report_cfg": timedelta(seconds=5),
+            "get_maintenance": timedelta(minutes=30),
+            "device_version_upgrade": timedelta(hours=5),
+        }
+
+    @property
+    def mammotion(self) -> Mammotion:
+        return self._mammotion
+
+    def _should_call_api(self, api_name: str, device: MowingDevice | None = None) -> bool:
+        """Check if API should be called based on time or criteria."""
+        # Time-based check
+        if api_name not in self._last_call_times:
+            return True
+
+        last_call = self._last_call_times[api_name]
+        interval = self._call_intervals.get(api_name, timedelta(seconds=10))
+
+        # Criteria-based checks
+        if api_name == "check_maps" and device:
+            # Call immediately if map data is incomplete
+            if len(device.map.area) == 0 or device.map.missing_hashlist():
+                return True
+
+        return datetime.now() - last_call >= interval
+
+    def _mark_api_called(self, api_name: str) -> None:
+        """Mark an API as called with the current timestamp."""
+        self._last_call_times[api_name] = datetime.now()
+
+    async def update(self, device_name: str) -> MowingDevice:
+        device = self._mammotion.get_device_by_name(device_name)
+
+        if device.has_queued_commands():
+            return device.state
+
+        if self._map_lock.locked():
+            # if maps is not complete kick off the map sync process again
+            if len(device.state.map.missing_hashlist()) > 0:
+                await self._mammotion.start_map_sync(device_name)
+                return device.state
+            # if maps complete
+            else:
+                self._map_lock.release()
+
+        # Check maps periodically
+        if self._should_call_api("check_maps"):
+            await self._map_lock.acquire()
+            await self.mammotion.start_map_sync(device_name)
+            self._mark_api_called("check_maps")
+
+        # Read settings less frequently
+        if self._should_call_api("read_settings"):
+            # await device.async_read_settings()
+            self._mark_api_called("read_settings")
+
+        # Check for errors periodically
+        if self._should_call_api("get_errors"):
+            await self.async_send_command(device_name, "get_error_code")
+            await self.async_send_command(device_name, "get_error_timestamp")
+            self._mark_api_called("get_errors")
+
+        if self._should_call_api("get_report_cfg"):
+            await self.async_send_command(device_name, "get_report_cfg")
+            self._mark_api_called("get_report_cfg")
+
+        if self._should_call_api("get_maintenance"):
+            await self.async_send_command(device_name, "get_maintenance")
+            self._mark_api_called("get_maintenance")
+
+        if self._should_call_api("device_version_upgrade"):
+            self._mark_api_called("device_version_upgrade")
+
+        return device.state
+
+    async def async_send_command(self, device_name: str, command: str, **kwargs: Any) -> bool | None:
+        """Send command."""
+        device = self._mammotion.get_device_by_name(device_name)
+
+        try:
+            # TODO check preference
+            if device.cloud:
+                return await self.async_send_cloud_command(device, command, **kwargs)
+            elif device.ble:
+                return await self.async_send_bluetooth_command(device, command, **kwargs)
+        except (DeviceOfflineException, NoConnectionException) as ex:
+            """Device is offline try bluetooth if we have it."""
+            logger.error(f"Device offline: {ex.iot_id}")
+            if ble := device.ble:
+                # if we don't do this, it will stay connected and no longer update over Wi-Fi
+                ble.set_disconnect_strategy(disconnect=True)
+                await ble.queue_command(command, **kwargs)
+
+                return True
+            raise DeviceOfflineException(ex.args[0], device.iot_id)
+        return False
+
+    async def async_send_cloud_command(
+        self, device: MammotionMowerDeviceManager, key: str, **kwargs: Any
+    ) -> bool | None:
+        """Send command."""
+        if cloud := device.cloud:
+            if not device.state.online:
+                return False
+
+            try:
+                await cloud.command(key, **kwargs)
+                self.update_failures = 0
+                return True
+            except FailedRequestException:
+                self.update_failures += 1
+                if self.update_failures < 5:
+                    await cloud.command(key, **kwargs)
+                    return True
+                return False
+            except EXPIRED_CREDENTIAL_EXCEPTIONS:
+                self.update_failures += 1
+                await self._mammotion.refresh_login(device.mammotion_http.account)
+                # TODO tell home assistant the credentials have changed
+                if self.update_failures < 5:
+                    await cloud.command(key, **kwargs)
+                    return True
+                return False
+            except GatewayTimeoutException as ex:
+                logger.error(f"Gateway timeout exception: {ex.iot_id}")
+                self.update_failures = 0
+                return False
+            except (DeviceOfflineException, NoConnectionException) as ex:
+                """Device is offline try bluetooth if we have it."""
+                logger.error(f"Device offline: {ex.iot_id}")
+        return False
+
+    @staticmethod
+    async def async_send_bluetooth_command(device: MammotionMowerDeviceManager, key: str, **kwargs: Any) -> bool | None:
+        """Send command."""
+        if ble := device.ble:
+            await ble.command(key, **kwargs)
+
+            return True
+        raise DeviceOfflineException("bluetooth command failed", device.iot_id)
+
+    async def set_scheduled_updates(self, device_name: str, enabled: bool) -> None:
+        device = self.mammotion.get_device_by_name(device_name)
+        device.state.enabled = enabled
+        if device.state.enabled:
+            self.update_failures = 0
+            if not device.state.online:
+                device.state.online = True
+            if device.cloud and device.cloud.stopped:
+                await device.cloud.start()
+        else:
+            if device.cloud:
+                await device.cloud.stop()
+                if device.cloud.mqtt.is_connected():
+                    device.cloud.mqtt.disconnect()
+            if device.ble:
+                await device.ble.stop()
+
+    def is_online(self, device_name: str) -> bool:
+        if device := self.mammotion.get_device_by_name(device_name):
+            ble = device.ble
+            return device.state.online or ble is not None and ble.client.is_connected
+        return False
+
+    async def update_firmware(self, device_name: str, version: str) -> None:
+        """Update firmware."""
+        device = self.mammotion.get_device_by_name(device_name)
+        await device.mammotion_http.start_ota_upgrade(device.iot_id, version)
+
+    async def async_start_stop_blades(self, device_name: str, start_stop: bool, blade_height: int = 60) -> None:
+        """Start stop blades."""
+        if DeviceType.is_luba1(device_name):
+            if start_stop:
+                await self.async_send_command(device_name, "set_blade_control", on_off=1)
+            else:
+                await self.async_send_command(device_name, "set_blade_control", on_off=0)
+        elif start_stop:
+            if DeviceType.is_yuka(device_name) or DeviceType.is_yuka_mini(device_name):
+                blade_height = 0
+
+            await self.async_send_command(
+                "operate_on_device",
+                main_ctrl=1,
+                cut_knife_ctrl=1,
+                cut_knife_height=blade_height,
+                max_run_speed=1.2,
+            )
+        else:
+            await self.async_send_command(
+                "operate_on_device",
+                main_ctrl=0,
+                cut_knife_ctrl=0,
+                cut_knife_height=blade_height,
+                max_run_speed=1.2,
+            )
+
+    async def async_set_rain_detection(self, device_name: str, on_off: bool) -> None:
+        """Set rain detection."""
+        await self.async_send_command(device_name, "read_write_device", rw_id=3, context=int(on_off), rw=1)
+
+    async def async_read_rain_detection(self, device_name: str) -> None:
+        """Set rain detection."""
+        await self.async_send_command(device_name, "read_write_device", rw_id=3, context=1, rw=0)
+
+    async def async_set_sidelight(self, device_name: str, on_off: int) -> None:
+        """Set Sidelight."""
+        await self.async_send_command(device_name, "read_and_set_sidelight", is_sidelight=bool(on_off), operate=0)
+        await self.async_read_sidelight()
+
+    async def async_read_sidelight(self, device_name: str) -> None:
+        """Set Sidelight."""
+        await self.async_send_command(device_name, "read_and_set_sidelight", is_sidelight=False, operate=1)
+
+    async def async_set_manual_light(self, device_name: str, manual_ctrl: bool) -> None:
+        """Set manual night light."""
+        await self.async_send_command(device_name, "set_car_manual_light", manual_ctrl=manual_ctrl)
+        await self.async_send_command(device_name, "get_car_light", ids=1126)
+
+    async def async_set_night_light(self, device_name: str, night_light: bool) -> None:
+        """Set night light."""
+        await self.async_send_command(device_name, "set_car_light", on_off=night_light)
+        await self.async_send_command(device_name, "get_car_light", ids=1123)
+
+    async def async_set_traversal_mode(self, device_name: str, context: int) -> None:
+        """Set traversal mode."""
+        await self.async_send_command(device_name, "traverse_mode", context=context)
+
+    async def async_set_turning_mode(self, device_name: str, context: int) -> None:
+        """Set turning mode."""
+        await self.async_send_command(device_name, "turning_mode", context=context)
+
+    async def async_blade_height(self, device_name: str, height: int) -> int:
+        """Set blade height."""
+        await self.async_send_command(device_name, "set_blade_height", height=height)
+        return height
+
+    async def async_set_cutter_speed(self, device_name: str, mode: int) -> None:
+        """Set cutter speed."""
+        await self.async_send_command(device_name, "set_cutter_mode", cutter_mode=mode)
+
+    async def async_set_speed(self, device_name: str, speed: float) -> None:
+        """Set working speed."""
+        await self.async_send_command(device_name, "set_speed", speed=speed)
+
+    async def async_leave_dock(self, device_name: str) -> None:
+        """Leave dock."""
+        await self.send_command_and_update(device_name, "leave_dock")
+
+    async def async_cancel_task(self, device_name: str) -> None:
+        """Cancel task."""
+        await self.send_command_and_update(device_name, "cancel_job")
+
+    async def async_move_forward(self, device_name: str, speed: float) -> None:
+        """Move forward."""
+        device = self.mammotion.get_device_by_name(device_name)
+        await self.async_send_bluetooth_command(device, "move_forward", linear=speed)
+
+    async def async_move_left(self, device_name: str, speed: float) -> None:
+        """Move left."""
+        device = self.mammotion.get_device_by_name(device_name)
+        await self.async_send_bluetooth_command(device, "move_left", angular=speed)
+
+    async def async_move_right(self, device_name: str, speed: float) -> None:
+        """Move right."""
+        device = self.mammotion.get_device_by_name(device_name)
+        await self.async_send_bluetooth_command(device, "move_right", angular=speed)
+
+    async def async_move_back(self, device_name: str, speed: float) -> None:
+        """Move back."""
+        device = self.mammotion.get_device_by_name(device_name)
+        await self.async_send_bluetooth_command(device, "move_back", linear=speed)
+
+    async def async_rtk_dock_location(self, device_name: str) -> None:
+        """RTK and dock location."""
+        await self.async_send_command(device_name, "read_write_device", rw_id=5, rw=1, context=1)
+
+    async def async_get_area_list(self, device_name: str, iot_id: str) -> None:
+        """Mowing area List."""
+        await self.async_send_command(device_name, "get_area_name_list", device_id=iot_id)
+
+    async def async_relocate_charging_station(self, device_name: str) -> None:
+        """Reset charging station."""
+        await self.async_send_command(device_name, "delete_charge_point")
+        # fetch charging location?
+        """
+        nav {
+          todev_get_commondata {
+            pver: 1
+            subCmd: 2
+            action: 6
+            type: 5
+            totalFrame: 1
+            currentFrame: 1
+          }
+        }
+        """
+
+    async def send_command_and_update(self, device_name: str, command_str: str, **kwargs: Any) -> None:
+        """Send command and update."""
+        await self.async_send_command(device_name, command_str, **kwargs)
+        await self.async_request_iot_sync(device_name)
+
+    async def async_request_iot_sync(self, device_name: str, stop: bool = False) -> None:
+        """Sync specific info from device."""
+        await self.async_send_command(
+            device_name,
+            "request_iot_sys",
+            rpt_act=RptAct.RPT_STOP if stop else RptAct.RPT_START,
+            rpt_info_type=[
+                RptInfoType.RIT_DEV_STA,
+                RptInfoType.RIT_DEV_LOCAL,
+                RptInfoType.RIT_WORK,
+                RptInfoType.RIT_MAINTAIN,
+                RptInfoType.RIT_BASESTATION_INFO,
+                RptInfoType.RIT_VIO,
+            ],
+            timeout=10000,
+            period=3000,
+            no_change_period=4000,
+            count=0,
+        )
+
+    def generate_route_information(
+        self, device_name: str, operation_settings: OperationSettings
+    ) -> GenerateRouteInformation:
+        """Generate route information."""
+        device = self.mammotion.get_device_by_name(device_name)
+        if device.state.report_data.dev:
+            dev = device.state.report_data.dev
+            if dev.collector_status.collector_installation_status == 0:
+                operation_settings.is_dump = False
+
+        if DeviceType.is_yuka(device_name):
+            operation_settings.blade_height = -10
+
+        route_information = GenerateRouteInformation(
+            one_hashs=list(operation_settings.areas),
+            rain_tactics=operation_settings.rain_tactics,
+            speed=operation_settings.speed,
+            ultra_wave=operation_settings.ultra_wave,  # touch no touch etc
+            toward=operation_settings.toward,  # is just angle (route angle)
+            toward_included_angle=operation_settings.toward_included_angle  # demond_angle
+            if operation_settings.channel_mode == 1
+            else 0,  # crossing angle relative to grid
+            toward_mode=operation_settings.toward_mode,
+            blade_height=operation_settings.blade_height,
+            channel_mode=operation_settings.channel_mode,  # single, double, segment or none (route mode)
+            channel_width=operation_settings.channel_width,  # path space
+            job_mode=operation_settings.job_mode,  # taskMode grid or border first
+            edge_mode=operation_settings.mowing_laps,  # perimeter/mowing laps
+            path_order=create_path_order(operation_settings, device_name),
+            obstacle_laps=operation_settings.obstacle_laps,
+        )
+
+        if DeviceType.is_luba1(device_name):
+            route_information.toward_mode = 0
+            route_information.toward_included_angle = 0
+        return route_information
+
+    async def async_plan_route(self, device_name: str, operation_settings: OperationSettings) -> bool | None:
+        """Plan mow."""
+        route_information = self.generate_route_information(device_name, operation_settings)
+
+        # not sure if this is artificial limit
+        # if (
+        #     DeviceType.is_mini_or_x_series(device_name)
+        #     and route_information.toward_mode == 0
+        # ):
+        #     route_information.toward = 0
+
+        return await self.async_send_command(
+            device_name, "generate_route_information", generate_route_information=route_information
+        )
+
+    async def async_modify_plan_route(self, device_name: str, operation_settings: OperationSettings) -> bool | None:
+        """Modify plan mow."""
+        device = self.mammotion.get_device_by_name(device_name)
+
+        if work := device.state.work:
+            operation_settings.areas = work.zone_hashs
+            operation_settings.toward = work.toward
+            operation_settings.toward_mode = work.toward_mode
+            operation_settings.toward_included_angle = work.toward_included_angle
+            operation_settings.mowing_laps = work.edge_mode
+            operation_settings.job_mode = work.job_mode
+            operation_settings.job_id = work.job_id
+            operation_settings.job_version = work.job_ver
+
+        route_information = self.generate_route_information(device_name, operation_settings)
+        if route_information.toward_mode == 0:
+            route_information.toward = 0
+
+        return await self.async_send_command(
+            device_name, "modify_route_information", generate_route_information=route_information
+        )
+
+    async def start_task(self, device_name: str, plan_id: str) -> None:
+        """Start task."""
+        await self.async_send_command(device_name, "single_schedule", plan_id=plan_id)
+
+    async def clear_update_failures(self, device_name: str) -> None:
+        """Clear update failures."""
+        self.update_failures = 0
+        device = self.mammotion.get_device_by_name(device_name)
+        if not device.state.online:
+            device.state.online = True
+        if cloud := device.cloud:
+            if cloud.stopped:
+                await cloud.start()

pymammotion/homeassistant/rtk_api.py

@@ -0,0 +1,54 @@
+import json
+
+from pymammotion.aliyun.cloud_gateway import DeviceOfflineException, GatewayTimeoutException, SetupException
+from pymammotion.data.model.device import RTKDevice
+from pymammotion.http.model.http import CheckDeviceVersion
+from pymammotion.mammotion.devices.mammotion import Mammotion
+
+
+class HomeAssistantRTKApi:
+    def __init__(self) -> None:
+        self._mammotion = Mammotion()
+
+    @property
+    def mammotion(self) -> Mammotion:
+        return self._mammotion
+
+    async def update(self, device_name: str) -> RTKDevice:
+        """Update RTK data."""
+        device = self.mammotion.get_rtk_device_by_name(device_name)
+        try:
+            response = await device.cloud_client.get_device_properties(device.iot_id)
+            if response.code == 200:
+                data = response.data
+                if ota_progress := data.otaProgress:
+                    device.update_check = CheckDeviceVersion.from_dict(ota_progress.value)
+                if network_info := data.networkInfo:
+                    network = json.loads(network_info.value)
+                    device.state.wifi_rssi = network["wifi_rssi"]
+                    device.state.wifi_sta_mac = network["wifi_sta_mac"]
+                    device.state.bt_mac = network["bt_mac"]
+                if coordinate := data.coordinate:
+                    coord_val = json.loads(coordinate.value)
+                    if device.state.lat == 0:
+                        device.state.lat = coord_val["lat"]
+                    if device.state.lon == 0:
+                        device.state.lon = coord_val["lon"]
+                if device_version := data.deviceVersion:
+                    device.state.device_version = device_version.value
+            device.state.online = True
+
+            ota_info = await device.cloud_client.mammotion_http.get_device_ota_firmware([device.state.iot_id])
+            if check_versions := ota_info.data:
+                for check_version in check_versions:
+                    if check_version.device_id == device.state.iot_id:
+                        device.state.update_check = check_version
+            return device.state
+        except SetupException:
+            """Cloud IOT Gateway is not setup."""
+            return device.state
+        except DeviceOfflineException:
+            device.state.online = False
+        except GatewayTimeoutException:
+            """Gateway is timing out again."""
+        return device.state

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, account: str | None = None, password: str | None = None) -> None:
-        self.expires_in = 0
+        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 = 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