matterbridge-roborock-vacuum-plugin 1.0.8-rc01 → 1.0.8-rc03

package/.github/workflows/build.yml

@@ -0,0 +1,47 @@
+name: Build, lint and test
+
+on: [push, pull_request]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [18.x, 20.x, 22.x, 24.x]
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Clean cache
+        run: npm cache clean --force
+
+      - name: Verify Node.js version
+        run: node -v
+
+      - name: Verify Npm version
+        run: npm -v
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install dependencies
+        run: npm run precondition && npm run deepClean && npm install && npm link matterbridge
+
+      - name: Lint the project
+        run: npm run lint
+
+      - name: Test the project
+        run: npm run test
+
+      - name: Build (optional)
+        run: npm run build

package/.github/workflows/coverage.yml

@@ -0,0 +1,50 @@
+name: Analyze code coverage
+
+on: [push, pull_request]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Clean cache
+        run: npm cache clean --force
+
+      - name: Verify Node.js version
+        run: node -v
+
+      - name: Verify Npm version
+        run: npm -v
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install dependencies
+        run: npm run precondition && npm run deepClean && npm install && npm link matterbridge
+
+      - name: Lint the project
+        run: npm run lint
+
+      - name: Test the project
+        run: npm run test
+
+      - name: Test with coverage
+        run: npm run test -- --coverage
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          slug: RinDevJunior/matterbridge-roborock-vacuum-plugin
+
+      - name: Build (optional)
+        run: npm run build

package/.github/workflows/publish.yml

@@ -28,7 +28,10 @@ jobs:
       - name: Build (optional)
         run: npm run build
 
+      - name: Run tests
+        run: npm run test
+
       - name: Publish to npm
         run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -11,6 +11,12 @@
   <a href="https://www.npmjs.com/package/matterbridge-roborock-vacuum-plugin">
     <img src="https://img.shields.io/npm/dt/matterbridge-roborock-vacuum-plugin.svg" alt="npm downloads" />
   </a>
+  <a href="https://github.com/RinDevJunior/matterbridge-roborock-vacuum-plugin/actions/workflows/publish.yml/badge.svg">
+    <img src="https://github.com/RinDevJunior/matterbridge-roborock-vacuum-plugin/actions/workflows/publish.yml/badge.svg" alt="nodejs ci" />
+  </a>
+  <a href="https://codecov.io/gh/RinDevJunior/matterbridge-roborock-vacuum-plugin">
+    <img src="https://codecov.io/gh/RinDevJunior/matterbridge-roborock-vacuum-plugin/branch/main/graph/badge.svg" alt="codecov" />
+  </a>
   <a href="https://www.npmjs.com/package/matterbridge">
     <img src="https://img.shields.io/badge/powered%20by-matterbridge-blue" alt="powered by Matterbridge" />
   </a>
@@ -68,6 +74,8 @@ To get the **DUID** for your devices, you have two options:
 
 ---
 
+**➡️ [See Supported & Tested Roborock Devices](./README_SUPPORTED.md)**
+
 ### 📦 Prerequisites
 
 - A working installation of [Matterbridge](https://github.com/Luligu/matterbridge)

package/README_SUPPORTED.md

@@ -0,0 +1,54 @@
+# Supported & Tested Roborock Device Models
+
+## ✅ Tested Devices
+
+| Device Name                | Model Enum Key         | Model String                  |    Thank         |
+|----------------------------|------------------------|-------------------------------|------------------|
+| Roborock Qrevo Edge 5V1    | `QREVO_EDGE_5V1`       | `roborock.vacuum.a187`        |                  |
+| Roborock S8 Pro Ultra      | `S8_PRO_ULTRA`         | `roborock.vacuum.a70`         |                  |
+| Roborock S7 MaxV           | `S7_MAXV`              | `roborock.vacuum.a27`         |                  |
+
+These devices have been fully tested and are confirmed to work as expected.
+
+---
+
+## ⚠️ Other Supported Devices
+
+All other models listed in the code are supported, but **may have some limitations**.
+
+**Reason:**  
+I do not own these devices for direct testing.
+
+If you have one of these models, please try it out and let me know your results!
+
+---
+
+### List of Other Models that I know the mode string
+
+- Q5 (`roborock.vacuum.a34`)
+- Q5_PRO (`roborock.vacuum.a72`)
+- S5 (`roborock.vacuum.s5`)
+- S5_MAX (`roborock.vacuum.s5e`)
+- S6 (`roborock.vacuum.s6`)
+- S6_MAXV (`roborock.vacuum.a10`)
+- S6_PURE (`roborock.vacuum.a08`)
+- Q7 (`roborock.vacuum.a40`)
+- Q7_MAX (`roborock.vacuum.a38`)
+- Q7_PLUS (`roborock.vacuum.a40`)
+- S7 (`roborock.vacuum.a15`)
+- S7_MAXV_ULTRA (`roborock.vacuum.a65`)
+- S7_PRO_ULTRA (`roborock.vacuum.a62`)
+- Q8_MAX (`roborock.vacuum.a73`)
+- S8 (`roborock.vacuum.a51`)
+- S8_MAXV_ULTRA (`roborock.vacuum.a97`)
+- QREVO_MASTER (`roborock.vacuum.a117`)
+- QREVO_CURV (`roborock.vacuum.a135`)
+- QREVO_S (`roborock.vacuum.a104`)
+- QREVO_PRO (`roborock.vacuum.a101`)
+- QREVO_MAXV (`roborock.vacuum.a87`)
+- QREVO_EDGE_5AE (`roborock.vacuum.xxxx`)
+
+---
+
+> **Note:**  
+> If you have a device not listed above, feel free to try it and report your experience!

package/dist/behaviorFactory.js

@@ -3,6 +3,7 @@ import { setCommandHandlerA187 } from './behaviors/roborock.vacuum/QREVO_EDGE_5V
 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) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
@@ -15,9 +16,14 @@ export function configurateBehavior(model, duid, roborockService, cleanModeSetti
             setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
+        case DeviceModel.S8_PRO_ULTRA: {
+            const deviceHandler = new BehaviorDeviceGeneric(logger);
+            setCommandHandlerA51(duid, deviceHandler, logger, roborockService, cleanModeSettings);
+            return deviceHandler;
+        }
         default: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService);
+            setDefaultCommandHandler(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
     }

package/dist/behaviors/BehaviorDeviceGeneric.js

@@ -17,15 +17,6 @@ export class BehaviorDeviceGeneric {
         await handler(...args);
     }
 }
-export class BehaviorGeneric extends Behavior {
-    static id;
-}
 export class BehaviorRoborock extends Behavior {
     static id = 'roborock.vacuum.axx';
 }
-(function (BehaviorRoborock) {
-    class State {
-        device;
-    }
-    BehaviorRoborock.State = State;
-})(BehaviorRoborock || (BehaviorRoborock = {}));

package/dist/behaviors/roborock.vacuum/QREVO_EDGE_5V1/a187.js

@@ -2,13 +2,6 @@ import { debugStringify } from 'matterbridge/logger';
 import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
 export class BehaviorA187 extends BehaviorRoborock {
 }
-export var BehaviorRoborockA187;
-(function (BehaviorRoborockA187) {
-    class State {
-        device;
-    }
-    BehaviorRoborockA187.State = State;
-})(BehaviorRoborockA187 || (BehaviorRoborockA187 = {}));
 export var VacuumSuctionPowerA187;
 (function (VacuumSuctionPowerA187) {
     VacuumSuctionPowerA187[VacuumSuctionPowerA187["Quiet"] = 101] = "Quiet";
@@ -142,8 +135,8 @@ export function setCommandHandlerA187(duid, handler, logger, roborockService, cl
         logger.notice('BehaviorA187-GoHome');
         await roborockService.stopAndGoHome(duid);
     });
-    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
-        logger.notice('BehaviorA187-PlaySoundToLocate');
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        logger.notice('BehaviorA187-playSoundToLocate');
         await roborockService.playSoundToLocate(duid);
     });
 }

package/dist/behaviors/roborock.vacuum/S7_MAXV/a27.js

@@ -2,13 +2,6 @@ import { debugStringify } from 'matterbridge/logger';
 import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
 export class BehaviorA27 extends BehaviorRoborock {
 }
-export var BehaviorRoborockA27;
-(function (BehaviorRoborockA27) {
-    class State {
-        device;
-    }
-    BehaviorRoborockA27.State = State;
-})(BehaviorRoborockA27 || (BehaviorRoborockA27 = {}));
 export var VacuumSuctionPowerA27;
 (function (VacuumSuctionPowerA27) {
     VacuumSuctionPowerA27[VacuumSuctionPowerA27["Quiet"] = 101] = "Quiet";
@@ -133,8 +126,8 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService, cle
         logger.notice('BehaviorA27-GoHome');
         await roborockService.stopAndGoHome(duid);
     });
-    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
-        logger.notice('BehaviorA27-PlaySoundToLocate');
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        logger.notice('BehaviorA27-playSoundToLocate');
         await roborockService.playSoundToLocate(duid);
     });
 }

package/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/a51.js

@@ -0,0 +1,132 @@
+import { debugStringify } from 'matterbridge/logger';
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+export class BehaviorA51 extends BehaviorRoborock {
+}
+export var VacuumSuctionPowerA51;
+(function (VacuumSuctionPowerA51) {
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Max"] = 104] = "Max";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Off"] = 105] = "Off";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["Custom"] = 106] = "Custom";
+    VacuumSuctionPowerA51[VacuumSuctionPowerA51["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPowerA51 || (VacuumSuctionPowerA51 = {}));
+export var MopWaterFlowA51;
+(function (MopWaterFlowA51) {
+    MopWaterFlowA51[MopWaterFlowA51["Off"] = 200] = "Off";
+    MopWaterFlowA51[MopWaterFlowA51["Low"] = 201] = "Low";
+    MopWaterFlowA51[MopWaterFlowA51["Medium"] = 202] = "Medium";
+    MopWaterFlowA51[MopWaterFlowA51["High"] = 203] = "High";
+    MopWaterFlowA51[MopWaterFlowA51["Custom"] = 204] = "Custom";
+})(MopWaterFlowA51 || (MopWaterFlowA51 = {}));
+export var MopRouteA51;
+(function (MopRouteA51) {
+    MopRouteA51[MopRouteA51["Standard"] = 300] = "Standard";
+    MopRouteA51[MopRouteA51["Deep"] = 301] = "Deep";
+    MopRouteA51[MopRouteA51["Custom"] = 302] = "Custom";
+    MopRouteA51[MopRouteA51["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteA51[MopRouteA51["Fast"] = 304] = "Fast";
+})(MopRouteA51 || (MopRouteA51 = {}));
+const RvcRunMode = {
+    [1]: 'Idle',
+    [2]: 'Cleaning',
+    [3]: 'Mapping',
+};
+const RvcCleanMode = {
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
+};
+const CleanSetting = {
+    [5]: { suctionPower: VacuumSuctionPowerA51.Off, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Off, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA51.Balanced, waterFlow: MopWaterFlowA51.Medium, distance_off: 0, mopRoute: MopRouteA51.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA51.Custom, waterFlow: MopWaterFlowA51.Custom, distance_off: 0, mopRoute: MopRouteA51.Custom },
+};
+export function setCommandHandlerA51(duid, handler, logger, roborockService, cleanModeSettings) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                await roborockService.startClean(duid);
+                return;
+            }
+            case 'Mop':
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`BehaviorA51-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
+                return;
+            }
+            default:
+                logger.notice('BehaviorA51-changeToMode-Unknown: ', newMode);
+                return;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`BehaviorA51-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('BehaviorA51-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('BehaviorA51-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('BehaviorA51-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        logger.notice('BehaviorA51-playSoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA51[mopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[mopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow: MopWaterFlowA51.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacuumSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA51[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA51.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA51[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA51.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA51[vacmopSetting?.mopRouteMode] ?? MopRouteA51.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
+}

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

@@ -0,0 +1,76 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+export function getDefaultSupportedRunModes() {
+    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() {
+    return [
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Vacuum',
+            mode: 6,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            label: 'Mop & Vacuum',
+            mode: 7,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.DeepClean }],
+        },
+        {
+            label: 'Custom',
+            mode: 8,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Quick }],
+        },
+    ];
+}
+export function getDefaultOperationalStates() {
+    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/dist/behaviors/roborock.vacuum/S8_PRO_ULTRA/runtimes.js

@@ -0,0 +1,33 @@
+import { MopWaterFlowA51, VacuumSuctionPowerA51 } from './a51.js';
+export function getCurrentCleanModeA51(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom || water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerA51(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA51.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA51.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeA51(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlowA51.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlowA51.Off)
+        return 6;
+    else
+        return undefined;
+}

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

@@ -1,23 +1,51 @@
+import { debugStringify } from 'matterbridge/logger';
 import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
 export class DefaultBehavior extends BehaviorRoborock {
 }
-export var DefaultBehaviorRoborock;
-(function (DefaultBehaviorRoborock) {
-    class State {
-        device;
-    }
-    DefaultBehaviorRoborock.State = State;
-})(DefaultBehaviorRoborock || (DefaultBehaviorRoborock = {}));
+export var VacuumSuctionPower;
+(function (VacuumSuctionPower) {
+    VacuumSuctionPower[VacuumSuctionPower["Quiet"] = 101] = "Quiet";
+    VacuumSuctionPower[VacuumSuctionPower["Balanced"] = 102] = "Balanced";
+    VacuumSuctionPower[VacuumSuctionPower["Turbo"] = 103] = "Turbo";
+    VacuumSuctionPower[VacuumSuctionPower["Max"] = 104] = "Max";
+    VacuumSuctionPower[VacuumSuctionPower["Off"] = 105] = "Off";
+    VacuumSuctionPower[VacuumSuctionPower["Custom"] = 106] = "Custom";
+    VacuumSuctionPower[VacuumSuctionPower["MaxPlus"] = 108] = "MaxPlus";
+})(VacuumSuctionPower || (VacuumSuctionPower = {}));
+export var MopWaterFlow;
+(function (MopWaterFlow) {
+    MopWaterFlow[MopWaterFlow["Off"] = 200] = "Off";
+    MopWaterFlow[MopWaterFlow["Low"] = 201] = "Low";
+    MopWaterFlow[MopWaterFlow["Medium"] = 202] = "Medium";
+    MopWaterFlow[MopWaterFlow["High"] = 203] = "High";
+    MopWaterFlow[MopWaterFlow["Custom"] = 204] = "Custom";
+})(MopWaterFlow || (MopWaterFlow = {}));
+export var MopRoute;
+(function (MopRoute) {
+    MopRoute[MopRoute["Standard"] = 300] = "Standard";
+    MopRoute[MopRoute["Deep"] = 301] = "Deep";
+    MopRoute[MopRoute["Custom"] = 302] = "Custom";
+    MopRoute[MopRoute["DeepPlus"] = 303] = "DeepPlus";
+    MopRoute[MopRoute["Fast"] = 304] = "Fast";
+})(MopRoute || (MopRoute = {}));
 const RvcRunMode = {
     [1]: 'Idle',
     [2]: 'Cleaning',
     [3]: 'Mapping',
 };
 const RvcCleanMode = {
-    [4]: 'Mop',
-    [5]: 'Vacuum',
+    [5]: 'Mop',
+    [6]: 'Vacuum',
+    [7]: 'Vac & Mop',
+    [8]: 'Custom',
 };
-export function setDefaultCommandHandler(duid, handler, logger, roborockService) {
+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 function setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -26,8 +54,19 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
                 return;
             }
             case 'Mop':
-            case 'Vacuum': {
-                logger.notice('DefaultBehavior-ChangeCleanMode to: ', activity);
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
+            case 'Custom': {
+                const setting = CleanSetting[newMode];
+                logger.notice(`DefaultBehavior-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -51,8 +90,43 @@ export function setDefaultCommandHandler(duid, handler, logger, roborockService)
         logger.notice('DefaultBehavior-GoHome');
         await roborockService.stopAndGoHome(duid);
     });
-    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
-        logger.notice('DefaultBehavior-PlaySoundToLocate');
+    handler.setCommandHandler('playSoundToLocate', async () => {
+        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;
+        }
+    };
 }