matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

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/rvc.ts

@@ -0,0 +1,97 @@
+import { RoboticVacuumCleaner } from 'matterbridge/devices';
+import { RoomMap } from './model/RoomMap.js';
+import { Device } from './roborockCommunication/index.js';
+import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { BehaviorFactoryResult } from './behaviorFactory.js';
+import { ModeBase, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
+import { ExperimentalFeatureSetting } from './model/ExperimentalFeatureSetting.js';
+import { DockingStationStatus } from './model/DockingStationStatus.js';
+
+interface IdentifyCommandRequest {
+  identifyTime?: number;
+}
+
+export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
+  username: string | undefined;
+  device: Device;
+  roomInfo: RoomMap | undefined;
+  dockStationStatus: DockingStationStatus | undefined;
+
+  constructor(
+    username: string,
+    device: Device,
+    roomMap: RoomMap,
+    routineAsRoom: ServiceArea.Area[],
+    enableExperimentalFeature: ExperimentalFeatureSetting | undefined,
+    log: AnsiLogger,
+  ) {
+    const cleanModes = getSupportedCleanModes(device.data.model, enableExperimentalFeature);
+    const supportedRunModes = getSupportedRunModes();
+    const enableMultipleMap = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableMultipleMap;
+
+    const { supportedAreas, supportedMaps } = getSupportedAreas(device.rooms, roomMap, enableMultipleMap, log);
+    const supportedAreaAndRoutines = [...supportedAreas, ...routineAsRoom];
+    const deviceName = `${device.name}-${device.duid}`.replace(/\s+/g, '');
+
+    log.debug(
+      `Creating RoborockVacuumCleaner for device: ${deviceName}, model: ${device.data.model}, forceRunAtDefault: ${enableExperimentalFeature?.advancedFeature?.forceRunAtDefault}`,
+    );
+    log.debug(`Supported Clean Modes: ${JSON.stringify(cleanModes)}`);
+    log.debug(`Supported Run Modes: ${JSON.stringify(supportedRunModes)}`);
+    log.debug(`Supported Areas: ${JSON.stringify(supportedAreas)}`);
+    log.debug(`Supported Maps: ${JSON.stringify(supportedMaps)}`);
+
+    const bridgeMode = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableServerMode ? 'server' : undefined;
+    super(
+      deviceName, // name
+      device.duid, // serial
+      bridgeMode, // mode
+      supportedRunModes[0].mode, // currentRunMode
+      supportedRunModes, // supportedRunModes
+      cleanModes[0].mode, // currentCleanMode
+      cleanModes, // supportedCleanModes
+      undefined, // currentPhase
+      undefined, // phaseList
+      RvcOperationalState.OperationalState.Docked, // operationalState
+      getOperationalStates(), // operationalStateList
+      supportedAreaAndRoutines, // supportedAreas
+      undefined, // selectedAreas
+      supportedAreas[0].areaId, // currentArea
+      supportedMaps, // supportedMaps
+    );
+
+    this.username = username;
+    this.device = device;
+  }
+
+  public configurateHandler(behaviorHandler: BehaviorFactoryResult): void {
+    this.addCommandHandler('identify', async ({ request, cluster, attributes, endpoint }) => {
+      this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${debugStringify(attributes)}, request: ${JSON.stringify(request)}`);
+      behaviorHandler.executeCommand('playSoundToLocate', (request as IdentifyCommandRequest).identifyTime ?? 0);
+    });
+
+    this.addCommandHandler('selectAreas', async ({ request }) => {
+      const { newAreas } = request as ServiceArea.SelectAreasRequest;
+      this.log.info(`Selecting areas: ${newAreas?.join(', ')}`);
+      behaviorHandler.executeCommand('selectAreas', newAreas);
+    });
+
+    this.addCommandHandler('changeToMode', async ({ request }) => {
+      const { newMode } = request as ModeBase.ChangeToModeRequest;
+      behaviorHandler.executeCommand('changeToMode', newMode);
+    });
+
+    this.addCommandHandler('pause', async () => {
+      behaviorHandler.executeCommand('pause');
+    });
+
+    this.addCommandHandler('resume', async () => {
+      behaviorHandler.executeCommand('resume');
+    });
+
+    this.addCommandHandler('goHome', async () => {
+      behaviorHandler.executeCommand('goHome');
+    });
+  }
+}

package/src/settings.ts

@@ -0,0 +1 @@
+export const PLUGIN_NAME = 'matterbridge-roborock-vacuum-plugin-jb';

package/src/share/function.ts

@@ -0,0 +1,103 @@
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { RvcRunMode, RvcOperationalState } from 'matterbridge/matter/clusters';
+
+export function state_to_matter_state(state: number | undefined): RvcRunMode.ModeTag | undefined {
+  if (state === null) {
+    return undefined;
+  }
+
+  switch (state) {
+    case OperationStatusCode.RemoteControl:
+    case OperationStatusCode.Cleaning:
+    case OperationStatusCode.ReturningDock:
+    case OperationStatusCode.ManualMode:
+    case OperationStatusCode.SpotCleaning:
+    case OperationStatusCode.ReturnToDock:
+    case OperationStatusCode.GoTo:
+    case OperationStatusCode.ZoneClean:
+    case OperationStatusCode.RoomClean:
+    case OperationStatusCode.WashingTheMop:
+    case OperationStatusCode.GoingToWashTheMop:
+    case OperationStatusCode.EmptyingDustContainer:
+    case OperationStatusCode.Initiating:
+    case OperationStatusCode.Paused:
+    case OperationStatusCode.AirDryingStopping:
+    case OperationStatusCode.CleanMopCleaning:
+    case OperationStatusCode.CleanMopMopping:
+    case OperationStatusCode.RoomMopping:
+    case OperationStatusCode.RoomCleanMopCleaning:
+    case OperationStatusCode.RoomCleanMopMopping:
+    case OperationStatusCode.ZoneMopping:
+    case OperationStatusCode.ZoneCleanMopCleaning:
+    case OperationStatusCode.ZoneCleanMopMopping:
+    case OperationStatusCode.BackToDockWashingDuster:
+      return RvcRunMode.ModeTag.Cleaning;
+
+    case OperationStatusCode.Mapping:
+      return RvcRunMode.ModeTag.Mapping;
+
+    case OperationStatusCode.Idle:
+    case OperationStatusCode.Sleeping:
+    case OperationStatusCode.Charging:
+    case OperationStatusCode.FullyCharged:
+    default:
+      return RvcRunMode.ModeTag.Idle;
+  }
+}
+
+export function state_to_matter_operational_status(state: number | undefined): RvcOperationalState.OperationalState | null {
+  switch (state) {
+    case OperationStatusCode.Initiating:
+    case OperationStatusCode.RemoteControl:
+    case OperationStatusCode.Cleaning:
+    case OperationStatusCode.ManualMode:
+    case OperationStatusCode.SpotCleaning:
+    case OperationStatusCode.GoTo:
+    case OperationStatusCode.ZoneClean:
+    case OperationStatusCode.RoomClean:
+    case OperationStatusCode.InCall:
+    case OperationStatusCode.Mapping:
+    case OperationStatusCode.Patrol:
+    case OperationStatusCode.CleanMopCleaning:
+    case OperationStatusCode.CleanMopMopping:
+    case OperationStatusCode.RoomMopping:
+    case OperationStatusCode.RoomCleanMopCleaning:
+    case OperationStatusCode.RoomCleanMopMopping:
+    case OperationStatusCode.ZoneMopping:
+    case OperationStatusCode.ZoneCleanMopCleaning:
+    case OperationStatusCode.ZoneCleanMopMopping:
+    case OperationStatusCode.RobotStatusMopping:
+      return RvcOperationalState.OperationalState.Running;
+
+    case OperationStatusCode.InError:
+    case OperationStatusCode.ChargingError:
+    case OperationStatusCode.Unknown:
+    case OperationStatusCode.DeviceOffline:
+    case OperationStatusCode.Locked:
+    case OperationStatusCode.AirDryingStopping:
+      return RvcOperationalState.OperationalState.Error;
+
+    case OperationStatusCode.Paused:
+      return RvcOperationalState.OperationalState.Paused;
+
+    case OperationStatusCode.ShuttingDown:
+      return RvcOperationalState.OperationalState.Stopped;
+
+    case OperationStatusCode.ReturnToDock:
+    case OperationStatusCode.ReturningDock:
+    case OperationStatusCode.WashingTheMop:
+    case OperationStatusCode.WashingTheMop2:
+    case OperationStatusCode.GoingToWashTheMop:
+    case OperationStatusCode.BackToDockWashingDuster:
+    case OperationStatusCode.EmptyingDustContainer:
+      return RvcOperationalState.OperationalState.SeekingCharger;
+
+    case OperationStatusCode.Idle:
+    case OperationStatusCode.Sleeping:
+    case OperationStatusCode.Updating:
+    case OperationStatusCode.FullyCharged:
+    case OperationStatusCode.Charging:
+    default:
+      return RvcOperationalState.OperationalState.Docked;
+  }
+}

package/src/share/runtimeHelper.ts

@@ -0,0 +1,23 @@
+import { CleanModeSetting } from '../behaviors/roborock.vacuum/default/default.js';
+import { getCurrentCleanModeDefault } from '../behaviors/roborock.vacuum/default/runtimes.js';
+import { getCurrentCleanModeSmart } from '../behaviors/roborock.vacuum/smart/runtimes.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+
+export type CleanModeFunc = (setting: CleanModeSetting) => number | undefined;
+
+export function getCurrentCleanModeFunc(model: string, forceRunAtDefault: boolean): CleanModeFunc {
+  if (forceRunAtDefault) {
+    return getCurrentCleanModeDefault;
+  }
+
+  switch (model) {
+    case DeviceModel.QREVO_EDGE_5V1:
+      return getCurrentCleanModeSmart;
+
+    case DeviceModel.S7_MAXV:
+    case DeviceModel.S8_PRO_ULTRA:
+    case DeviceModel.S6_PURE:
+    default:
+      return getCurrentCleanModeDefault;
+  }
+}