feat: add shared rooms endpoint

roborock/devices/traits/v1/__init__.py

@@ -199,7 +199,7 @@ def __init__(
         self.device_features = DeviceFeaturesTrait(product, self._device_cache)
         self.status = StatusTrait(self.device_features, region=self._region)
         self.consumables = ConsumableTrait()
-        self.rooms = RoomsTrait(home_data, web_api)
+        self.rooms = RoomsTrait(home_data, device_uid, web_api)
         self.maps = MapsTrait(self.status)
         self.map_content = MapContentTrait(map_parser_config)
         self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, self._device_cache)

roborock/devices/traits/v1/rooms.py

@@ -2,6 +2,7 @@
 
 import logging
 from dataclasses import dataclass
+from functools import cached_property
 
 from roborock.data import HomeData, HomeDataRoom, NamedRoomMapping, RoborockBase
 from roborock.devices.traits.v1 import common
@@ -84,12 +85,22 @@ class RoomsTrait(Rooms, common.V1TraitMixin):
     command = RoborockCommand.GET_ROOM_MAPPING
     converter = RoomsConverter()
 
-    def __init__(self, home_data: HomeData, web_api: UserWebApiClient) -> None:
+    def __init__(self, home_data: HomeData, device_uid: str, web_api: UserWebApiClient) -> None:
         """Initialize the RoomsTrait."""
         super().__init__()
         self._home_data = home_data
+        self._device_uid = device_uid
         self._web_api = web_api
         self._discovered_iot_ids: set[str] = set()
+        self._shared_room_names: dict[str, str] = {}
+
+    @cached_property
+    def _is_shared(self) -> bool:
+        return any(d.duid == self._device_uid for d in self._home_data.received_devices)
+
+    @property
+    def _room_name_map(self) -> dict[str, str]:
+        return {**self._home_data.rooms_name_map, **self._shared_room_names}
 
     async def refresh(self) -> None:
         """Refresh room mappings and backfill unknown room names from the web API."""
@@ -104,12 +115,15 @@ async def refresh(self) -> None:
 
         segment_map = RoomsConverter.extract_segment_map(response)
         # Track all iot ids seen before. Refresh the room list when new ids are found.
-        new_iot_ids = set(segment_map.values()) - set(self._home_data.rooms_map.keys())
+        new_iot_ids = set(segment_map.values()) - set(self._room_name_map.keys())
         if new_iot_ids - self._discovered_iot_ids:
             _LOGGER.debug("Refreshing room list to discover new room names")
             if updated_rooms := await self._refresh_rooms():
                 _LOGGER.debug("Updating rooms: %s", list(updated_rooms))
-                self._home_data.rooms = updated_rooms
+                if self._is_shared:
+                    self._shared_room_names = {room.iot_id: room.name for room in updated_rooms}
+                else:
+                    self._home_data.rooms = updated_rooms
             self._discovered_iot_ids.update(new_iot_ids)
         try:
             rooms = self.converter.convert(response)
@@ -121,12 +135,14 @@ async def refresh(self) -> None:
                 inner_error=err,
             ) from err
 
-        rooms = rooms.with_room_names(self._home_data.rooms_name_map)
+        rooms = rooms.with_room_names(self._room_name_map)
         common.merge_trait_values(self, rooms)
 
     async def _refresh_rooms(self) -> list[HomeDataRoom]:
         """Fetch the latest rooms from the web API."""
         try:
+            if self._is_shared:
+                return await self._web_api.get_shared_device_rooms(self._device_uid)
             return await self._web_api.get_rooms()
         except Exception:
             _LOGGER.debug("Failed to fetch rooms from web API", exc_info=True)

roborock/web_api.py

@@ -557,6 +557,33 @@ async def get_rooms(self, user_data: UserData, home_id: int | None = None) -> li
         else:
             raise RoborockException("home_response result was an unexpected type")
 
+    async def get_shared_device_rooms(self, user_data: UserData, device_id: str) -> list[HomeDataRoom]:
+        """Fetch room names for a shared (received) device."""
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        path = f"/user/deviceshare/query/{device_id}/rooms"
+        room_request = PreparedRequest(
+            rriot.r.a,
+            self.session,
+            {"Authorization": _get_hawk_authentication(rriot, path)},
+        )
+        room_response = await room_request.request("get", path)
+        if not room_response.get("success"):
+            raise RoborockException(room_response)
+        rooms = room_response.get("result")
+        if isinstance(rooms, list):
+            output_list = []
+            for room in rooms:
+                normalized_room = room
+                if isinstance(room, dict) and "id" not in room and "roomId" in room:
+                    normalized_room = {**room, "id": room["roomId"]}
+                output_list.append(HomeDataRoom.from_dict(normalized_room))
+            return output_list
+        raise RoborockException("get_shared_device_rooms result was an unexpected type")
+
     async def get_scenes(self, user_data: UserData, device_id: str) -> list[HomeDataScene]:
         rriot = user_data.rriot
         if rriot is None:
@@ -754,6 +781,10 @@ async def get_rooms(self) -> list[HomeDataRoom]:
         """Fetch rooms using the API client."""
         return await self._web_api.get_rooms(self._user_data)
 
+    async def get_shared_device_rooms(self, device_id: str) -> list[HomeDataRoom]:
+        """Fetch shared-device rooms using the API client."""
+        return await self._web_api.get_shared_device_rooms(self._user_data, device_id)
+
     async def execute_routine(self, scene_id: int) -> None:
         """Execute a specific routine (scene) by its ID."""
         await self._web_api.execute_scene(self._user_data, scene_id)

tests/devices/traits/v1/test_rooms.py

@@ -207,3 +207,34 @@ async def test_refresh_unknown_room_names_failure_falls_back_to_room_segment_id(
     assert rooms_trait.rooms[0] == NamedRoomMapping(segment_id=16, iot_id="9999401")
     assert rooms_trait.rooms[0].name == "Room 16"
     web_api_client.get_rooms.assert_called_once()
+
+
+async def test_refresh_shared_room_names_use_shared_device_rooms_without_mutating_home_data(
+    rooms_trait: RoomsTrait,
+    web_api_client: AsyncMock,
+    mock_rpc_channel: AsyncMock,
+) -> None:
+    """Test shared devices resolve room names via the shared-device room list."""
+    original_rooms = list(rooms_trait._home_data.rooms or ())
+    try:
+        # Mark the device as shared by adding it to received_devices
+        device = next(d for d in rooms_trait._home_data.devices if d.duid == rooms_trait._device_uid)
+        rooms_trait._home_data.received_devices = [device]
+        rooms_trait._home_data.devices = []
+
+        web_api_client.get_shared_device_rooms.return_value = [
+            HomeDataRoom(id=9999999, name="Office"),
+        ]
+        room_mapping_data = [[16, "2362048"], [17, "9999999"]]
+        mock_rpc_channel.send_command.side_effect = [room_mapping_data]
+
+        await rooms_trait.refresh()
+
+        assert rooms_trait.rooms
+        assert rooms_trait.rooms[0] == NamedRoomMapping(segment_id=16, iot_id="2362048", raw_name="Example room 1")
+        assert rooms_trait.rooms[1] == NamedRoomMapping(segment_id=17, iot_id="9999999", raw_name="Office")
+        assert rooms_trait._home_data.rooms == original_rooms
+        web_api_client.get_shared_device_rooms.assert_called_once_with(rooms_trait._device_uid)
+        web_api_client.get_rooms.assert_not_called()
+    finally:
+        rooms_trait._home_data.rooms = original_rooms

tests/test_web_api.py

@@ -5,7 +5,7 @@
 import pytest
 from aioresponses.compat import normalize_url
 
-from roborock import HomeData, HomeDataScene, UserData
+from roborock import HomeData, HomeDataRoom, HomeDataScene, UserData
 from roborock.exceptions import RoborockAccountDoesNotExist
 from roborock.web_api import IotLoginInfo, RoborockApiClient
 from tests.mock_data import HOME_DATA_RAW, USER_DATA
@@ -374,3 +374,43 @@ async def test_get_schedules(mock_rest) -> None:
     assert schedule.cron == "03 13 15 12 ?"
     assert schedule.repeated is False
     assert schedule.enabled is True
+
+
+@pytest.mark.parametrize(
+    "result_payload",
+    [
+        # roomId field (deviceshare endpoint convention)
+        [
+            {"roomId": "2362048", "name": "Living Room"},
+            {"roomId": 2362044, "name": "Kitchen"},
+        ],
+        # id field (matches /user/homes/{id}/rooms — defensive in case the API normalizes)
+        [
+            {"id": 2362048, "name": "Living Room"},
+            {"id": 2362044, "name": "Kitchen"},
+        ],
+    ],
+)
+async def test_get_shared_device_rooms(mock_rest, result_payload) -> None:
+    """Test that shared-device rooms are fetched from the deviceshare query path."""
+    api = RoborockApiClient(username="test_user@gmail.com")
+    ud = await api.pass_login("password")
+
+    mock_rest.get(
+        "https://api-us.roborock.com/user/deviceshare/query/device-id-q7/rooms",
+        status=200,
+        payload={
+            "api": None,
+            "code": 200,
+            "result": result_payload,
+            "status": "ok",
+            "success": True,
+        },
+    )
+
+    rooms = await api.get_shared_device_rooms(ud, "device-id-q7")
+
+    assert rooms == [
+        HomeDataRoom(id=2362048, name="Living Room"),
+        HomeDataRoom(id=2362044, name="Kitchen"),
+    ]