diff --git a/custom_components/vector/coordinator.py b/custom_components/vector/coordinator.py index e5af0d9..5e3f04d 100644 --- a/custom_components/vector/coordinator.py +++ b/custom_components/vector/coordinator.py @@ -30,6 +30,7 @@ _MAX_EVENT_READS = 10 _STREAM_READ_TIMEOUT_SECONDS = 120.0 _STREAM_RECONNECT_DELAY_SECONDS = 3.0 +_TELEMETRY_POLL_INTERVAL_SECONDS = 300 _SIGHTING_INTERVAL_SECONDS = 60 _INITIAL_REFRESH_TIMEOUT_SECONDS = 20.0 _INITIAL_REFRESH_RETRY_ATTEMPTS = 5 @@ -111,6 +112,8 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None: self._activity_tracker: Any | None = None self._telemetry_filter: Any | None = None self._event_listener_task: asyncio.Task[None] | None = None + self._telemetry_poll_task: asyncio.Task[None] | None = None + self._initial_refresh_complete = False self._face_seen_last: dict[str, float] = {} self._cube_seen_last: dict[int, float] = {} self._camera_stream_task: asyncio.Task[None] | None = None @@ -128,9 +131,10 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None: self._auth_backoff_lock = asyncio.Lock() async def _async_update_data(self) -> None: - """Do initial one-shot load at setup.""" + """Refresh battery and lifetime stats, and load settings at startup.""" try: client, messaging = await self._async_get_client() + previous_robot_state = self._latest_robot_state ( battery_volts, battery_level, @@ -139,28 +143,34 @@ async def _async_update_data(self) -> None: client, messaging, ) - firmware_version = await self._async_read_firmware_version( - client, messaging - ) lifetime_stats = await self._async_read_lifetime_stats() - master_volume = await self._async_read_master_volume() - eye_color = await self._async_read_eye_color() - activity = self.current_activity + if not self._initial_refresh_complete: + await self._async_load_initial_settings(client, messaging) except Exception as err: - raise UpdateFailed(f"Failed to update Vector activity: {err}") from err + raise UpdateFailed( + "Failed to refresh Vector battery and lifetime stats" + ) from err self.battery_percent = _battery_percentage_from_wirepod_curve(battery_volts) self.battery_volts = battery_volts self.battery_level = battery_level - self.is_charging = is_charging - self.firmware_version = firmware_version + if self._latest_robot_state is previous_robot_state: + self.is_charging = is_charging if lifetime_stats is not None: self.days_alive = lifetime_stats.days_alive self.reacted_to_trigger_word = lifetime_stats.reacted_to_trigger_word self.utility_features_used = lifetime_stats.utility_features_used self.seconds_petted = lifetime_stats.seconds_petted self.distance_moved_cm = lifetime_stats.distance_moved_cm - self.master_volume = master_volume + self._auth_backoff_delay_seconds = _AUTH_BACKOFF_BASE_DELAY_SECONDS + + async def _async_load_initial_settings(self, client: Any, messaging: Any) -> None: + """Read firmware and settings during the first successful refresh.""" + self.firmware_version = await self._async_read_firmware_version( + client, messaging + ) + self.master_volume = await self._async_read_master_volume() + eye_color = await self._async_read_eye_color() if eye_color is not None: preset = str(getattr(eye_color, "preset", "")).strip().lower() self.eye_color_preset = preset or None @@ -170,18 +180,14 @@ async def _async_update_data(self) -> None: custom_hue = getattr(eye_color, "custom_hue", None) custom_saturation = getattr(eye_color, "custom_saturation", None) self.eye_color_custom_hue = ( - float(custom_hue) - if isinstance(custom_hue, (int, float)) - else None + float(custom_hue) if isinstance(custom_hue, (int, float)) else None ) self.eye_color_custom_saturation = ( float(custom_saturation) if isinstance(custom_saturation, (int, float)) else None ) - self.current_activity = activity - self._auth_backoff_delay_seconds = _AUTH_BACKOFF_BASE_DELAY_SECONDS - return None + self._initial_refresh_complete = True async def async_validate_connection(self) -> None: """Validate robot connectivity/auth for config entry setup.""" @@ -252,9 +258,30 @@ async def async_start_runtime(self) -> None: ) await self.async_start_event_listener() + if self._telemetry_poll_task is None: + self._telemetry_poll_task = self.hass.async_create_background_task( + self._async_poll_telemetry(), + name=f"vector_telemetry_poll_{self.entry.entry_id}", + ) + + async def _async_poll_telemetry(self) -> None: + """Refresh telemetry independently of event stream notifications.""" + while True: + await asyncio.sleep(_TELEMETRY_POLL_INTERVAL_SECONDS) + if not self.entry.pref_disable_polling: + await self.async_refresh() async def async_shutdown(self) -> None: """Disconnect active client resources.""" + await super().async_shutdown() + if self._telemetry_poll_task is not None: + self._telemetry_poll_task.cancel() + try: + await self._telemetry_poll_task + except asyncio.CancelledError: + pass + self._telemetry_poll_task = None + if self._event_listener_task is not None: self._event_listener_task.cancel() try: diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py index c4bb788..ea767bf 100644 --- a/tests/test_coordinator.py +++ b/tests/test_coordinator.py @@ -35,6 +35,110 @@ def _state(**kwargs): return SimpleNamespace(**defaults) +def test_telemetry_refresh_keeps_newer_push_charging_state() -> None: + """Keep charging changes received during a poll.""" + + async def run() -> None: + with patch("homeassistant.helpers.frame.report_usage"): + vector = VectorCoordinator(Mock(), SimpleNamespace(entry_id="vector-entry")) + battery_started = asyncio.Event() + finish_battery = asyncio.Event() + vector._async_get_client = AsyncMock(return_value=(object(), object())) + + async def read_battery(*_args): + battery_started.set() + await finish_battery.wait() + return 4.10, "nominal", False + + first_stats = SimpleNamespace( + days_alive=1, + reacted_to_trigger_word=2, + utility_features_used=3, + seconds_petted=4, + distance_moved_cm=5, + ) + vector._async_read_lifetime_stats = AsyncMock( + side_effect=[ + first_stats, + SimpleNamespace(**(vars(first_stats) | {"days_alive": 2})), + ] + ) + vector._async_read_firmware_version = AsyncMock(return_value="firmware") + vector._async_read_master_volume = AsyncMock(return_value="medium") + vector._async_read_eye_color = AsyncMock(return_value=None) + vector._async_read_battery_state = AsyncMock(return_value=(3.70, "low", False)) + await vector._async_update_data() + assert vector.battery_volts == 3.70 + assert vector.days_alive == 1 + + vector._async_read_battery_state.side_effect = read_battery + refresh = asyncio.create_task(vector._async_update_data()) + await battery_started.wait() + vector._latest_robot_state = object() + vector.is_charging = True + finish_battery.set() + await refresh + + assert vector.battery_percent == 100 + assert vector.is_charging is True + assert vector.days_alive == 2 + vector._async_read_firmware_version.assert_awaited_once() + vector._async_read_master_volume.assert_awaited_once() + vector._async_read_eye_color.assert_awaited_once() + + asyncio.run(run()) + + +def test_telemetry_poll_runs_independently_and_stops_on_shutdown(monkeypatch) -> None: + """Polling runs alongside push updates and is cancelled on unload.""" + + async def run() -> None: + hass = Mock() + hass.async_create_background_task.side_effect = asyncio.create_task + entry = SimpleNamespace(entry_id="vector-entry", pref_disable_polling=False) + with patch("homeassistant.helpers.frame.report_usage"): + vector = VectorCoordinator(hass, entry) + vector.battery_percent = 50 + vector.firmware_version = "firmware" + vector.async_refresh = AsyncMock() + vector.async_start_event_listener = AsyncMock() + tick = asyncio.Semaphore(0) + timer_started = asyncio.Event() + + async def sleep(delay): + assert delay == 300 + timer_started.set() + await tick.acquire() + + monkeypatch.setattr( + coordinator, + "asyncio", + SimpleNamespace( + sleep=sleep, + wait_for=asyncio.wait_for, + CancelledError=asyncio.CancelledError, + ), + ) + await vector.async_start_runtime() + task = vector._telemetry_poll_task + await timer_started.wait() + vector.async_set_updated_data(None) + tick.release() + await asyncio.sleep(0) + assert vector.async_refresh.await_count == 2 + + entry.pref_disable_polling = True + tick.release() + await asyncio.sleep(0) + assert vector.async_refresh.await_count == 2 + + await vector.async_shutdown() + assert task.cancelled() + assert vector._telemetry_poll_task is None + + asyncio.run(run()) + + def test_event_stream_publishes_and_throttles_sightings() -> None: """Publish eligible face and cube observations from one shared stream.""" light_cube_type = 2