|
| 1 | +"""Trait that represents a full view of the home layout. |
| 2 | +
|
| 3 | +This trait combines information about maps and rooms to provide a comprehensive |
| 4 | +view of the home layout, including room names and their corresponding segment |
| 5 | +on the map. It also makes it straight forward to fetch the map image and data. |
| 6 | +
|
| 7 | +This trait depends on the MapsTrait and RoomsTrait to gather the necessary |
| 8 | +information. It provides properties to access the current map, the list of |
| 9 | +rooms with names, and the map image and data. |
| 10 | +""" |
| 11 | + |
| 12 | +import asyncio |
| 13 | +import logging |
| 14 | +from typing import Self |
| 15 | + |
| 16 | +from roborock.code_mappings import RoborockStateCode |
| 17 | +from roborock.containers import CombinedMapInfo, RoborockBase |
| 18 | +from roborock.devices.cache import Cache |
| 19 | +from roborock.devices.traits.v1 import common |
| 20 | +from roborock.exceptions import RoborockDeviceBusy, RoborockException |
| 21 | +from roborock.roborock_typing import RoborockCommand |
| 22 | + |
| 23 | +from .maps import MapsTrait |
| 24 | +from .rooms import RoomsTrait |
| 25 | +from .status import StatusTrait |
| 26 | + |
| 27 | +_LOGGER = logging.getLogger(__name__) |
| 28 | + |
| 29 | +MAP_SLEEP = 3 |
| 30 | + |
| 31 | + |
| 32 | +class HomeTrait(RoborockBase, common.V1TraitMixin): |
| 33 | + """Trait that represents a full view of the home layout.""" |
| 34 | + |
| 35 | + command = RoborockCommand.GET_MAP_V1 # This is not used |
| 36 | + |
| 37 | + def __init__( |
| 38 | + self, |
| 39 | + status_trait: StatusTrait, |
| 40 | + maps_trait: MapsTrait, |
| 41 | + rooms_trait: RoomsTrait, |
| 42 | + cache: Cache, |
| 43 | + ) -> None: |
| 44 | + """Initialize the HomeTrait. |
| 45 | +
|
| 46 | + We keep track of the MapsTrait and RoomsTrait to provide a comprehensive |
| 47 | + view of the home layout. This also depends on the StatusTrait to determine |
| 48 | + the current map. See comments in MapsTrait for details on that dependency. |
| 49 | +
|
| 50 | + The cache is used to store discovered home data to minimize map switching |
| 51 | + and improve performance. The cache should be persisted by the caller to |
| 52 | + ensure data is retained across restarts. |
| 53 | +
|
| 54 | + After initial discovery, only information for the current map is refreshed |
| 55 | + to keep data up to date without excessive map switching. However, as |
| 56 | + users switch rooms, the current map's data will be updated to ensure |
| 57 | + accuracy. |
| 58 | + """ |
| 59 | + super().__init__() |
| 60 | + self._status_trait = status_trait |
| 61 | + self._maps_trait = maps_trait |
| 62 | + self._rooms_trait = rooms_trait |
| 63 | + self._cache = cache |
| 64 | + self._home_cache: dict[int, CombinedMapInfo] | None = None |
| 65 | + |
| 66 | + async def discover_home(self) -> None: |
| 67 | + """Iterate through all maps to discover rooms and cache them. |
| 68 | +
|
| 69 | + This will be a no-op if the home cache is already populated. |
| 70 | +
|
| 71 | + This cannot be called while the device is cleaning, as that would interrupt the |
| 72 | + cleaning process. This will raise `RoborockDeviceBusy` if the device is |
| 73 | + currently cleaning. |
| 74 | +
|
| 75 | + After discovery, the home cache will be populated and can be accessed via the `home_cache` property. |
| 76 | + """ |
| 77 | + cache_data = await self._cache.get() |
| 78 | + if cache_data.home_cache: |
| 79 | + _LOGGER.debug("Home cache already populated, skipping discovery") |
| 80 | + self._home_cache = cache_data.home_cache |
| 81 | + return |
| 82 | + |
| 83 | + if self._status_trait.state == RoborockStateCode.cleaning: |
| 84 | + raise RoborockDeviceBusy("Cannot perform home discovery while the device is cleaning") |
| 85 | + |
| 86 | + await self._maps_trait.refresh() |
| 87 | + if self._maps_trait.current_map_info is None: |
| 88 | + raise RoborockException("Cannot perform home discovery without current map info") |
| 89 | + |
| 90 | + home_cache = await self._build_home_cache() |
| 91 | + _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_cache)) |
| 92 | + await self._update_home_cache(home_cache) |
| 93 | + |
| 94 | + async def _refresh_map_data(self, map_info) -> CombinedMapInfo: |
| 95 | + """Collect room data for a specific map and return CombinedMapInfo.""" |
| 96 | + await self._rooms_trait.refresh() |
| 97 | + return CombinedMapInfo( |
| 98 | + map_flag=map_info.map_flag, |
| 99 | + name=map_info.name, |
| 100 | + rooms=self._rooms_trait.rooms or [], |
| 101 | + ) |
| 102 | + |
| 103 | + async def _build_home_cache(self) -> dict[int, CombinedMapInfo]: |
| 104 | + """Perform the actual discovery and caching of home data.""" |
| 105 | + home_cache: dict[int, CombinedMapInfo] = {} |
| 106 | + |
| 107 | + # Sort map_info to process the current map last, reducing map switching. |
| 108 | + # False (non-original maps) sorts before True (original map). We ensure |
| 109 | + # we load the original map last. |
| 110 | + sorted_map_infos = sorted( |
| 111 | + self._maps_trait.map_info or [], |
| 112 | + key=lambda mi: mi.map_flag == self._maps_trait.current_map, |
| 113 | + reverse=False, |
| 114 | + ) |
| 115 | + _LOGGER.debug("Building home cache for maps: %s", [mi.map_flag for mi in sorted_map_infos]) |
| 116 | + for map_info in sorted_map_infos: |
| 117 | + # We need to load each map to get its room data |
| 118 | + if len(sorted_map_infos) > 1: |
| 119 | + _LOGGER.debug("Loading map %s", map_info.map_flag) |
| 120 | + await self._maps_trait.set_current_map(map_info.map_flag) |
| 121 | + await asyncio.sleep(MAP_SLEEP) |
| 122 | + |
| 123 | + map_data = await self._refresh_map_data(map_info) |
| 124 | + home_cache[map_info.map_flag] = map_data |
| 125 | + return home_cache |
| 126 | + |
| 127 | + async def refresh(self) -> Self: |
| 128 | + """Refresh current map's underlying map and room data, updating cache as needed. |
| 129 | +
|
| 130 | + This will only refresh the current map's data and will not populate non |
| 131 | + active maps or re-discover the home. It is expected that this will keep |
| 132 | + information up to date for the current map as users switch to that map. |
| 133 | + """ |
| 134 | + if self._home_cache is None: |
| 135 | + raise RoborockException("Cannot refresh home data without home cache, did you call discover_home()?") |
| 136 | + |
| 137 | + # Refresh the list of map names/info |
| 138 | + await self._maps_trait.refresh() |
| 139 | + if (current_map_info := self._maps_trait.current_map_info) is None or ( |
| 140 | + map_flag := self._maps_trait.current_map |
| 141 | + ) is None: |
| 142 | + raise RoborockException("Cannot refresh home data without current map info") |
| 143 | + |
| 144 | + # Refresh the current map's room data |
| 145 | + current_map_data = self._home_cache.get(map_flag) |
| 146 | + if current_map_data: |
| 147 | + map_data = await self._refresh_map_data(current_map_info) |
| 148 | + if map_data != current_map_data: |
| 149 | + await self._update_home_cache({**self._home_cache, map_flag: map_data}) |
| 150 | + |
| 151 | + return self |
| 152 | + |
| 153 | + @property |
| 154 | + def home_cache(self) -> dict[int, CombinedMapInfo] | None: |
| 155 | + """Returns the map information for all cached maps.""" |
| 156 | + return self._home_cache |
| 157 | + |
| 158 | + @property |
| 159 | + def current_map_data(self) -> CombinedMapInfo | None: |
| 160 | + """Returns the map data for the current map.""" |
| 161 | + current_map_flag = self._maps_trait.current_map |
| 162 | + if current_map_flag is None or self._home_cache is None: |
| 163 | + return None |
| 164 | + return self._home_cache.get(current_map_flag) |
| 165 | + |
| 166 | + def _parse_response(self, response: common.V1ResponseData) -> Self: |
| 167 | + """This trait does not parse responses directly.""" |
| 168 | + raise NotImplementedError("HomeTrait does not support direct command responses") |
| 169 | + |
| 170 | + async def _update_home_cache(self, home_cache: dict[int, CombinedMapInfo]) -> None: |
| 171 | + cache_data = await self._cache.get() |
| 172 | + cache_data.home_cache = home_cache |
| 173 | + await self._cache.set(cache_data) |
| 174 | + self._home_cache = home_cache |
0 commit comments