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

package/src/behaviors/roborock.vacuum/default/default.ts

@@ -0,0 +1,238 @@
+import { MaybePromise } from 'matterbridge/matter';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { BehaviorDeviceGeneric, BehaviorRoborock, DeviceCommands } from '../../BehaviorDeviceGeneric.js';
+import RoborockService from '../../../roborockService.js';
+import { CleanModeSettings } from '../../../model/ExperimentalFeatureSetting.js';
+
+export interface DefaultEndpointCommands extends DeviceCommands {
+  selectAreas: (newAreas: number[]) => MaybePromise;
+  changeToMode: (newMode: number) => MaybePromise;
+  pause: () => MaybePromise;
+  resume: () => MaybePromise;
+  goHome: () => MaybePromise;
+  playSoundToLocate: (identifyTime: number) => MaybePromise;
+}
+
+export class DefaultBehavior extends BehaviorRoborock {
+  declare state: DefaultBehaviorRoborockState;
+}
+
+export interface DefaultBehaviorRoborockState {
+  device: BehaviorDeviceGeneric<DefaultEndpointCommands>;
+}
+
+// suction_power
+export enum VacuumSuctionPower {
+  Quiet = 101,
+  Balanced = 102,
+  Turbo = 103,
+  Max = 104,
+  Off = 105,
+  Custom = 106,
+  MaxPlus = 108,
+}
+
+// water_box_mode
+export enum MopWaterFlow {
+  Off = 200,
+  Low = 201,
+  Medium = 202,
+  High = 203,
+  Custom = 204,
+  CustomizeWithDistanceOff = 207,
+}
+
+// set_mop_mode
+export enum MopRoute {
+  Standard = 300,
+  Deep = 301,
+  Custom = 302,
+  DeepPlus = 303,
+  Fast = 304,
+}
+
+export const RvcRunMode: Record<number, string> = {
+  [1]: 'Idle', // DO NOT HANDLE HERE,
+  [2]: 'Cleaning',
+  [3]: 'Mapping',
+};
+
+export const RvcCleanMode: Record<number, string> = {
+  [5]: 'Mop & Vacuum: Default',
+  [6]: 'Mop & Vacuum: Quick',
+  [7]: 'Mop & Vacuum: Max',
+  [8]: 'Mop & Vacuum: Min',
+  [9]: 'Mop & Vacuum: Quiet',
+  [10]: 'Mop & Vacuum: Custom',
+
+  [31]: 'Mop: Default',
+  [32]: 'Mop: Max',
+  [33]: 'Mop: Min',
+  [34]: 'Mop: Quick',
+  [35]: 'Mop: DeepClean',
+
+  [66]: 'Vacuum: Default',
+  [67]: 'Vacuum: Max',
+  [68]: 'Vacuum: Quiet',
+  [69]: 'Vacuum: Quick',
+
+  [99]: 'Go Vacation',
+};
+
+export interface CleanModeSetting {
+  suctionPower: number;
+  waterFlow: number;
+  distance_off: number;
+  mopRoute: number | undefined;
+}
+
+export const CleanSetting: Record<number, CleanModeSetting> = {
+  [5]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Vac & Mop Default'
+  [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast }, // 'Vac & Mop Quick'
+
+  [7]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Vac & Mop Max'
+  [8]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Vac & Mop Min'
+  [9]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Vac & Mop Quiet'
+
+  [10]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom }, // 'Vac & Mop Custom -> LowEnergy'
+
+  [31]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Mop Default'
+  [32]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.High, distance_off: 0, mopRoute: MopRoute.Standard }, // 'MopMax'
+  [33]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard }, // 'MopMin'
+  [34]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast }, // 'MopQuick'
+  [35]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Deep }, // 'MopDeepClean'
+
+  [66]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard }, // 'Vacuum Default'
+  [67]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard }, // 'VacuumMax'
+  [68]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard }, // 'VacuumQuiet'
+  [69]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Fast }, // 'VacuumQuick'
+};
+
+export function setDefaultCommandHandler(
+  duid: string,
+  handler: BehaviorDeviceGeneric<DefaultEndpointCommands>,
+  logger: AnsiLogger,
+  roborockService: RoborockService,
+  cleanModeSettings: CleanModeSettings | undefined,
+): void {
+  handler.setCommandHandler('changeToMode', async (newMode: number) => {
+    const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+    switch (activity) {
+      case 'Cleaning': {
+        logger.notice('DefaultBehavior-ChangeRunMode to: ', activity);
+        await roborockService.startClean(duid);
+        break;
+      }
+
+      case 'Go Vacation': {
+        logger.notice('DefaultBehavior-GoHome');
+        await roborockService.stopAndGoHome(duid);
+        break;
+      }
+
+      case 'Mop & Vacuum: Custom': {
+        const setting = CleanSetting[newMode];
+        logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+        await roborockService.changeCleanMode(duid, setting);
+        break;
+      }
+
+      case 'Mop & Vacuum: Default':
+      case 'Mop: Default':
+      case 'Vacuum: Default': {
+        const setting = cleanModeSettings ? (getSettingFromCleanMode(activity, cleanModeSettings) ?? CleanSetting[newMode]) : CleanSetting[newMode];
+        logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+        if (setting) {
+          await roborockService.changeCleanMode(duid, setting);
+        }
+        break;
+      }
+
+      case 'Mop & Vacuum: Quick':
+      case 'Mop & Vacuum: Max':
+      case 'Mop & Vacuum: Min':
+      case 'Mop & Vacuum: Quiet':
+      case 'Mop: Max':
+      case 'Mop: Min':
+      case 'Mop: Quick':
+      case 'Mop: DeepClean':
+      case 'Vacuum: Max':
+      case 'Vacuum: Min':
+      case 'Vacuum: Quiet':
+      case 'Vacuum: Quick': {
+        const setting = CleanSetting[newMode];
+        logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+        if (setting) {
+          await roborockService.changeCleanMode(duid, setting);
+        }
+        break;
+      }
+      default:
+        logger.notice('DefaultBehavior-changeToMode-Unknown: ', newMode);
+        break;
+    }
+  });
+
+  handler.setCommandHandler('selectAreas', async (newAreas: number[]) => {
+    logger.notice(`DefaultBehavior-selectAreas: ${newAreas}`);
+    roborockService.setSelectedAreas(duid, newAreas ?? []);
+  });
+
+  handler.setCommandHandler('pause', async () => {
+    logger.notice('DefaultBehavior-Pause');
+    await roborockService.pauseClean(duid);
+  });
+
+  handler.setCommandHandler('resume', async () => {
+    logger.notice('DefaultBehavior-Resume');
+    await roborockService.resumeClean(duid);
+  });
+
+  handler.setCommandHandler('goHome', async () => {
+    logger.notice('DefaultBehavior-GoHome');
+    await roborockService.stopAndGoHome(duid);
+  });
+
+  handler.setCommandHandler('playSoundToLocate', async () => {
+    logger.notice('DefaultBehavior-playSoundToLocate');
+    await roborockService.playSoundToLocate(duid);
+  });
+}
+
+export const getSettingFromCleanMode = (activity: string, cleanModeSettings?: CleanModeSettings): CleanModeSetting | undefined => {
+  switch (activity) {
+    case 'Mop: Default': {
+      const mopSetting = cleanModeSettings?.mopping;
+      const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode as keyof typeof MopWaterFlow] ?? MopWaterFlow.Medium;
+      const distance_off = waterFlow == MopWaterFlow.CustomizeWithDistanceOff ? 210 - 5 * (mopSetting?.distanceOff ?? 25) : 0;
+      return {
+        suctionPower: VacuumSuctionPower.Off,
+        waterFlow,
+        distance_off,
+        mopRoute: MopRoute[mopSetting?.mopRouteMode as keyof typeof MopRoute] ?? MopRoute.Standard,
+      };
+    }
+    case 'Vacuum: Default': {
+      const vacuumSetting = cleanModeSettings?.vacuuming;
+      return {
+        suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode as keyof typeof VacuumSuctionPower] ?? VacuumSuctionPower.Balanced,
+        waterFlow: MopWaterFlow.Off,
+        distance_off: 0,
+        mopRoute: MopRoute[vacuumSetting?.mopRouteMode as keyof typeof MopRoute] ?? MopRoute.Standard,
+      };
+    }
+    case 'Mop & Vacuum: Default': {
+      const vacmopSetting = cleanModeSettings?.vacmop;
+      const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode as keyof typeof MopWaterFlow] ?? MopWaterFlow.Medium;
+      const distance_off = waterFlow == MopWaterFlow.CustomizeWithDistanceOff ? 210 - 5 * (vacmopSetting?.distanceOff ?? 25) : 0;
+      return {
+        suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode as keyof typeof VacuumSuctionPower] ?? VacuumSuctionPower.Balanced,
+        waterFlow,
+        distance_off,
+        mopRoute: MopRoute[vacmopSetting?.mopRouteMode as keyof typeof MopRoute] ?? MopRoute.Standard,
+      };
+    }
+    default:
+      return undefined;
+  }
+};

package/src/behaviors/roborock.vacuum/default/initalData.ts

@@ -0,0 +1,152 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './default.js';
+import { ExperimentalFeatureSetting } from '../../../model/ExperimentalFeatureSetting.js';
+
+export function getDefaultSupportedRunModes(): RvcRunMode.ModeOption[] {
+  return [
+    {
+      label: 'Idle',
+      mode: 1,
+      modeTags: [{ value: RvcRunMode.ModeTag.Idle }],
+    },
+    {
+      label: 'Cleaning',
+      mode: 2,
+      modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }],
+    },
+    {
+      label: 'Mapping',
+      mode: 3,
+      modeTags: [{ value: RvcRunMode.ModeTag.Mapping }],
+    },
+  ];
+}
+
+export function getDefaultSupportedCleanModes(enableExperimentalFeature: ExperimentalFeatureSetting | undefined): RvcCleanMode.ModeOption[] {
+  const result = [
+    {
+      label: RvcCleanModeDisplayMap[5],
+      mode: 5,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[6],
+      mode: 6,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[7],
+      mode: 7,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Max }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[8],
+      mode: 8,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Min }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[9],
+      mode: 9,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quiet }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[10],
+      mode: 10,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.LowEnergy }],
+    },
+
+    {
+      label: RvcCleanModeDisplayMap[31],
+      mode: 31,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+    },
+
+    {
+      label: RvcCleanModeDisplayMap[32],
+      mode: 32,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Max }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[33],
+      mode: 33,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Min }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[34],
+      mode: 34,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Quick }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[35],
+      mode: 35,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.DeepClean }],
+    },
+
+    {
+      label: RvcCleanModeDisplayMap[66],
+      mode: 66,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[67],
+      mode: 67,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Max }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[68],
+      mode: 68,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quiet }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[69],
+      mode: 69,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+    },
+  ];
+
+  if (enableExperimentalFeature?.advancedFeature?.useVacationModeToSendVacuumToDock ?? false) {
+    return [
+      ...result,
+      {
+        label: RvcCleanModeDisplayMap[99],
+        mode: 99,
+        modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Vacation }],
+      },
+    ];
+  }
+
+  return result;
+}
+
+export function getDefaultOperationalStates(): RvcOperationalState.OperationalStateStruct[] {
+  return [
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Stopped,
+      operationalStateLabel: 'Stopped',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Running,
+      operationalStateLabel: 'Running',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Paused,
+      operationalStateLabel: 'Paused',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Error,
+      operationalStateLabel: 'Error',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.SeekingCharger,
+      operationalStateLabel: 'SeekingCharger',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Charging,
+      operationalStateLabel: 'Charging',
+    },
+    {
+      operationalStateId: RvcOperationalState.OperationalState.Docked,
+      operationalStateLabel: 'Docked',
+    },
+  ];
+}

package/src/behaviors/roborock.vacuum/default/runtimes.ts

@@ -0,0 +1,23 @@
+import { CleanModeSetting, CleanSetting, MopRoute, MopWaterFlow, VacuumSuctionPower } from './default.js';
+
+export function getCurrentCleanModeDefault(setting: CleanModeSetting): number | undefined {
+  if (!setting || typeof setting !== 'object') {
+    return undefined;
+  }
+
+  if (setting.suctionPower === VacuumSuctionPower.Custom || setting.waterFlow === MopWaterFlow.Custom || setting.mopRoute === MopRoute.Custom) {
+    return 10; // 'Vac & Mop Custom'
+  }
+
+  for (const [key, value] of Object.entries(CleanSetting)) {
+    if (value.suctionPower === setting.suctionPower && value.waterFlow === setting.waterFlow && value.mopRoute === setting.mopRoute) {
+      return Number(key);
+    }
+  }
+
+  if (setting.suctionPower == VacuumSuctionPower.Off) return 31; // 'Mop Default'
+  if (setting.waterFlow == MopWaterFlow.Off) return 66; // 'Vacuum Default'
+  if ((setting.suctionPower !== VacuumSuctionPower.Off && setting.waterFlow) !== MopWaterFlow.Off) return 5; // 'Vac & Mop Default'
+
+  return undefined;
+}

package/src/behaviors/roborock.vacuum/smart/initalData.ts

@@ -0,0 +1,20 @@
+import { RvcCleanMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './smart.js';
+import { getDefaultSupportedCleanModes } from '../default/initalData.js';
+import { ExperimentalFeatureSetting } from '../../../model/ExperimentalFeatureSetting.js';
+
+export function getSupportedCleanModesSmart(enableExperimentalFeature: ExperimentalFeatureSetting | undefined): RvcCleanMode.ModeOption[] {
+  return [
+    {
+      label: RvcCleanModeDisplayMap[4],
+      mode: 4,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+    },
+    {
+      label: RvcCleanModeDisplayMap[5],
+      mode: 5,
+      modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Day }],
+    },
+    ...getDefaultSupportedCleanModes(enableExperimentalFeature).filter((x) => x.mode !== 4 && x.mode !== 5), // Exclude modes 4 and 5 which are already defined
+  ];
+}

package/src/behaviors/roborock.vacuum/smart/runtimes.ts

@@ -0,0 +1,15 @@
+import { CleanModeSetting } from '../default/default.js';
+import { getCurrentCleanModeDefault } from '../default/runtimes.js';
+import { MopRouteSmart, MopWaterFlowSmart, VacuumSuctionPowerSmart } from './smart.js';
+
+export function getCurrentCleanModeSmart(setting: CleanModeSetting): number | undefined {
+  if (!setting || typeof setting !== 'object') {
+    return undefined;
+  }
+
+  if (setting.suctionPower === VacuumSuctionPowerSmart.Smart || setting.waterFlow === MopWaterFlowSmart.Smart || setting.mopRoute === MopRouteSmart.Smart) {
+    return 4; // 'Smart Plan'
+  }
+
+  return getCurrentCleanModeDefault(setting);
+}

package/src/behaviors/roborock.vacuum/smart/smart.ts

@@ -0,0 +1,159 @@
+import { MaybePromise } from 'matterbridge/matter';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { BehaviorDeviceGeneric, BehaviorRoborock, DeviceCommands } from '../../BehaviorDeviceGeneric.js';
+import RoborockService from '../../../roborockService.js';
+import { CleanModeSettings } from '../../../model/ExperimentalFeatureSetting.js';
+import { RvcCleanMode as DefaultRvcCleanMode, CleanSetting as DefaultCleanSetting, getSettingFromCleanMode, RvcRunMode, CleanModeSetting } from '../default/default.js';
+
+export interface EndpointCommandsSmart extends DeviceCommands {
+  selectAreas: (newAreas: number[] | undefined) => MaybePromise;
+  changeToMode: (newMode: number) => MaybePromise;
+  pause: () => MaybePromise;
+  resume: () => MaybePromise;
+  goHome: () => MaybePromise;
+  playSoundToLocate: (identifyTime: number) => MaybePromise;
+}
+
+export class BehaviorSmart extends BehaviorRoborock {
+  declare state: BehaviorRoborockSmartState;
+}
+
+export interface BehaviorRoborockSmartState {
+  device: BehaviorDeviceGeneric<EndpointCommandsSmart>;
+}
+
+// get_custom_mode
+export enum VacuumSuctionPowerSmart {
+  Quiet = 101,
+  Balanced = 102,
+  Turbo = 103,
+  Max = 104,
+  Off = 105,
+  Custom = 106,
+  MaxPlus = 108,
+  Smart = 110,
+}
+
+// get_water_box_custom_mode
+export enum MopWaterFlowSmart {
+  Off = 200,
+  Low = 201,
+  Medium = 202,
+  High = 203,
+  Custom = 204,
+  CustomizeWithDistanceOff = 207,
+  Smart = 209,
+}
+
+// get_mop_mode
+export enum MopRouteSmart {
+  Standard = 300,
+  Deep = 301,
+  Custom = 302,
+  DeepPlus = 303,
+  Fast = 304,
+  Smart = 306,
+}
+
+export const RvcCleanMode: Record<number, string> = {
+  [4]: 'Smart Plan',
+  ...DefaultRvcCleanMode,
+};
+
+// { suctionPower: [ 102 ], waterFlow: 200, distance_off: 0, mopRoute: [ 102 ] }
+export const CleanSetting: Record<number, CleanModeSetting> = {
+  [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteSmart.Smart }, // 'Smart Plan'
+  ...DefaultCleanSetting,
+};
+
+export function setCommandHandlerSmart(
+  duid: string,
+  handler: BehaviorDeviceGeneric<EndpointCommandsSmart>,
+  logger: AnsiLogger,
+  roborockService: RoborockService,
+  cleanModeSettings: CleanModeSettings | undefined,
+): void {
+  handler.setCommandHandler('changeToMode', async (newMode: number) => {
+    const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+    switch (activity) {
+      case 'Cleaning': {
+        logger.notice('BehaviorSmart-ChangeRunMode to: ', activity);
+        await roborockService.startClean(duid);
+        break;
+      }
+
+      case 'Go Vacation': {
+        logger.notice('BehaviorSmart-GoHome');
+        await roborockService.stopAndGoHome(duid);
+        break;
+      }
+
+      case 'Smart Plan':
+      case 'Mop & Vacuum: Custom': {
+        const setting = CleanSetting[newMode];
+        logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+        await roborockService.changeCleanMode(duid, setting);
+        break;
+      }
+
+      case 'Mop & Vacuum: Default':
+      case 'Mop: Default':
+      case 'Vacuum: Default': {
+        const setting = cleanModeSettings ? (getSettingFromCleanMode(activity, cleanModeSettings) ?? CleanSetting[newMode]) : CleanSetting[newMode];
+        logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+        if (setting) {
+          await roborockService.changeCleanMode(duid, setting);
+        }
+        break;
+      }
+
+      case 'Mop & Vacuum: Quick':
+      case 'Mop & Vacuum: Max':
+      case 'Mop & Vacuum: Min':
+      case 'Mop & Vacuum: Quiet':
+      case 'Mop: Max':
+      case 'Mop: Min':
+      case 'Mop: Quick':
+      case 'Mop: DeepClean':
+      case 'Vacuum: Max':
+      case 'Vacuum: Min':
+      case 'Vacuum: Quiet':
+      case 'Vacuum: Quick': {
+        const setting = CleanSetting[newMode];
+        logger.notice(`BehaviorSmart-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+        if (setting) {
+          await roborockService.changeCleanMode(duid, setting);
+        }
+        break;
+      }
+      default:
+        logger.notice('BehaviorSmart-changeToMode-Unknown: ', newMode);
+        break;
+    }
+  });
+
+  handler.setCommandHandler('selectAreas', async (newAreas: number[] | undefined) => {
+    logger.notice(`BehaviorSmart-selectAreas: ${newAreas}`);
+    roborockService.setSelectedAreas(duid, newAreas ?? []);
+  });
+
+  handler.setCommandHandler('pause', async () => {
+    logger.notice('BehaviorSmart-Pause');
+    await roborockService.pauseClean(duid);
+  });
+
+  handler.setCommandHandler('resume', async () => {
+    logger.notice('BehaviorSmart-Resume');
+    await roborockService.resumeClean(duid);
+  });
+
+  handler.setCommandHandler('goHome', async () => {
+    logger.notice('BehaviorSmart-GoHome');
+    await roborockService.stopAndGoHome(duid);
+  });
+
+  handler.setCommandHandler('playSoundToLocate', async () => {
+    logger.notice('BehaviorSmart-playSoundToLocate');
+    await roborockService.playSoundToLocate(duid);
+  });
+}

package/src/clientManager.ts

@@ -0,0 +1,23 @@
+import { ClientRouter } from './roborockCommunication/broadcast/clientRouter.js';
+import { UserData } from './roborockCommunication/index.js';
+import { AnsiLogger } from 'matterbridge/logger';
+
+export default class ClientManager {
+  private readonly clients = new Map<string, ClientRouter>();
+  private logger: AnsiLogger;
+
+  public constructor(logger: AnsiLogger) {
+    this.logger = logger;
+  }
+
+  public get(username: string, userdata: UserData): ClientRouter {
+    if (!this.clients.has(username)) {
+      this.clients.set(username, new ClientRouter(this.logger, userdata));
+    }
+    return this.clients.get(username) as ClientRouter;
+  }
+
+  public destroy(username: string): void {
+    this.clients.delete(username);
+  }
+}