matterbridge-roborock-vacuum-plugin 1.1.0-rc18 → 1.1.1-rc01

package/src/roborockCommunication/Zmodel/messageResult.ts

@@ -12,10 +12,10 @@ export interface CloudMessageResult {
   in_fresh_state: number;
   lab_status: number;
   water_box_status: number;
-  back_type: number;
-  wash_phase: number;
-  wash_ready: number;
-  wash_status: number;
+  back_type?: number;
+  wash_phase?: number;
+  wash_ready?: number;
+  wash_status?: number;
   fan_power: number;
   dnd_enabled: number;
   map_status: number;
@@ -25,43 +25,44 @@ export interface CloudMessageResult {
   distance_off: number;
   water_box_carriage_status: number;
   mop_forbidden_enable: number;
-  camera_status: number;
-  is_exploring: number;
+  camera_status?: number;
+  is_exploring?: number;
   adbumper_status: number[];
-  water_shortage_status: number;
+  water_shortage_status?: number;
   dock_type: number;
   dust_collection_status: number;
   auto_dust_collection: number;
-  avoid_count: number;
-  mop_mode: number;
+  avoid_count?: number;
+  mop_mode?: number;
   debug_mode: number;
-  in_warmup: number;
-  collision_avoid_status: number;
+  in_warmup?: number;
+  collision_avoid_status?: number;
   switch_map_mode: number;
   dock_error_status: number;
   charge_status: number;
-  unsave_map_reason: number;
-  unsave_map_flag: number;
-  dry_status: number;
-  rdt: number;
-  clean_percent: number;
-  extra_time: number;
-  rss: number;
-  dss: number;
-  common_status: number;
-  last_clean_t: number;
-  replenish_mode: number;
-  repeat: number;
-  kct: number;
-  subdivision_sets: number;
-  cleaning_info: {
+  unsave_map_reason?: number;
+  unsave_map_flag?: number;
+  dry_status?: number;
+  rdt?: number;
+  clean_percent?: number;
+  extra_time?: number;
+  rss?: number;
+  dss?: number;
+  common_status?: number;
+  last_clean_t?: number;
+  replenish_mode?: number;
+  repeat?: number;
+  kct?: number;
+  subdivision_sets?: number;
+  cleaning_info?: {
     target_segment_id: number;
     segment_id: number;
     fan_power: number;
     water_box_status: number;
     mop_mode: number;
   };
-  exit_dock: number;
+  exit_dock?: number;
+  seq_type?: number;
 }
 
 export enum CarpetCleanMode {

package/src/roborockCommunication/Zmodel/userData.ts

@@ -1,5 +1,6 @@
 export interface UserData {
-  uid: string;
+  uid: string | number;
+  tokentype: string;
   token: string;
   rruid: string;
   region: string;

package/src/runtimes/handleCloudMessage.ts

@@ -0,0 +1,134 @@
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { CloudMessageModel } from '../model/CloudMessageModel.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { RoborockMatterbridgePlatform } from '../platform.js';
+import { AdditionalPropCode, DeviceStatusNotify, Protocol } from '../roborockCommunication/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { RvcCleanMode, RvcOperationalState, RvcRunMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { triggerDssError } from './handleLocalMessage.js';
+import { DpsPayload } from '../roborockCommunication/broadcast/model/dps.js';
+import { getRoomMapFromDevice, isStatusUpdate } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { CloudMessageResult } from '../roborockCommunication/Zmodel/messageResult.js';
+import { NotifyMessageTypes } from '../notifyMessageTypes.js';
+import { getCurrentCleanModeFunc } from '../share/runtimeHelper.js';
+import { getSupportedAreas } from '../initialData/getSupportedAreas.js';
+import { PlatformRunner } from '../platformRunner.js';
+import { RoborockVacuumCleaner } from '../rvc.js';
+
+export async function handleCloudMessage(data: CloudMessageModel, platform: RoborockMatterbridgePlatform, runner: PlatformRunner, duid: string): Promise<void> {
+  const messageTypes = Object.keys(data.dps).map(Number);
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error3: Robot with DUID ${duid} not found`);
+    return;
+  }
+
+  // Known: 122, 121, 102,
+  // Unknown: 128, 139
+  messageTypes.forEach(async (messageType) => {
+    switch (messageType) {
+      case Protocol.status_update: {
+        const status = Number(data.dps[messageType]);
+        const matterState = state_to_matter_state(status);
+
+        if (matterState) {
+          robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+        }
+
+        const operationalStateId = state_to_matter_operational_status(status);
+        if (operationalStateId) {
+          const dssHasError = hasDockingStationError(robot.dockStationStatus);
+          if (!(dssHasError && triggerDssError(robot, platform))) {
+            robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+          }
+        }
+        break;
+      }
+      case Protocol.rpc_response: {
+        const response = data.dps[messageType] as DpsPayload;
+        // ignore network info
+        if (!isStatusUpdate(response.result)) {
+          platform.log.debug('Ignore message:', debugStringify(data));
+          return;
+        }
+
+        let roboStatus: CloudMessageResult | undefined;
+        if (Array.isArray(response.result) && response.result.length > 0) {
+          roboStatus = response.result[0] as CloudMessageResult;
+        }
+
+        if (roboStatus) {
+          const message = { ...roboStatus } as DeviceStatusNotify;
+          platform.log.debug('rpc_response:', debugStringify(message));
+          await runner.updateFromMQTTMessage(NotifyMessageTypes.LocalMessage, message, duid, true);
+        }
+        break;
+      }
+      case Protocol.suction_power:
+      case Protocol.water_box_mode: {
+        await platform.roborockService?.getCleanModeData(duid).then((cleanModeData) => {
+          if (cleanModeData) {
+            const currentCleanMode = getCurrentCleanModeFunc(
+              robot.device.data.model,
+              platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false,
+            )({
+              suctionPower: cleanModeData.suctionPower,
+              waterFlow: cleanModeData.waterFlow,
+              distance_off: cleanModeData.distance_off,
+              mopRoute: cleanModeData.mopRoute,
+            });
+
+            platform.log.debug(`Clean mode data: ${debugStringify(cleanModeData)}`);
+            platform.log.debug(`Current clean mode: ${currentCleanMode}`);
+            if (currentCleanMode) {
+              robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+            }
+          }
+        });
+        break; // Do nothing, handled in local message
+      }
+      case Protocol.additional_props: {
+        platform.log.notice(`Received additional properties for robot ${duid}: ${debugStringify(data)}`);
+        const propCode = data.dps[Protocol.additional_props] as number;
+        platform.log.debug(`DPS for additional properties: ${propCode}, AdditionalPropCode: ${AdditionalPropCode[propCode]}`);
+        if (propCode === AdditionalPropCode.map_change) {
+          await handleMapChange(robot, platform, duid);
+        }
+        break;
+      }
+      case Protocol.back_type: {
+        // TODO: check if this is needed
+        break;
+      }
+      default: {
+        platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
+        break;
+      }
+    }
+  });
+}
+
+export async function handleMapChange(robot: RoborockVacuumCleaner, platform: RoborockMatterbridgePlatform, duid: string): Promise<void> {
+  const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap) ?? false;
+  if (!enableMultipleMap) return;
+
+  await getRoomMapFromDevice(robot.device, platform).then((roomMap) => {
+    const { supportedAreas, supportedMaps, roomIndexMap } = getSupportedAreas(robot.device.rooms, roomMap, enableMultipleMap, platform.log);
+
+    platform.log.debug(`handleMapChange - supportedAreas: ${debugStringify(supportedAreas)}`);
+    platform.log.debug(`handleMapChange - supportedMaps: ${debugStringify(supportedMaps)}`);
+    platform.log.debug(`handleMapChange - roomIndexMap: `, roomIndexMap);
+
+    platform.roborockService?.setSupportedAreas(duid, supportedAreas);
+    platform.roborockService?.setSelectedAreas(duid, []);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'supportedAreas', supportedAreas, platform.log);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+
+    if (enableMultipleMap) {
+      platform.roborockService?.setSupportedAreaIndexMap(duid, roomIndexMap);
+      robot.updateAttribute(ServiceArea.Cluster.id, 'supportedMaps', supportedMaps, platform.log);
+    }
+  });
+}

package/src/runtimes/handleHomeDataMessage.ts

@@ -0,0 +1,67 @@
+import { PowerSource, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { getVacuumProperty } from '../helper.js';
+import { RoborockMatterbridgePlatform } from '../platform.js';
+import { Device, Home } from '../roborockCommunication/index.js';
+import { debugStringify } from 'matterbridge/logger';
+import { getBatteryState, getBatteryStatus } from '../initialData/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { triggerDssError } from './handleLocalMessage.js';
+
+export async function updateFromHomeData(homeData: Home, platform: RoborockMatterbridgePlatform): Promise<void> {
+  if (platform.robots.size === 0) return;
+  const devices = homeData.devices.filter((d: Device) => platform.robots.has(d.duid));
+
+  for (const device of devices) {
+    const robot = platform.robots.get(device.duid);
+    if (robot === undefined) {
+      platform.log.error(`Error5: Robot with DUID ${device.duid} not found`);
+      continue;
+    }
+
+    const deviceData = robot.device.data;
+    if (!device || deviceData === undefined) {
+      platform.log.error('Device not found in home data');
+      return;
+    }
+
+    device.schema = homeData.products.find((prd) => prd.id === device.productId || prd.model === device.data.model)?.schema ?? [];
+    platform.log.debug('updateFromHomeData-homeData:', debugStringify(homeData));
+    platform.log.debug('updateFromHomeData-device:', debugStringify(device));
+    platform.log.debug('updateFromHomeData-schema:' + debugStringify(device.schema));
+    platform.log.debug('updateFromHomeData-battery:' + debugStringify(device.deviceStatus));
+
+    const batteryLevel = getVacuumProperty(device, 'battery');
+    if (batteryLevel) {
+      robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel ? batteryLevel * 2 : 200, platform.log);
+      robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+    }
+
+    const state = getVacuumProperty(device, 'state');
+    const matterState = state_to_matter_state(state);
+    if (!state || !matterState) {
+      return;
+    }
+    platform.log.debug(`updateFromHomeData-RvcRunMode code: ${state} name: ${OperationStatusCode[state]}, matterState: ${RvcRunMode.ModeTag[matterState]}`);
+
+    if (matterState) {
+      robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+    }
+    if (batteryLevel) {
+      robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(state, batteryLevel), platform.log);
+    }
+
+    const operationalStateId = state_to_matter_operational_status(state);
+
+    if (operationalStateId) {
+      const dssHasError = hasDockingStationError(robot.dockStationStatus);
+      platform.log.debug(`dssHasError: ${dssHasError}, dockStationStatus: ${debugStringify(robot.dockStationStatus ?? {})}`);
+      if (!(dssHasError && triggerDssError(robot, platform))) {
+        platform.log.debug(`updateFromHomeData-OperationalState: ${RvcOperationalState.OperationalState[operationalStateId]}`);
+        robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+      }
+    }
+  }
+}

package/src/runtimes/handleLocalMessage.ts

@@ -0,0 +1,209 @@
+import { PowerSource, RvcCleanMode, RvcOperationalState, RvcRunMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { CloudMessageResult } from '../roborockCommunication/Zmodel/messageResult.js';
+import { state_to_matter_state } from '../share/function.js';
+import { RoborockMatterbridgePlatform } from '../platform.js';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { getRoomMap } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { getBatteryState, getBatteryStatus } from '../initialData/index.js';
+import { getCurrentCleanModeFunc } from '../share/runtimeHelper.js';
+import { RoborockVacuumCleaner } from '../rvc.js';
+import { hasDockingStationError, parseDockingStationStatus } from '../model/DockingStationStatus.js';
+
+export async function handleLocalMessage(data: CloudMessageResult, platform: RoborockMatterbridgePlatform, duid = ''): Promise<void> {
+  const robot = platform.robots.get(duid);
+
+  if (!robot) {
+    platform.log.error(`Robot with DUID ${duid} not found.`);
+    return;
+  }
+
+  const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+  const roomIndexMap = platform.roborockService?.getSupportedAreasIndexMap(duid);
+  const roomMap = await getRoomMap(duid, platform);
+  platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+  platform.log.debug(`Current mapped areas: ${currentMappedAreas ? debugStringify(currentMappedAreas) : 'undefined'}`);
+  platform.log.debug(
+    `RoomIndexMap:
+    `,
+    roomIndexMap,
+  );
+
+  const deviceData = robot.device.data;
+  const state = state_to_matter_state(data.state);
+  if (state) {
+    robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
+  }
+
+  if (data.state === OperationStatusCode.Idle) {
+    const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
+    robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
+  }
+
+  if (state === RvcRunMode.ModeTag.Cleaning && !data.cleaning_info) {
+    platform.log.debug('No cleaning_info, setting currentArea to null');
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+    robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+  } else {
+    const isMultipleMapEnable = platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap;
+    if (isMultipleMapEnable) {
+      await mapRoomsToAreasFeatureOn(platform, duid, data);
+    } else {
+      await mapRoomsToAreasFeatureOff(platform, duid, data);
+    }
+  }
+
+  if (data.battery) {
+    const batteryLevel = data.battery as number;
+    robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
+    robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(data.state, data.battery), platform.log);
+    robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+  }
+
+  const currentCleanModeSetting = {
+    suctionPower: data.cleaning_info?.fan_power ?? data.fan_power,
+    waterFlow: data.cleaning_info?.water_box_status ?? data.water_box_mode,
+    distance_off: data.distance_off,
+    mopRoute: data.cleaning_info?.mop_mode ?? data.mop_mode,
+    segment_id: data.cleaning_info?.segment_id,
+    target_segment_id: data.cleaning_info?.target_segment_id,
+  };
+
+  platform.log.debug(`data: ${debugStringify(data)}`);
+  platform.log.notice(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
+
+  if (currentCleanModeSetting.mopRoute && currentCleanModeSetting.suctionPower && currentCleanModeSetting.waterFlow) {
+    const currentCleanMode = getCurrentCleanModeFunc(deviceData.model, platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)(currentCleanModeSetting);
+    platform.log.debug(`Current clean mode: ${currentCleanMode}`);
+
+    if (currentCleanMode) {
+      robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+    }
+  }
+
+  processAdditionalProps(robot, data, duid, platform);
+}
+
+export function triggerDssError(robot: RoborockVacuumCleaner, platform: RoborockMatterbridgePlatform): boolean {
+  const currentOperationState = robot.getAttribute(RvcOperationalState.Cluster.id, 'operationalState') as RvcOperationalState.OperationalState;
+  if (currentOperationState === RvcOperationalState.OperationalState.Error) {
+    return true;
+  }
+
+  if (currentOperationState === RvcOperationalState.OperationalState.Docked) {
+    robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
+    return true;
+  }
+
+  return false;
+}
+
+async function processAdditionalProps(robot: RoborockVacuumCleaner, message: CloudMessageResult, duid: string, platform: RoborockMatterbridgePlatform): Promise<void> {
+  // dss -> DockingStationStatus
+  const dssStatus = getDssStatus(message, duid, platform);
+  if (dssStatus) {
+    triggerDssError(robot, platform);
+  }
+}
+
+function getDssStatus(message: CloudMessageResult, duid: string, platform: RoborockMatterbridgePlatform): RvcOperationalState.OperationalState | undefined {
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error4: Robot with DUID ${duid} not found`);
+    return undefined;
+  }
+
+  if (
+    platform.enableExperimentalFeature &&
+    platform.enableExperimentalFeature.enableExperimentalFeature &&
+    platform.enableExperimentalFeature.advancedFeature.includeDockStationStatus &&
+    message.dss !== undefined
+  ) {
+    const dss = parseDockingStationStatus(message.dss);
+    if (dss && robot) {
+      robot.dockStationStatus = dss;
+    }
+
+    if (dss && hasDockingStationError(dss)) {
+      return RvcOperationalState.OperationalState.Error;
+    }
+  }
+  return undefined;
+}
+
+async function mapRoomsToAreasFeatureOff(platform: RoborockMatterbridgePlatform, duid: string, data: CloudMessageResult): Promise<void> {
+  const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+  const robot = platform.robots.get(duid);
+  if (!robot) {
+    platform.log.error(`Robot with DUID ${duid} not found.`);
+    return;
+  }
+
+  if (!data.cleaning_info) {
+    return;
+  }
+
+  const source_segment_id = data.cleaning_info.segment_id ?? -1; // 4
+  const source_target_segment_id = data.cleaning_info.target_segment_id ?? -1; // -1
+  const segment_id = source_segment_id !== -1 ? source_segment_id : source_target_segment_id; // 4
+  const mappedArea = currentMappedAreas?.find((x) => x.areaId == segment_id);
+  platform.log.debug(
+    `mappedArea:
+    source_segment_id: ${source_segment_id},
+    source_target_segment_id: ${source_target_segment_id},
+    segment_id: ${segment_id},
+    result: ${mappedArea ? debugStringify(mappedArea) : 'undefined'}
+    `,
+  );
+  if (segment_id !== -1 && mappedArea) {
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', segment_id, platform.log);
+  }
+
+  if (segment_id == -1) {
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+  }
+}
+
+async function mapRoomsToAreasFeatureOn(platform: RoborockMatterbridgePlatform, duid: string, data: CloudMessageResult): Promise<void> {
+  const robot = platform.robots.get(duid);
+  if (!robot) {
+    platform.log.error(`Robot with DUID ${duid} not found.`);
+    return;
+  }
+
+  if (!data.cleaning_info) {
+    return;
+  }
+
+  const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+  const roomIndexMap = platform.roborockService?.getSupportedAreasIndexMap(duid);
+  const source_segment_id = data.cleaning_info.segment_id ?? -1; // 4
+  const source_target_segment_id = data.cleaning_info.target_segment_id ?? -1; // -1
+  const segment_id = source_segment_id !== -1 ? source_segment_id : source_target_segment_id; // 4
+  const areaId = roomIndexMap?.getAreaId(segment_id, 0);
+
+  if (!areaId) {
+    platform.log.debug(`
+      source_segment_id: ${source_segment_id}, 
+      source_target_segment_id: ${source_target_segment_id}, 
+      segment_id: ${segment_id}, 
+      areaId: ${areaId}`);
+    return;
+  }
+
+  const mappedArea = currentMappedAreas?.find((x) => x.areaId == areaId);
+  platform.log.debug(
+    `mappedArea:
+    source_segment_id: ${source_segment_id},
+    source_target_segment_id: ${source_target_segment_id},
+    segment_id: ${segment_id},
+    areaId: ${areaId},
+    result: ${mappedArea ? debugStringify(mappedArea) : 'undefined'}
+    `,
+  );
+
+  if (areaId !== -1 && mappedArea) {
+    robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log); // need to be 107
+  }
+}

package/src/share/runtimeHelper.ts

@@ -2,7 +2,7 @@ import { getCurrentCleanModeDefault } from '../behaviors/roborock.vacuum/default
 import { getCurrentCleanModeSmart } from '../behaviors/roborock.vacuum/smart/runtimes.js';
 import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
 
-export type CleanModeFunc = (setting: { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }) => number | undefined;
+export type CleanModeFunc = (setting: { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number | undefined }) => number | undefined;
 
 export function getCurrentCleanModeFunc(model: string, forceRunAtDefault: boolean): CleanModeFunc {
   if (forceRunAtDefault) {

package/src/tests/helper.test.ts

@@ -1,16 +1,6 @@
 import { getRoomMapFromDevice } from '../helper';
 import { RoomMap } from '../model/RoomMap';
 
-// Mocks
-// const mockLog = {
-//   notice: (message: string, ...arg: unknown[]) => console.log('NOTICE:', message, ...arg),
-//   error: (message: string, ...arg: unknown[]) => console.error('ERROR:', message, ...arg),
-//   debug: (message: string, ...arg: unknown[]) => console.debug('DEBUG:', message, ...arg),
-//   info: (message: string, ...arg: unknown[]) => console.info('INFO:', message, ...arg),
-//   warn: (message: string, ...arg: unknown[]) => console.warn('WARN:', message, ...arg),
-//   verbose: (message: string, ...arg: unknown[]) => console.log('VERBOSE:', message, ...arg),
-// };
-
 const mockLog = {
   notice: jest.fn(),
   error: jest.fn(),
@@ -110,4 +100,63 @@ describe('getRoomMapFromDevice', () => {
     expect(mockRoborockService.getRoomMappings).toHaveBeenCalledWith('123');
     expect(result.rooms.length).toBeGreaterThan(0);
   });
+
+  it('returns RoomMap from getMapInformation if available', async () => {
+    const device = {
+      duid: '123',
+      rooms: [
+        { id: 11100845, name: 'Kitchen' },
+        { id: 11100849, name: 'Study' },
+        { id: 11100842, name: 'Living room' },
+        { id: 11100847, name: 'Bedroom' },
+        { id: 12469150, name: 'Dining room' },
+        { id: 12461114, name: 'Guest bedroom' },
+        { id: 12461109, name: 'Master bedroom' },
+        { id: 12461111, name: 'Balcony' },
+        { id: 11100842, name: 'Living room' },
+      ],
+    };
+    mockRoborockService.getRoomMappings.mockResolvedValue(undefined);
+    mockRoborockService.getMapInformation.mockResolvedValue({
+      maps: [
+        {
+          id: 0,
+          name: 'First Map',
+          rooms: [
+            { id: 1, globalId: 11100845, iot_name_id: '11100845', tag: 14, displayName: 'Kitchen', mapId: 0 },
+            { id: 2, globalId: 11100849, iot_name_id: '11100849', tag: 9, displayName: 'Study', mapId: 0 },
+            { id: 3, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 0 },
+            { id: 4, globalId: 11100847, iot_name_id: '11100847', tag: 1, displayName: 'Bedroom', mapId: 0 },
+          ],
+        },
+        {
+          id: 1,
+          name: 'Second Map',
+          rooms: [
+            { id: 1, globalId: 12469150, iot_name_id: '12469150', tag: 13, displayName: 'Dining room', mapId: 1 },
+            { id: 2, globalId: 12461114, iot_name_id: '12461114', tag: 3, displayName: 'Guest bedroom', mapId: 1 },
+            { id: 3, globalId: 12461109, iot_name_id: '12461109', tag: 2, displayName: 'Master bedroom', mapId: 1 },
+            { id: 4, globalId: 12461111, iot_name_id: '12461111', tag: 7, displayName: 'Balcony', mapId: 1 },
+            { id: 5, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 1 },
+          ],
+        },
+      ],
+      allRooms: [
+        { id: 1, globalId: 11100845, iot_name_id: '11100845', tag: 14, displayName: 'Kitchen', mapId: 0 },
+        { id: 2, globalId: 11100849, iot_name_id: '11100849', tag: 9, displayName: 'Study', mapId: 0 },
+        { id: 3, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 0 },
+        { id: 4, globalId: 11100847, iot_name_id: '11100847', tag: 1, displayName: 'Bedroom', mapId: 0 },
+        { id: 1, globalId: 12469150, iot_name_id: '12469150', tag: 13, displayName: 'Dining room', mapId: 1 },
+        { id: 2, globalId: 12461114, iot_name_id: '12461114', tag: 3, displayName: 'Guest bedroom', mapId: 1 },
+        { id: 3, globalId: 12461109, iot_name_id: '12461109', tag: 2, displayName: 'Master bedroom', mapId: 1 },
+        { id: 4, globalId: 12461111, iot_name_id: '12461111', tag: 7, displayName: 'Balcony', mapId: 1 },
+        { id: 5, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 1 },
+      ],
+    });
+
+    const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(mockRoborockService.getMapInformation).toHaveBeenCalledWith('123');
+    expect(result.rooms.length).toBeGreaterThan(0);
+  });
 });

package/src/tests/roborockService.setSelectedAreas.test.ts

@@ -0,0 +1,61 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../roborockService';
+import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { RoomIndexMap } from '../model/roomIndexMap';
+
+describe('RoborockService - startClean', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+  let mockLoginApi: any;
+  let mockIotApi: any;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: jest.fn(),
+      notice: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    mockMessageProcessor = {
+      startClean: jest.fn(),
+      startRoomClean: jest.fn(),
+    } as any;
+
+    mockLoginApi = {
+      loginWithPassword: jest.fn(),
+      loginWithUserData: jest.fn(),
+    };
+
+    roborockService = new RoborockService(() => mockLoginApi, jest.fn(), 10, {} as any, mockLogger);
+    roborockService['auth'] = jest.fn((ud) => ud);
+    roborockService['messageProcessorMap'] = new Map<string, MessageProcessor>([['test-duid', mockMessageProcessor]]);
+
+    mockIotApi = { getCustom: jest.fn() };
+    roborockService['iotApi'] = mockIotApi;
+  });
+
+  it('setSelectedAreas should set selected areas', () => {
+    roborockService.setSupportedAreaIndexMap(
+      'duid',
+      new RoomIndexMap(
+        new Map([
+          [100, { roomId: 1, mapId: 0 }],
+          [101, { roomId: 2, mapId: 0 }],
+          [102, { roomId: 3, mapId: 0 }],
+          [103, { roomId: 4, mapId: 0 }],
+          [104, { roomId: 1, mapId: 1 }],
+          [105, { roomId: 2, mapId: 1 }],
+          [106, { roomId: 3, mapId: 1 }],
+          [107, { roomId: 4, mapId: 1 }],
+          [108, { roomId: 5, mapId: 1 }],
+        ]),
+      ),
+    );
+    roborockService.setSelectedAreas('duid', [106, 108]);
+
+    expect(roborockService['selectedAreas'].get('duid')).toEqual([3, 5]);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - setSelectedAreas - roomIds', [3, 5]);
+  });
+});