matterbridge-roborock-vacuum-plugin 1.0.8-rc05 → 1.0.8-rc07

package/README.md

@@ -40,7 +40,7 @@
 - **Matterbridge must be run in child bridge mode** for proper operation.
 - **Use one Matterbridge instance per Roborock vacuum.**  
   If you have more than one vacuum, please run separate instances.
-  Please put the **duid** of device you want to use into **whiteList** section in the plugin configuration popup.
+  Please put the <**Vacuum name**>-<**duid**> of device you want to use into **whiteList** section in the plugin configuration popup.
 
 
   More details available here: [Discussion #264](https://github.com/Luligu/matterbridge/discussions/264)
@@ -74,7 +74,14 @@ To get the **DUID** for your devices, you have two options:
 
 ---
 
-**➡️ [See Supported & Tested Roborock Devices](./README_SUPPORTED.md)**
+
+### ➡️ [See Supported & Tested Roborock Devices](./README_SUPPORTED.md)
+
+
+📋 **Apple Home ↔️ Roborock Clean Mode Mapping:**  
+For a detailed table of how Apple Home clean modes map to Roborock settings, see  👉 [Apple Home ↔️ Roborock Clean Mode Mapping](./README_CLEANMODE.md)
+
+---
 
 ### 📦 Prerequisites
 

package/README_CLEANMODE.md

@@ -0,0 +1,29 @@
+# Apple Home RVC Clean Mode Mapping to Roborock Clean Setting
+
+This table shows the mapping between **Apple Home RVC Clean Modes** and the corresponding **Roborock Clean Settings** as defined in `smart.ts` and `default.ts`.
+
+| Apple Home RVC Clean Mode (Key) | Apple Home Mode Name         | Roborock Clean Mode | suctionPower (enum value) | waterFlow (enum value) | distance_off | mopRoute (enum value) |
+|:-------------------------------:|:-----------------------------|:--------------------|:--------------------------|:----------------------|:------------:|:---------------------:|
+| 4 *(smart only)*                | Mop & Vacuum: Automatic      | Smart Plan          | 0                         | 0                     | 0            | Smart (306)           |
+| 5                               | Mop & Vacuum: Day (Automatic)| Vac & Mop           | Balanced (102)            | Medium (202)          | 0            | Standard (300)        |
+| 6                               | Mop & Vacuum: Quick          | Vac & Mop           | Balanced (102)            | Medium (202)          | 0            | Fast (304)            |
+| 7                               | Mop & Vacuum: Max            | Vac & Mop           | Max (104)                 | Medium (202)          | 0            | Standard (300)        |
+| 8                               | Mop & Vacuum: Min            | Vac & Mop           | Balanced (102)            | Low (201)             | 0            | Standard (300)        |
+| 9                               | Mop & Vacuum: Quiet          | Vac & Mop           | Quiet (101)               | Medium (202)          | 0            | Standard (300)        |
+| 10                              | Mop & Vacuum: LowEnergy      | Custom              | Custom (106)              | Custom (204)          | 0            | Custom (302)          |
+| 31                              | Mop: Default                 | Mop                 | Off (105)                 | Medium (202)          | 0            | Standard (300)        |
+| 32                              | Mop: Max                     | Mop                 | Off (105)                 | High (203)            | 0            | Standard (300)        |
+| 33                              | Mop: Min                     | Mop                 | Off (105)                 | Low (201)             | 0            | Standard (300)        |
+| 34                              | Mop: Quick                   | Mop                 | Off (105)                 | Medium (202)          | 0            | Fast (304)            |
+| 35                              | Mop: DeepClean               | Mop                 | Off (105)                 | Medium (202)          | 0            | Deep (301)            |
+| 66                              | Vacuum: Default              | Vacuum              | Balanced (102)            | Off (200)             | 0            | Standard (300)        |
+| 67                              | Vacuum: Max                  | Vacuum              | Max (104)                 | Off (200)             | 0            | Standard (300)        |
+| 68                              | Vacuum: Quiet                | Vacuum              | Quiet (101)               | Off (200)             | 0            | Standard (300)        |
+| 69                              | Vacuum: Quick                | Vacuum              | Balanced (102)            | Off (200)             | 0            | Fast (304)            |
+| 99                              | Mop & Vacuum: Vacation       |                     |                           |                       |              |                       |
+
+**Notes:**
+- The values in parentheses are enum values from `VacuumSuctionPowerSmart`/`VacuumSuctionPower`, `MopWaterFlowSmart`/`MopWaterFlow`, and `MopRouteSmart`/`MopRoute` in `smart.ts` and `default.ts`.
+- Key 4 ("Smart Plan") is only available on some new vacuums.
+- This mapping helps you understand how Apple Home clean modes correspond to Roborock's internal cleaning settings for both "smart" and "default" behaviors.
+- Key 99 is a tricky mode to support go to charge in Apple Home Automation

package/dist/behaviorFactory.js

@@ -1,26 +1,22 @@
 import { BehaviorDeviceGeneric } from './behaviors/BehaviorDeviceGeneric.js';
-import { setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js';
 import { setDefaultCommandHandler } from './behaviors/roborock.vacuum/default/default.js';
 import { DeviceModel } from './roborockCommunication/Zmodel/deviceModel.js';
-import { setCommandHandlerA27 } from './behaviors/roborock.vacuum/S7_MAXV/a27.js';
-import { setCommandHandlerA51 } from './behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js';
-export function configurateBehavior(model, duid, roborockService, cleanModeSettings, logger) {
+import { setCommandHandlerSmart } from './behaviors/roborock.vacuum/smart/smart.js';
+export function configurateBehavior(model, duid, roborockService, cleanModeSettings, forceRunAtDefault, logger) {
+    if (forceRunAtDefault) {
+        const deviceHandler = new BehaviorDeviceGeneric(logger);
+        setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+        return deviceHandler;
+    }
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA187(duid, deviceHandler, logger, roborockService, cleanModeSettings);
-            return deviceHandler;
-        }
-        case DeviceModel.S7_MAXV: {
-            const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
-            return deviceHandler;
-        }
-        case DeviceModel.S8_PRO_ULTRA: {
-            const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA51(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            setCommandHandlerSmart(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
+        case DeviceModel.S7_MAXV:
+        case DeviceModel.S8_PRO_ULTRA:
+        case DeviceModel.S6_PURE:
         default: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
             setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);

package/dist/behaviors/roborock.vacuum/default/default.js

@@ -19,6 +19,7 @@ export var MopWaterFlow;
     MopWaterFlow[MopWaterFlow["Medium"] = 202] = "Medium";
     MopWaterFlow[MopWaterFlow["High"] = 203] = "High";
     MopWaterFlow[MopWaterFlow["Custom"] = 204] = "Custom";
+    MopWaterFlow[MopWaterFlow["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
 })(MopWaterFlow || (MopWaterFlow = {}));
 export var MopRoute;
 (function (MopRoute) {
@@ -28,50 +29,98 @@ export var MopRoute;
     MopRoute[MopRoute["DeepPlus"] = 303] = "DeepPlus";
     MopRoute[MopRoute["Fast"] = 304] = "Fast";
 })(MopRoute || (MopRoute = {}));
-const RvcRunMode = {
+export const RvcRunMode = {
     [1]: 'Idle',
     [2]: 'Cleaning',
     [3]: 'Mapping',
 };
-const RvcCleanMode = {
-    [5]: 'Mop',
-    [6]: 'Vacuum',
-    [7]: 'Vac & Mop',
-    [8]: 'Custom',
+export const RvcCleanMode = {
+    [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',
 };
-const CleanSetting = {
-    [5]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
-    [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
-    [7]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
-    [8]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom },
+export const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [6]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast },
+    [7]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [8]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard },
+    [9]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [10]: { suctionPower: VacuumSuctionPower.Custom, waterFlow: MopWaterFlow.Custom, distance_off: 0, mopRoute: MopRoute.Custom },
+    [31]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Standard },
+    [32]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.High, distance_off: 0, mopRoute: MopRoute.Standard },
+    [33]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Low, distance_off: 0, mopRoute: MopRoute.Standard },
+    [34]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Fast },
+    [35]: { suctionPower: VacuumSuctionPower.Off, waterFlow: MopWaterFlow.Medium, distance_off: 0, mopRoute: MopRoute.Deep },
+    [66]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [67]: { suctionPower: VacuumSuctionPower.Max, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [68]: { suctionPower: VacuumSuctionPower.Quiet, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Standard },
+    [69]: { suctionPower: VacuumSuctionPower.Balanced, waterFlow: MopWaterFlow.Off, distance_off: 0, mopRoute: MopRoute.Fast },
 };
 export function setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
             case 'Cleaning': {
+                logger.notice('DefaultBehavior-ChangeRunMode to: ', activity);
                 await roborockService.startClean(duid);
-                return;
+                break;
             }
-            case 'Mop':
-            case 'Vacuum':
-            case 'Vac & Mop': {
-                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+            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);
                 }
-                return;
+                break;
             }
-            case 'Custom': {
+            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)}`);
-                await roborockService.changeCleanMode(duid, setting);
-                return;
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                break;
             }
             default:
                 logger.notice('DefaultBehavior-changeToMode-Unknown: ', newMode);
-                return;
+                break;
         }
     });
     handler.setCommandHandler('selectAreas', async (newAreas) => {
@@ -94,39 +143,41 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService,
         logger.notice('DefaultBehavior-playSoundToLocate');
         await roborockService.playSoundToLocate(duid);
     });
-    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
-        switch (activity) {
-            case 'Mop': {
-                const mopSetting = cleanModeSettings?.mopping;
-                const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
-                return {
-                    suctionPower: VacuumSuctionPower.Off,
-                    waterFlow,
-                    distance_off: 0,
-                    mopRoute: MopRoute[mopSetting?.mopRouteMode] ?? MopRoute.Standard,
-                };
-            }
-            case 'Vacuum': {
-                const vacuumSetting = cleanModeSettings?.vacuuming;
-                return {
-                    suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
-                    waterFlow: MopWaterFlow.Off,
-                    distance_off: 0,
-                    mopRoute: MopRoute[vacuumSetting?.mopRouteMode] ?? MopRoute.Standard,
-                };
-            }
-            case 'Vac & Mop': {
-                const vacmopSetting = cleanModeSettings?.vacmop;
-                const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
-                return {
-                    suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
-                    waterFlow,
-                    distance_off: 0,
-                    mopRoute: MopRoute[vacmopSetting?.mopRouteMode] ?? MopRoute.Standard,
-                };
-            }
-            default:
-                return undefined;
-        }
-    };
 }
+export const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+    switch (activity) {
+        case 'Mop: Default': {
+            const mopSetting = cleanModeSettings?.mopping;
+            const waterFlow = MopWaterFlow[mopSetting?.waterFlowMode] ?? 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] ?? MopRoute.Standard,
+            };
+        }
+        case 'Vacuum: Default': {
+            const vacuumSetting = cleanModeSettings?.vacuuming;
+            return {
+                suctionPower: VacuumSuctionPower[vacuumSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                waterFlow: MopWaterFlow.Off,
+                distance_off: 0,
+                mopRoute: MopRoute[vacuumSetting?.mopRouteMode] ?? MopRoute.Standard,
+            };
+        }
+        case 'Mop & Vacuum: Default': {
+            const vacmopSetting = cleanModeSettings?.vacmop;
+            const waterFlow = MopWaterFlow[vacmopSetting?.waterFlowMode] ?? MopWaterFlow.Medium;
+            const distance_off = waterFlow == MopWaterFlow.CustomizeWithDistanceOff ? 210 - 5 * (vacmopSetting?.distanceOff ?? 25) : 0;
+            return {
+                suctionPower: VacuumSuctionPower[vacmopSetting?.fanMode] ?? VacuumSuctionPower.Balanced,
+                waterFlow,
+                distance_off,
+                mopRoute: MopRoute[vacmopSetting?.mopRouteMode] ?? MopRoute.Standard,
+            };
+        }
+        default:
+            return undefined;
+    }
+};

package/dist/behaviors/roborock.vacuum/default/initalData.js

@@ -1,4 +1,5 @@
 import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './default.js';
 export function getDefaultSupportedRunModes() {
     return [
         {
@@ -18,29 +19,95 @@ export function getDefaultSupportedRunModes() {
         },
     ];
 }
-export function getDefaultSupportedCleanModes() {
-    return [
+export function getDefaultSupportedCleanModes(enableExperimentalFeature) {
+    const result = [
         {
-            label: 'Mop',
+            label: RvcCleanModeDisplayMap[5],
             mode: 5,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
         },
         {
-            label: 'Vacuum',
+            label: RvcCleanModeDisplayMap[6],
             mode: 6,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
         },
         {
-            label: 'Mop & Vacuum',
+            label: RvcCleanModeDisplayMap[7],
             mode: 7,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Max }],
         },
         {
-            label: 'Custom',
+            label: RvcCleanModeDisplayMap[8],
             mode: 8,
-            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+            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() {
     return [

package/dist/behaviors/roborock.vacuum/default/runtimes.js

@@ -1,33 +1,21 @@
-import { MopWaterFlow, VacuumSuctionPower } from './default.js';
-export function getCurrentCleanModeDefault(fan_power, water_box_mode) {
-    if (!fan_power || !water_box_mode)
+import { CleanSetting, MopRoute, MopWaterFlow, VacuumSuctionPower } from './default.js';
+export function getCurrentCleanModeDefault(setting) {
+    if (!setting || typeof setting !== 'object') {
         return undefined;
-    if (fan_power == VacuumSuctionPower.Custom || water_box_mode == MopWaterFlow.Custom)
-        return 8;
-    if (fan_power == VacuumSuctionPower.Off)
+    }
+    if (setting.suctionPower === VacuumSuctionPower.Custom || setting.waterFlow === MopWaterFlow.Custom || setting.mopRoute === MopRoute.Custom) {
+        return 10;
+    }
+    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;
+    if (setting.waterFlow == MopWaterFlow.Off)
+        return 66;
+    if ((setting.suctionPower !== VacuumSuctionPower.Off && setting.waterFlow) !== MopWaterFlow.Off)
         return 5;
-    if (water_box_mode == MopWaterFlow.Off)
-        return 6;
-    else
-        return 7;
-}
-export function getCurrentCleanModeFromFanPowerDefault(fan_power) {
-    if (!fan_power)
-        return undefined;
-    if (fan_power == VacuumSuctionPower.Custom)
-        return 8;
-    if (fan_power == VacuumSuctionPower.Off)
-        return 5;
-    else
-        return undefined;
-}
-export function getCurrentCleanModeFromWaterBoxModeDefault(water_box_mode) {
-    if (!water_box_mode)
-        return undefined;
-    if (water_box_mode == MopWaterFlow.Custom)
-        return 8;
-    if (water_box_mode == MopWaterFlow.Off)
-        return 6;
-    else
-        return undefined;
+    return undefined;
 }

package/dist/behaviors/roborock.vacuum/smart/initalData.js

@@ -0,0 +1,18 @@
+import { RvcCleanMode } from 'matterbridge/matter/clusters';
+import { RvcCleanMode as RvcCleanModeDisplayMap } from './smart.js';
+import { getDefaultSupportedCleanModes } from '../default/initalData.js';
+export function getSupportedCleanModesSmart(enableExperimentalFeature) {
+    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),
+    ];
+}

package/dist/behaviors/roborock.vacuum/smart/runtimes.js

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

package/dist/behaviors/roborock.vacuum/smart/smart.js

@@ -0,0 +1,119 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+import { RvcCleanMode as DefaultRvcCleanMode, CleanSetting as DefaultCleanSetting, getSettingFromCleanMode, RvcRunMode } from '../default/default.js';
+export class BehaviorSmart extends BehaviorRoborock {
+}
+export var VacuumSuctionPowerSmart;
+(function (VacuumSuctionPowerSmart) {
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Max"] = 104] = "Max";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Off"] = 105] = "Off";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Custom"] = 106] = "Custom";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["MaxPlus"] = 108] = "MaxPlus";
+    VacuumSuctionPowerSmart[VacuumSuctionPowerSmart["Smart"] = 110] = "Smart";
+})(VacuumSuctionPowerSmart || (VacuumSuctionPowerSmart = {}));
+export var MopWaterFlowSmart;
+(function (MopWaterFlowSmart) {
+    MopWaterFlowSmart[MopWaterFlowSmart["Off"] = 200] = "Off";
+    MopWaterFlowSmart[MopWaterFlowSmart["Low"] = 201] = "Low";
+    MopWaterFlowSmart[MopWaterFlowSmart["Medium"] = 202] = "Medium";
+    MopWaterFlowSmart[MopWaterFlowSmart["High"] = 203] = "High";
+    MopWaterFlowSmart[MopWaterFlowSmart["Custom"] = 204] = "Custom";
+    MopWaterFlowSmart[MopWaterFlowSmart["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
+    MopWaterFlowSmart[MopWaterFlowSmart["Smart"] = 209] = "Smart";
+})(MopWaterFlowSmart || (MopWaterFlowSmart = {}));
+export var MopRouteSmart;
+(function (MopRouteSmart) {
+    MopRouteSmart[MopRouteSmart["Standard"] = 300] = "Standard";
+    MopRouteSmart[MopRouteSmart["Deep"] = 301] = "Deep";
+    MopRouteSmart[MopRouteSmart["Custom"] = 302] = "Custom";
+    MopRouteSmart[MopRouteSmart["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteSmart[MopRouteSmart["Fast"] = 304] = "Fast";
+    MopRouteSmart[MopRouteSmart["Smart"] = 306] = "Smart";
+})(MopRouteSmart || (MopRouteSmart = {}));
+export const RvcCleanMode = {
+    [4]: 'Smart Plan',
+    ...DefaultRvcCleanMode,
+};
+export const CleanSetting = {
+    [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteSmart.Smart },
+    ...DefaultCleanSetting,
+};
+export function setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        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) => {
+        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/dist/initialData/getOperationalStates.js

@@ -1,21 +1,8 @@
 import { RvcOperationalState } from 'matterbridge/matter/clusters';
-import { getOperationalStatesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
 import { getDefaultOperationalStates } from '../behaviors/roborock.vacuum/default/initalData.js';
-import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
 import { VacuumErrorCode } from '../roborockCommunication/Zenum/vacuumAndDockErrorCode.js';
-import { getOperationalStatesA27 } from '../behaviors/roborock.vacuum/S7_MAXV/initalData.js';
-import { getOperationalStatesA51 } from '../behaviors/roborock.vacuum/S8_PRO_ULTRA/initalData.js';
-export function getOperationalStates(model) {
-    switch (model) {
-        case DeviceModel.QREVO_EDGE_5V1:
-            return getOperationalStatesA187();
-        case DeviceModel.S7_MAXV:
-            return getOperationalStatesA27();
-        case DeviceModel.S8_MAXV_ULTRA:
-            return getOperationalStatesA51();
-        default:
-            return getDefaultOperationalStates();
-    }
+export function getOperationalStates() {
+    return getDefaultOperationalStates();
 }
 export function getOperationalErrorState(errorCode) {
     switch (errorCode) {