pymammotion 0.4.0a2__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/mammotion/devices/mammotion_mower_cloud.py

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

pymammotion/mammotion/devices/managers/managers.py

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

pymammotion/mammotion/devices/mower_device.py

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

pymammotion/mammotion/devices/mower_manager.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from bleak import BLEDevice
+
+from pymammotion import CloudIOTGateway
+from pymammotion.aliyun.model.dev_by_account_response import Device
+from pymammotion.data.model.device import MowingDevice
+from pymammotion.data.model.enums import ConnectionPreference
+from pymammotion.data.mower_state_manager import MowerStateManager
+from pymammotion.mammotion.devices.mammotion_cloud import MammotionCloud
+from pymammotion.mammotion.devices.mammotion_mower_ble import MammotionMowerBLEDevice
+from pymammotion.mammotion.devices.mammotion_mower_cloud import MammotionMowerCloudDevice
+from pymammotion.mammotion.devices.managers.managers import AbstractDeviceManager
+
+
+class MammotionMowerDeviceManager(AbstractDeviceManager):
+    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.BLUETOOTH,
+    ) -> None:
+        super().__init__(name, iot_id, cloud_client, cloud_device, preference)
+        self._ble_device: MammotionMowerBLEDevice | None = None
+        self._cloud_device: MammotionMowerCloudDevice | None = None
+
+        self._state_manager = MowerStateManager(MowingDevice())
+        self._state_manager.get_device().name = name
+        self.add_ble(ble_device) if ble_device else None
+        self.add_cloud(mqtt) if mqtt else None
+
+    @property
+    def state_manager(self) -> MowerStateManager:
+        """Return the state manager."""
+        return self._state_manager
+
+    @property
+    def state(self) -> MowingDevice:
+        """Return the state of the device."""
+        return self._state_manager.get_device()
+
+    @state.setter
+    def state(self, value: MowingDevice) -> None:
+        self._state_manager.set_device(value)
+
+    @property
+    def ble(self) -> MammotionMowerBLEDevice | None:
+        return self._ble_device
+
+    @property
+    def cloud(self) -> MammotionMowerCloudDevice | None:
+        return self._cloud_device
+
+    def has_queued_commands(self) -> bool:
+        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) -> MammotionMowerBLEDevice:
+        self._ble_device = MammotionMowerBLEDevice(
+            state_manager=self._state_manager, cloud_device=self._device, device=ble_device
+        )
+        return self._ble_device
+
+    def add_cloud(self, mqtt: MammotionCloud) -> MammotionMowerCloudDevice:
+        self._cloud_device = MammotionMowerCloudDevice(
+            mqtt, cloud_device=self._device, state_manager=self._state_manager
+        )
+        return self._cloud_device
+
+    def replace_cloud(self, cloud_device: MammotionMowerCloudDevice) -> None:
+        self._cloud_device = cloud_device
+
+    def remove_cloud(self) -> None:
+        self._state_manager.cloud_get_commondata_ack_callback = None
+        self._state_manager.cloud_get_hashlist_ack_callback = None
+        self._state_manager.cloud_get_plan_callback = None
+        self._state_manager.cloud_on_notification_callback = None
+        self._state_manager.cloud_gethash_ack_callback = None
+        self._cloud_device = None
+
+    def replace_ble(self, ble_device: MammotionMowerBLEDevice) -> None:
+        self._ble_device = ble_device
+
+    def remove_ble(self) -> None:
+        self._state_manager.ble_get_commondata_ack_callback = None
+        self._state_manager.ble_get_hashlist_ack_callback = None
+        self._state_manager.ble_get_plan_callback = None
+        self._state_manager.ble_on_notification_callback = None
+        self._state_manager.ble_gethash_ack_callback = None
+        self._ble_device = None
+
+    def replace_mqtt(self, mqtt: MammotionCloud) -> None:
+        device = self._cloud_device.device
+        self._cloud_device = MammotionMowerCloudDevice(mqtt, cloud_device=device, state_manager=self._state_manager)
+
+    def has_cloud(self) -> bool:
+        return self._cloud_device is not None
+
+    def has_ble(self) -> bool:
+        return self._ble_device is not None

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.iot_id != 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.iot_id != 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")