adjustments to area names, dynamics line fetching for ble only right now

Author: mikey0000

custom_components/mammotion/coordinator.py

@@ -28,7 +28,7 @@
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.debounce import Debouncer
-from homeassistant.helpers.event import async_call_later
+from homeassistant.helpers.event import async_call_later, async_track_time_interval
 from homeassistant.helpers.storage import Store
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from mashumaro.exceptions import InvalidFieldValue
@@ -50,7 +50,7 @@
     RTKBaseStationDevice,
 )
 from pymammotion.data.model.device_config import OperationSettings, create_path_order
-from pymammotion.data.model.hash_list import AreaHashNameList, Plan, SvgMessage
+from pymammotion.data.model.hash_list import Plan, SvgMessage
 from pymammotion.data.model.pool_state import PoolPlan, SpinoToggle
 from pymammotion.data.model.report_info import Maintain, NetUsedType
 from pymammotion.data.mqtt.event import DeviceNotificationEventParams, ThingEventMessage
@@ -101,6 +101,7 @@
 MAINTENANCE_INTERVAL = timedelta(minutes=60)
 DEFAULT_INTERVAL = timedelta(minutes=30)
 REPORT_INTERVAL = timedelta(minutes=5)
+DYNAMICS_LINE_INTERVAL = timedelta(seconds=10)
 DEVICE_VERSION_INTERVAL = timedelta(weeks=1)
 MAP_INTERVAL = timedelta(minutes=60)
 RTK_INTERVAL = timedelta(hours=5)
@@ -1457,24 +1458,22 @@ def get_area_entity_name(self, area_hash: int) -> str | None:
         if area_hash == 0:
             return None
 
-        name = None
         _mower_data = cast(MowingDevice, self.data)
-        if area_data := _mower_data.map.area.get(area_hash):
-            area_frame = area_data.data[0] if len(area_data.data) > 0 else None
-            if area_frame is not None:
-                area_name: AreaHashNameList | None = next(
-                    (
-                        area
-                        for area in _mower_data.map.area_name
-                        if area.hash == area_frame.hash
-                    ),
-                    None,
-                )
-                name = area_name.name if area_name is not None else None
-        else:
+        if area_hash not in _mower_data.map.area:
             return "path"
 
-        return name if name else f"area {area_hash}"
+        # Prefer the user's HA-level entity name over the device-assigned name.
+        entity_reg = er.async_get(self.hass)
+        unique_id = f"{self.unique_name}_{area_hash}"
+        entity_id = entity_reg.async_get_entity_id("switch", DOMAIN, unique_id)
+        if entity_id and (entry := entity_reg.async_get(entity_id)) and entry.name:
+            return entry.name
+
+        for area in _mower_data.map.computed_areas:
+            if area.hash == area_hash:
+                return area.name
+
+        return f"area {area_hash}"
 
     @property
     def map_sync_status(self) -> str:
@@ -1978,6 +1977,8 @@ async def _async_setup(self) -> None:
 class MammotionMapUpdateCoordinator(MammotionBaseUpdateCoordinator[MowerInfo]):
     """Class to manage fetching mammotion data."""
 
+    _dynamics_line_cancel: CALLBACK_TYPE | None = None
+
     def __init__(
         self,
         hass: HomeAssistant,
@@ -2046,13 +2047,72 @@ async def _async_update_data(self) -> MowerInfo:
         assert _d is not None
         return _d.mower_state
 
+    def _device_supports_dynamics_line(self) -> bool:
+        """Return True if this device supports the dynamics-line mow-progress stream."""
+        device = self.manager.get_device_by_name(self.device_name)
+        firmware = device.device_firmwares.main_controller if device else None
+        return DeviceType.value_of_str(self.device_name).is_support_dynamics_line(
+            firmware
+        )
+
+    def _ble_is_connected(self) -> bool:
+        """Return True if BLE transport exists and is currently connected."""
+        if handle := self.manager.mower(self.device_name):
+            if ble := handle.get_transport(TransportType.BLE):
+                return ble.is_connected
+        return False
+
+    def _stop_dynamics_line_poll(self) -> None:
+        if self._dynamics_line_cancel is not None:
+            self._dynamics_line_cancel()
+            self._dynamics_line_cancel = None
+
+    async def _on_sys_status_changed_dynamics(self, sys_status: int) -> None:
+        """Start the dynamics-line poll when mowing over BLE; stop it otherwise."""
+        if (
+            sys_status in MOWING_ACTIVE_MODES
+            and self._device_supports_dynamics_line()
+            and self._ble_is_connected()
+        ):
+            if self._dynamics_line_cancel is None:
+                self._dynamics_line_cancel = async_track_time_interval(
+                    self.hass,
+                    self._fetch_dynamics_line,
+                    DYNAMICS_LINE_INTERVAL,
+                )
+        else:
+            self._stop_dynamics_line_poll()
+
+    async def _fetch_dynamics_line(self, _now: datetime.datetime) -> None:
+        """Fetch the dynamics line; self-cancels if BLE has disconnected."""
+        if not self._ble_is_connected():
+            self._stop_dynamics_line_poll()
+            return
+        try:
+            await self.manager.get_dynamics_line(self.device_name)
+            device = self.manager.get_device_by_name(self.device_name)
+            if device is not None:
+                self.async_set_updated_data(device.mower_state)
+        except (
+            DeviceOfflineException,
+            NoTransportAvailableError,
+            GatewayTimeoutException,
+        ):
+            pass
+
     async def _async_setup(self) -> None:
         """Set up coordinator with initial call to get map data."""
         await super()._async_setup()
         device = self.manager.get_device_by_name(self.device_name)
         if device is None:
             return
 
+        if handle := self.manager.mower(self.device_name):
+            handle.watch_field(
+                lambda s: s.raw.report_data.dev.sys_status,
+                self._on_sys_status_changed_dynamics,
+            )
+
         if not device.enabled or not device.online:
             return
         try:
@@ -2417,6 +2477,14 @@ async def _async_setup(self) -> None:
                         context=0,
                         rw=0,
                     )
+            # Fetch pool geometry once at startup.  Responses arrive as unsolicited
+            # APP_DOWNLINK_CMD frames and are reassembled by PoolStateReducer.
+            for fetch in (self.async_fetch_pool_map, self.async_fetch_pool_line):
+                with contextlib.suppress(
+                    GatewayTimeoutException,
+                    NoTransportAvailableError,
+                ):
+                    await fetch()
         except DeviceOfflineException:
             self.device.online = False