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

pymammotion/mammotion/devices/rtk_ble.py

@@ -0,0 +1,89 @@
+"""RTK device with Bluetooth LE connectivity."""
+
+import asyncio
+import logging
+from typing import Any
+from uuid import UUID
+
+from bleak import BleakGATTCharacteristic, BLEDevice
+from bleak_retry_connector import BleakClientWithServiceCache
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.bluetooth import BleMessage
+from pymammotion.data.model.device import RTKDevice
+from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
+from pymammotion.mammotion.devices.rtk_device import MammotionRTKDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionRTKBLEDevice(MammotionRTKDevice):
+    """RTK device with BLE connectivity - simpler than mowers, no map sync."""
+
+    def __init__(
+        self, cloud_device: Device, rtk_state: RTKDevice, device: BLEDevice, interface: int = 0, **kwargs: Any
+    ) -> None:
+        """Initialize MammotionRTKBLEDevice."""
+        super().__init__(cloud_device, rtk_state)
+        self.command_sent_time = 0
+        self._disconnect_strategy = True
+        self._interface = f"hci{interface}"
+        self.ble_device = device
+        self._client: BleakClientWithServiceCache | None = None
+        self._read_char: BleakGATTCharacteristic | int | str | UUID = 0
+        self._write_char: BleakGATTCharacteristic | int | str | UUID = 0
+        self._disconnect_timer: asyncio.TimerHandle | None = None
+        self._message: BleMessage | None = None
+        self._commands: MammotionCommand = MammotionCommand(device.name or "", 1)
+        self.command_queue = asyncio.Queue()
+        self._expected_disconnect = False
+        self._connect_lock = asyncio.Lock()
+        self._operation_lock = asyncio.Lock()
+        self._key: str | None = None
+        loop = asyncio.get_event_loop()
+        loop.create_task(self.process_queue())
+
+    def __del__(self) -> None:
+        """Cleanup."""
+        if self._disconnect_timer:
+            self._disconnect_timer.cancel()
+
+    @property
+    def client(self) -> BleakClientWithServiceCache:
+        """Return the BLE client."""
+        return self._client
+
+    def set_disconnect_strategy(self, *, disconnect: bool) -> None:
+        """Set disconnect strategy."""
+        self._disconnect_strategy = disconnect
+
+    async def process_queue(self) -> None:
+        """Process queued commands - simplified for RTK."""
+        while True:
+            key, kwargs = await self.command_queue.get()
+            try:
+                _LOGGER.debug("Processing RTK BLE command: %s", key)
+                command_bytes = getattr(self._commands, key)(**kwargs)
+                # Send command via BLE (implementation depends on BLE infrastructure)
+                # For now, this is a placeholder
+                _LOGGER.debug("RTK BLE command sent: %s", key)
+            except Exception as ex:
+                _LOGGER.exception("Error processing RTK BLE command: %s", ex)
+            finally:
+                self.command_queue.task_done()
+
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
+        """Queue a command to the RTK device."""
+        await self.command_queue.put((key, kwargs))
+
+    async def command(self, key: str, **kwargs):
+        """Send a command to the RTK device."""
+        return await self.queue_command(key, **kwargs)
+
+    async def _ble_sync(self) -> None:
+        """RTK devices don't use BLE sync in the same way as mowers."""
+
+    async def stop(self) -> None:
+        """Stop everything ready for destroying."""
+        if self._client is not None and self._client.is_connected:
+            await self._client.disconnect()

pymammotion/mammotion/devices/rtk_cloud.py

@@ -0,0 +1,113 @@
+"""RTK device with cloud MQTT connectivity."""
+
+import asyncio
+from collections.abc import Awaitable, Callable
+import logging
+from typing import Any
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model.device import RTKDevice
+from pymammotion.data.mqtt.properties import ThingPropertiesMessage
+from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
+from pymammotion.mammotion.devices.mammotion_cloud import MammotionCloud
+from pymammotion.mammotion.devices.rtk_device import MammotionRTKDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionRTKCloudDevice(MammotionRTKDevice):
+    """RTK device with cloud connectivity - simpler than mowers, no map sync."""
+
+    def __init__(self, mqtt: MammotionCloud, cloud_device: Device, rtk_state: RTKDevice) -> None:
+        """Initialize MammotionRTKCloudDevice."""
+        super().__init__(cloud_device, rtk_state)
+        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.iot_id
+        self.device = cloud_device
+        self._commands: MammotionCommand = MammotionCommand(
+            cloud_device.device_name,
+            int(mqtt.cloud_client.mammotion_http.response.data.userInformation.userAccount),
+        )
+        # Subscribe to MQTT events for this device
+        self._mqtt.mqtt_properties_event.add_subscribers(self._parse_message_properties_for_device)
+        self._mqtt.mqtt_status_event.add_subscribers(self._parse_message_status_for_device)
+        self._mqtt.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)
+
+    def __del__(self) -> None:
+        """Cleanup subscriptions."""
+        if hasattr(self, "_mqtt"):
+            self._mqtt.on_ready_event.remove_subscribers(self.on_ready)
+            self._mqtt.on_disconnected_event.remove_subscribers(self.on_disconnect)
+            self._mqtt.on_connected_event.remove_subscribers(self.on_connect)
+            self._mqtt.mqtt_properties_event.remove_subscribers(self._parse_message_properties_for_device)
+            self._mqtt.mqtt_status_event.remove_subscribers(self._parse_message_status_for_device)
+
+    @property
+    def command_sent_time(self) -> float:
+        return self._mqtt.command_sent_time
+
+    @property
+    def mqtt(self):
+        return self._mqtt
+
+    async def on_ready(self) -> None:
+        """Callback for when MQTT is subscribed to events."""
+        if self.stopped:
+            return
+        if self.on_ready_callback:
+            await self.on_ready_callback()
+
+    async def on_disconnect(self) -> None:
+        """Callback for when MQTT disconnects."""
+        self._mqtt.disconnect()
+
+    async def on_connect(self) -> None:
+        """Callback for when MQTT connects."""
+
+    async def stop(self) -> None:
+        """Stop all tasks and disconnect."""
+        self.stopped = True
+
+    async def start(self) -> None:
+        """Start the device connection."""
+        self.stopped = False
+        if not self.mqtt.is_connected():
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self.mqtt.connect_async)
+
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
+        """Queue a command to the RTK device."""
+        _LOGGER.debug("Queueing command: %s", key)
+        future = asyncio.Future()
+        command_bytes = getattr(self._commands, key)(**kwargs)
+        await self._mqtt.command_queue.put((self.iot_id, key, command_bytes, future))
+        try:
+            return await future
+        except asyncio.CancelledError:
+            """Try again once."""
+            future = asyncio.Future()
+            await self._mqtt.command_queue.put((self.iot_id, key, command_bytes, future))
+
+    async def _parse_message_properties_for_device(self, event: ThingPropertiesMessage) -> None:
+        """Parse property messages for this RTK device."""
+        if event.params.iotId != self.iot_id:
+            return
+        # RTK devices have simpler properties - update as needed
+        _LOGGER.debug("RTK properties update: %s", event)
+
+    async def _parse_message_status_for_device(self, status: ThingStatusMessage) -> None:
+        """Parse status messages for this RTK device."""
+        if status.params.iotId != self.iot_id:
+            return
+        # Update online status
+        self._rtk_device.online = True
+        _LOGGER.debug("RTK status update: %s", status)
+
+    async def _ble_sync(self) -> None:
+        """RTK devices don't use BLE sync in the same way as mowers."""

pymammotion/mammotion/devices/rtk_device.py

@@ -0,0 +1,50 @@
+"""RTK device class without map synchronization callbacks."""
+
+import asyncio
+import logging
+from typing import Any
+
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model.device import RTKDevice
+from pymammotion.data.model.raw_data import RawMowerData
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MammotionRTKDevice:
+    """RTK device without map synchronization - simpler than mowers."""
+
+    def __init__(self, cloud_device: Device, rtk_state: RTKDevice) -> None:
+        """Initialize MammotionRTKDevice."""
+        self.loop = asyncio.get_event_loop()
+        self._rtk_device = rtk_state
+        self._raw_data = dict()
+        self._raw_mower_data: RawMowerData = RawMowerData()
+        self._notify_future: asyncio.Future[bytes] | None = None
+        self._cloud_device = cloud_device
+
+    @property
+    def rtk(self) -> RTKDevice:
+        """Get the RTK device state."""
+        return self._rtk_device
+
+    @property
+    def raw_data(self) -> dict[str, Any]:
+        """Get the raw data of the device."""
+        return self._raw_data
+
+    async def command(self, key: str, **kwargs: Any) -> bytes | None:
+        """Send a command to the device."""
+        return await self.queue_command(key, **kwargs)
+
+    async def queue_command(self, key: str, **kwargs: Any) -> bytes | None:
+        """Queue commands to RTK device - to be implemented by connection-specific subclasses."""
+        raise NotImplementedError("Subclasses must implement queue_command")
+
+    async def _ble_sync(self) -> None:
+        """Send ble sync command - to be implemented by connection-specific subclasses."""
+        raise NotImplementedError("Subclasses must implement _ble_sync")
+
+    def stop(self) -> None:
+        """Stop everything ready for destroying - to be implemented by connection-specific subclasses."""
+        raise NotImplementedError("Subclasses must implement stop")

pymammotion/mammotion/devices/rtk_manager.py

@@ -0,0 +1,122 @@
+"""RTK Device Manager - manages RTK devices with cloud and BLE connectivity."""
+
+from typing import override
+
+from bleak import BLEDevice
+
+from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model.device import RTKDevice
+from pymammotion.data.model.enums import ConnectionPreference
+from pymammotion.mammotion.devices.mammotion_cloud import MammotionCloud
+from pymammotion.mammotion.devices.managers.managers import AbstractDeviceManager
+from pymammotion.mammotion.devices.rtk_ble import MammotionRTKBLEDevice
+from pymammotion.mammotion.devices.rtk_cloud import MammotionRTKCloudDevice
+
+
+class MammotionRTKDeviceManager(AbstractDeviceManager):
+    """Manages an RTK device with both cloud and BLE connectivity options."""
+
+    def __init__(
+        self,
+        name: str,
+        iot_id: str,
+        cloud_client: CloudIOTGateway,
+        cloud_device: Device,
+        ble_device: BLEDevice | None = None,
+        mqtt: MammotionCloud | None = None,
+        preference: ConnectionPreference = ConnectionPreference.WIFI,
+    ) -> None:
+        """Initialize RTK device manager."""
+        super().__init__(name, iot_id, cloud_client, cloud_device, preference)
+        self._ble_device: MammotionRTKBLEDevice | None = None
+        self._cloud_device: MammotionRTKCloudDevice | None = 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
+
+        # Initialize RTK state
+        self._rtk_state = RTKDevice(
+            name=name,
+            iot_id=iot_id,
+            product_key=cloud_device.product_key,
+        )
+
+        # Add connection types if provided
+        if ble_device:
+            self.add_ble(ble_device)
+        if mqtt:
+            self.add_cloud(mqtt)
+
+    @property
+    def state(self) -> RTKDevice:
+        """Return the RTK device state."""
+        return self._rtk_state
+
+    @state.setter
+    def state(self, value: RTKDevice) -> None:
+        """Set the RTK device state."""
+        self._rtk_state = value
+
+    @property
+    def ble(self) -> MammotionRTKBLEDevice | None:
+        """Return BLE device interface."""
+        return self._ble_device
+
+    @property
+    def cloud(self) -> MammotionRTKCloudDevice | None:
+        """Return cloud device interface."""
+        return self._cloud_device
+
+    def has_queued_commands(self) -> bool:
+        """Check if there are queued commands."""
+        if self.cloud and self.preference == ConnectionPreference.WIFI:
+            return not self.cloud.mqtt.command_queue.empty()
+        elif self.ble:
+            return not self.ble.command_queue.empty()
+        return False
+
+    def add_ble(self, ble_device: BLEDevice) -> MammotionRTKBLEDevice:
+        """Add BLE device."""
+        self._ble_device = MammotionRTKBLEDevice(
+            cloud_device=self._device, rtk_state=self._rtk_state, device=ble_device
+        )
+        return self._ble_device
+
+    @override
+    def add_cloud(self, mqtt: MammotionCloud) -> MammotionRTKCloudDevice:
+        """Add cloud device."""
+        self._cloud_device = MammotionRTKCloudDevice(mqtt, cloud_device=self._device, rtk_state=self._rtk_state)
+        return self._cloud_device
+
+    def replace_cloud(self, cloud_device: MammotionRTKCloudDevice) -> None:
+        """Replace cloud device."""
+        self._cloud_device = cloud_device
+
+    def remove_cloud(self) -> None:
+        """Remove cloud device."""
+        self._cloud_device = None
+
+    def replace_ble(self, ble_device: MammotionRTKBLEDevice) -> None:
+        """Replace BLE device."""
+        self._ble_device = ble_device
+
+    def remove_ble(self) -> None:
+        """Remove BLE device."""
+        self._ble_device = None
+
+    def replace_mqtt(self, mqtt: MammotionCloud) -> None:
+        """Replace MQTT connection."""
+        device = self._cloud_device.device
+        self._cloud_device = MammotionRTKCloudDevice(mqtt, cloud_device=device, rtk_state=self._rtk_state)
+
+    def has_cloud(self) -> bool:
+        """Check if cloud connection is available."""
+        return self._cloud_device is not None
+
+    def has_ble(self) -> bool:
+        """Check if BLE connection is available."""
+        return self._ble_device is not None

pymammotion/mqtt/__init__.py

@@ -1,5 +1,6 @@
 """Package for MammotionMQTT."""
 
+from .aliyun_mqtt import AliyunMQTT
 from .mammotion_mqtt import MammotionMQTT
 
-__all__ = ["MammotionMQTT"]
+__all__ = ["AliyunMQTT", "MammotionMQTT"]

pymammotion/mqtt/aliyun_mqtt.py

@@ -0,0 +1,232 @@
+"""MammotionMQTT."""
+
+import asyncio
+import base64
+from collections.abc import Awaitable, Callable
+import hashlib
+import hmac
+import json
+import logging
+from logging import getLogger
+
+import betterproto2
+from paho.mqtt.client import MQTTMessage
+
+from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
+from pymammotion.data.mqtt.event import ThingEventMessage
+from pymammotion.data.mqtt.properties import ThingPropertiesMessage
+from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.mqtt.linkkit.linkkit import LinkKit
+from pymammotion.proto import LubaMsg
+
+logger = getLogger(__name__)
+
+
+class AliyunMQTT:
+    """MQTT client for pymammotion."""
+
+    def __init__(
+        self,
+        region_id: str,
+        product_key: str,
+        device_name: str,
+        device_secret: str,
+        iot_token: str,
+        cloud_client: CloudIOTGateway,
+        client_id: str | None = None,
+    ) -> None:
+        """Create instance of MammotionMQTT."""
+        super().__init__()
+        self._cloud_client = cloud_client
+        self.is_connected = False
+        self.is_ready = False
+        self.on_connected: Callable[[], Awaitable[None]] | None = None
+        self.on_ready: Callable[[], Awaitable[None]] | None = None
+        self.on_error: Callable[[str], Awaitable[None]] | None = None
+        self.on_disconnected: Callable[[], Awaitable[None]] | None = None
+        self.on_message: Callable[[str, str, str], Awaitable[None]] | None = None
+
+        self._product_key = product_key
+        self._device_name = device_name
+        self._device_secret = device_secret
+        self._iot_token = iot_token
+        self._mqtt_username = f"{device_name}&{product_key}"
+        # linkkit provides the correct MQTT service for all of this and uses paho under the hood
+        if client_id is None:
+            client_id = f"python-{device_name}"
+        self._mqtt_client_id = f"{client_id}|securemode=2,signmethod=hmacsha1|"
+        sign_content = f"clientId{client_id}deviceName{device_name}productKey{product_key}"
+        self._mqtt_password = hmac.new(
+            device_secret.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha1
+        ).hexdigest()
+
+        self._client_id = client_id
+        self.loop = asyncio.get_running_loop()
+
+        self._linkkit_client = LinkKit(
+            region_id,
+            product_key,
+            device_name,
+            device_secret,
+            auth_type="",
+            client_id=client_id,
+            password=self._mqtt_password,
+            username=self._mqtt_username,
+        )
+
+        self._linkkit_client.enable_logger(level=logging.ERROR)
+        self._linkkit_client.on_connect = self._thing_on_connect
+        self._linkkit_client.on_disconnect = self._on_disconnect
+        self._linkkit_client.on_thing_enable = self._thing_on_thing_enable
+        self._linkkit_client.on_topic_message = self._thing_on_topic_message
+        self._mqtt_host = f"{self._product_key}.iot-as-mqtt.{region_id}.aliyuncs.com"
+
+    def connect_async(self) -> None:
+        """Connect async to MQTT Server."""
+        logger.info("Connecting...")
+        if self._linkkit_client.check_state() is LinkKit.LinkKitState.INITIALIZED:
+            self._linkkit_client.thing_setup()
+        self._linkkit_client.connect_async()
+
+    def disconnect(self) -> None:
+        """Disconnect from MQTT Server."""
+        logger.info("Disconnecting...")
+
+        self._linkkit_client.disconnect()
+
+    def _thing_on_thing_enable(self, user_data) -> None:
+        """Is called when Thing is enabled."""
+        logger.debug("on_thing_enable")
+        self.is_connected = True
+        # logger.debug('subscribe_topic, topic:%s' % echo_topic)
+        # self._linkkit_client.subscribe_topic(echo_topic, 0)
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply"
+        )
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/event/property/post_reply"
+        )
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/wifi/status/notify"
+        )
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/wifi/connect/event/notify"
+        )
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/_thing/event/notify"
+        )
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/events")
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/status")
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/properties")
+        self._linkkit_client.subscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/model/down_raw"
+        )
+
+        self._linkkit_client.publish_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/up/account/bind",
+            json.dumps(
+                {
+                    "id": "msgid1",
+                    "version": "1.0",
+                    "request": {"clientId": self._mqtt_username},
+                    "params": {"iotToken": self._iot_token},
+                }
+            ),
+        )
+
+        if self.on_ready:
+            self.is_ready = True
+            future = asyncio.run_coroutine_threadsafe(self.on_ready(), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
+
+    def unsubscribe(self) -> None:
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply"
+        )
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/event/property/post_reply"
+        )
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/wifi/status/notify"
+        )
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/wifi/connect/event/notify"
+        )
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/_thing/event/notify"
+        )
+        self._linkkit_client.unsubscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/events")
+        self._linkkit_client.unsubscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/status")
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/properties"
+        )
+        self._linkkit_client.unsubscribe_topic(
+            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/model/down_raw"
+        )
+
+    def _thing_on_topic_message(self, topic: str, payload: str, qos, user_data) -> None:
+        """Is called when thing topic comes in."""
+        logger.debug(
+            "on_topic_message, receive message, topic:%s, payload:%s, qos:%d",
+            topic,
+            payload,
+            qos,
+        )
+        json_payload = json.loads(payload)
+        iot_id = json_payload.get("params", {}).get("iotId", "")
+        if iot_id != "" and self.on_message is not None:
+            future = asyncio.run_coroutine_threadsafe(self.on_message(topic, payload, iot_id), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
+
+    def _thing_on_connect(self, session_flag, rc, user_data) -> None:
+        """Handle connection event and execute callback if set."""
+        self.is_connected = True
+        if self.on_connected is not None:
+            future = asyncio.run_coroutine_threadsafe(self.on_connected(), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
+
+        logger.debug("on_connect, session_flag:%d, rc:%d", session_flag, rc)
+
+    def _on_disconnect(self, _client, _userdata) -> None:
+        """Is called on disconnect."""
+        if self._linkkit_client.check_state() is LinkKit.LinkKitState.DISCONNECTED:
+            logger.info("Disconnected")
+            self.is_connected = False
+            self.is_ready = False
+            if self.on_disconnected:
+                future = asyncio.run_coroutine_threadsafe(self.on_disconnected(), self.loop)
+                asyncio.wrap_future(future, loop=self.loop)
+
+    def _on_message(self, _client, _userdata, message: MQTTMessage) -> None:
+        """Is called when message is received."""
+        logger.debug("Message on topic %s", message.topic)
+
+        payload = json.loads(message.payload)
+        if message.topic.endswith("/app/down/thing/events"):
+            event = ThingEventMessage(**payload)
+            params = event.params
+            if params.identifier == "device_protobuf_msg_event":
+                content = LubaMsg().parse(base64.b64decode(params.value.content))
+
+                logger.info("Unhandled protobuf event: %s", betterproto2.which_one_of(content, "LubaSubMsg"))
+            elif params.identifier == "device_warning_event":
+                logger.debug("identifier event: %s", params.identifier)
+            else:
+                logger.info("Unhandled event: %s", params.identifier)
+        elif message.topic.endswith("/app/down/thing/status"):
+            # the tell if a device has come back online
+            # lastStatus
+            # 1 online?
+            # 3 offline?
+            status = ThingStatusMessage(**payload)
+            logger.debug(status.params.status.value)
+        elif message.topic.endswith("/app/down/thing/properties"):
+            properties = ThingPropertiesMessage(**payload)
+            logger.debug("properties: %s", properties)
+        else:
+            logger.debug("Unhandled topic: %s", message.topic)
+            logger.debug(payload)
+
+    async def send_cloud_command(self, iot_id: str, command: bytes) -> str:
+        """Return internal cloud client."""
+        return await self._cloud_client.send_cloud_command(iot_id, command)