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

package/dist/behaviorFactory.js

@@ -3,16 +3,16 @@ 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';
-export function configurateBehavior(model, duid, roborockService, logger) {
+export function configurateBehavior(model, duid, roborockService, cleanModeSettings, logger) {
     switch (model) {
         case DeviceModel.QREVO_EDGE_5V1: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA187(duid, deviceHandler, logger, roborockService);
+            setCommandHandlerA187(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
         case DeviceModel.S7_MAXV: {
             const deviceHandler = new BehaviorDeviceGeneric(logger);
-            setCommandHandlerA27(duid, deviceHandler, logger, roborockService);
+            setCommandHandlerA27(duid, deviceHandler, logger, roborockService, cleanModeSettings);
             return deviceHandler;
         }
         default: {

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

@@ -27,15 +27,16 @@ export var MopWaterFlowA187;
     MopWaterFlowA187[MopWaterFlowA187["Medium"] = 202] = "Medium";
     MopWaterFlowA187[MopWaterFlowA187["High"] = 203] = "High";
     MopWaterFlowA187[MopWaterFlowA187["Custom"] = 204] = "Custom";
+    MopWaterFlowA187[MopWaterFlowA187["CustomizeWithDistanceOff"] = 207] = "CustomizeWithDistanceOff";
     MopWaterFlowA187[MopWaterFlowA187["Smart"] = 209] = "Smart";
 })(MopWaterFlowA187 || (MopWaterFlowA187 = {}));
 export var MopRouteA187;
 (function (MopRouteA187) {
-    MopRouteA187[MopRouteA187["Fast"] = 304] = "Fast";
     MopRouteA187[MopRouteA187["Standard"] = 300] = "Standard";
     MopRouteA187[MopRouteA187["Deep"] = 301] = "Deep";
     MopRouteA187[MopRouteA187["Custom"] = 302] = "Custom";
     MopRouteA187[MopRouteA187["DeepPlus"] = 303] = "DeepPlus";
+    MopRouteA187[MopRouteA187["Fast"] = 304] = "Fast";
     MopRouteA187[MopRouteA187["Smart"] = 306] = "Smart";
 })(MopRouteA187 || (MopRouteA187 = {}));
 const RvcRunMode = {
@@ -51,13 +52,13 @@ const RvcCleanMode = {
     [8]: 'Custom',
 };
 const CleanSetting = {
-    [4]: { suctionPower: 0, waterFlow: 0, mopRoute: MopRouteA187.Smart },
-    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, mopRoute: MopRouteA187.Custom },
-    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, mopRoute: MopRouteA187.Custom },
-    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, mopRoute: MopRouteA187.Custom },
-    [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, mopRoute: MopRouteA187.Custom },
+    [4]: { suctionPower: 0, waterFlow: 0, distance_off: 0, mopRoute: MopRouteA187.Smart },
+    [5]: { suctionPower: VacuumSuctionPowerA187.Off, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Off, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA187.Balanced, waterFlow: MopWaterFlowA187.Medium, distance_off: 0, mopRoute: MopRouteA187.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA187.Custom, waterFlow: MopWaterFlowA187.Custom, distance_off: 0, mopRoute: MopRouteA187.Custom },
 };
-export function setCommandHandlerA187(duid, handler, logger, roborockService) {
+export function setCommandHandlerA187(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -67,20 +68,64 @@ export function setCommandHandlerA187(duid, handler, logger, roborockService) {
                 return;
             }
             case 'Smart Plan':
-            case 'Mop':
-            case 'Vacuum':
-            case 'Vac & Mop':
             case 'Custom': {
                 const setting = CleanSetting[newMode];
-                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
+                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
                 await roborockService.changeCleanMode(duid, setting);
                 return;
             }
+            case 'Mop':
+            case 'Vacuum':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA187-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
             default:
                 logger.notice('BehaviorA187-changeToMode-Unknown: ', newMode);
                 return;
         }
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA187[mopSetting?.waterFlowMode] ?? MopWaterFlowA187.Medium;
+                const distance_off = waterFlow == MopWaterFlowA187.CustomizeWithDistanceOff ? 210 - 5 * (mopSetting?.distanceOff ?? 25) : 0;
+                return {
+                    suctionPower: VacuumSuctionPowerA187.Off,
+                    waterFlow,
+                    distance_off,
+                    mopRoute: MopRouteA187[mopSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA187[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA187.Balanced,
+                    waterFlow: MopWaterFlowA187.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA187[vacuumSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA187[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA187.Medium;
+                const distance_off = waterFlow == MopWaterFlowA187.CustomizeWithDistanceOff ? 210 - 5 * (vacmopSetting?.distanceOff ?? 25) : 0;
+                return {
+                    suctionPower: VacuumSuctionPowerA187[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA187.Balanced,
+                    waterFlow,
+                    distance_off,
+                    mopRoute: MopRouteA187[vacmopSetting?.mopRouteMode] ?? MopRouteA187.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
     handler.setCommandHandler('selectAreas', async (newAreas) => {
         logger.notice(`BehaviorA187-selectAreas: ${newAreas}`);
         roborockService.setSelectedAreas(duid, newAreas ?? []);

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

@@ -47,12 +47,12 @@ const RvcCleanMode = {
     [8]: 'Custom',
 };
 const CleanSetting = {
-    [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom },
-    [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, mopRoute: MopRouteA27.Custom },
-    [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, mopRoute: MopRouteA27.Custom },
-    [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, mopRoute: MopRouteA27.Custom },
+    [5]: { suctionPower: VacuumSuctionPowerA27.Off, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [6]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Off, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [7]: { suctionPower: VacuumSuctionPowerA27.Balanced, waterFlow: MopWaterFlowA27.Medium, distance_off: 0, mopRoute: MopRouteA27.Standard },
+    [8]: { suctionPower: VacuumSuctionPowerA27.Custom, waterFlow: MopWaterFlowA27.Custom, distance_off: 0, mopRoute: MopRouteA27.Custom },
 };
-export function setCommandHandlerA27(duid, handler, logger, roborockService) {
+export function setCommandHandlerA27(duid, handler, logger, roborockService, cleanModeSettings) {
     handler.setCommandHandler('changeToMode', async (newMode) => {
         const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
         switch (activity) {
@@ -63,10 +63,18 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
             }
             case 'Mop':
             case 'Vacuum':
-            case 'Vac & Mop':
+            case 'Vac & Mop': {
+                const setting = cleanModeSettings ? getSettingFromCleanMode(activity, cleanModeSettings) : CleanSetting[newMode];
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting ?? {})}`);
+                if (setting) {
+                    await roborockService.changeCleanMode(duid, setting);
+                }
+                return;
+            }
             case 'Custom': {
                 const setting = CleanSetting[newMode];
-                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, code: ${debugStringify(setting)}`);
+                logger.notice(`BehaviorA27-ChangeCleanMode to: ${activity}, setting: ${debugStringify(setting)}`);
+                await roborockService.changeCleanMode(duid, setting);
                 return;
             }
             default:
@@ -74,6 +82,41 @@ export function setCommandHandlerA27(duid, handler, logger, roborockService) {
                 return;
         }
     });
+    const getSettingFromCleanMode = (activity, cleanModeSettings) => {
+        switch (activity) {
+            case 'Mop': {
+                const mopSetting = cleanModeSettings?.mopping;
+                const waterFlow = MopWaterFlowA27[mopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27.Off,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[mopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vacuum': {
+                const vacuumSetting = cleanModeSettings?.vacuuming;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacuumSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow: MopWaterFlowA27.Off,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacuumSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            case 'Vac & Mop': {
+                const vacmopSetting = cleanModeSettings?.vacmop;
+                const waterFlow = MopWaterFlowA27[vacmopSetting?.waterFlowMode] ?? MopWaterFlowA27.Medium;
+                return {
+                    suctionPower: VacuumSuctionPowerA27[vacmopSetting?.fanMode] ?? VacuumSuctionPowerA27.Balanced,
+                    waterFlow,
+                    distance_off: 0,
+                    mopRoute: MopRouteA27[vacmopSetting?.mopRouteMode] ?? MopRouteA27.Standard,
+                };
+            }
+            default:
+                return undefined;
+        }
+    };
     handler.setCommandHandler('selectAreas', async (newAreas) => {
         logger.notice(`BehaviorA27-selectAreas: ${newAreas}`);
         roborockService.setSelectedAreas(duid, newAreas ?? []);

package/dist/model/CleanModeSettings.js

@@ -0,0 +1,5 @@
+export class CleanModeSettings {
+    vacuuming;
+    mopping;
+    vacmop;
+}

package/dist/platform.js

@@ -91,6 +91,11 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     }
     async onConfigure() {
         await super.onConfigure();
+        if (this.config.enableExperimentalFeature) {
+            const cleanModeSettings = this.config.cleanModeSettings;
+            this.log.notice(`Experimental Feature has been enable`);
+            this.log.notice(`cleanModeSettings ${debugStringify(cleanModeSettings)}`);
+        }
         const self = this;
         this.rvcInterval = setInterval(async () => {
             self.platformRunner?.requestHomeData();
@@ -108,11 +113,15 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             this.log.error('Initializing: No supported devices found');
             return;
         }
+        let cleanModeSettings = undefined;
+        if (this.config.enableExperimentalFeature) {
+            cleanModeSettings = this.config.cleanModeSettings;
+        }
         const self = this;
         await this.roborockService.initializeMessageClientForLocal(vacuum);
         const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
-        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.log);
+        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, cleanModeSettings, this.log);
         this.roborockService.setSupportedAreas(vacuum.duid, getSupportedAreas(vacuum.rooms, roomMap, this.log));
         this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, this.log);
         this.robot.configurateHandler(behaviorHandler);

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -14,8 +14,8 @@ export class AbstractClient {
     logger;
     constructor(logger, context) {
         this.context = context;
-        this.serializer = new MessageSerializer(this.context);
-        this.deserializer = new MessageDeserializer(this.context);
+        this.serializer = new MessageSerializer(this.context, logger);
+        this.deserializer = new MessageDeserializer(this.context, logger);
         this.syncMessageListener = new SyncMessageListener(logger);
         this.messageListeners.register(this.syncMessageListener);
         this.logger = logger;

package/dist/roborockCommunication/broadcast/client/LocalNetworkClient.js

@@ -87,31 +87,31 @@ export class LocalNetworkClient extends AbstractClient {
         }
         try {
             this.buffer.append(message);
-            const recvBuffer = this.buffer.get();
-            if (!this.isMessageComplete(recvBuffer)) {
+            const receivedBuffer = this.buffer.get();
+            if (!this.isMessageComplete(receivedBuffer)) {
                 return;
             }
             this.buffer.reset();
             let offset = 0;
-            while (offset + 4 <= recvBuffer.length) {
-                const segmentLength = recvBuffer.readUInt32BE(offset);
+            while (offset + 4 <= receivedBuffer.length) {
+                const segmentLength = receivedBuffer.readUInt32BE(offset);
                 if (segmentLength == 17) {
                     offset += 4 + segmentLength;
                     continue;
                 }
                 try {
-                    const currentBuffer = recvBuffer.subarray(offset + 4, offset + segmentLength + 4);
+                    const currentBuffer = receivedBuffer.subarray(offset + 4, offset + segmentLength + 4);
                     const response = this.deserializer.deserialize(this.duid, currentBuffer);
                     await this.messageListeners.onMessage(response);
                 }
                 catch (error) {
-                    this.logger.error('unable to process message: ' + error);
+                    this.logger.error('LocalNetworkClient: unable to process message with error: ' + error);
                 }
                 offset += 4 + segmentLength;
             }
         }
         catch (error) {
-            this.logger.error('failed to read from a socket: ' + error);
+            this.logger.error('LocalNetworkClient: read socket buffer error: ' + error);
         }
     }
     isMessageComplete(buffer) {

package/dist/roborockCommunication/broadcast/client/MQTTClient.js

@@ -97,7 +97,7 @@ export class MQTTClient extends AbstractClient {
             await this.messageListeners.onMessage(response);
         }
         catch (error) {
-            this.logger.error('unable to process message from queue ' + topic + ': ' + error);
+            this.logger.error('MQTTClient: unable to process message with error: ' + topic + ': ' + error);
         }
     }
 }

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -63,25 +63,39 @@ export class MessageProcessor {
         const request = new RequestMessage(def);
         return this.client.send(duid, request);
     }
-    async getCustomMessage(duid, def) {
-        const response = this.client.get(duid, def);
-        this.logger?.warn('XXXXXXX: ', debugStringify(response));
-        return response;
+    getCustomMessage(duid, def) {
+        return this.client.get(duid, def);
     }
     async findMyRobot(duid) {
         const request = new RequestMessage({ method: 'find_me' });
         return this.client.send(duid, request);
     }
-    async changeCleanMode(duid, suctionPower, waterFlow, mopRoute) {
-        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}`);
-        if (mopRoute && mopRoute != 0) {
-            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+    async changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off) {
+        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}, mopRoute: ${mopRoute}, distance_off: ${distance_off}`);
+        const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_custom_mode' }));
+        const smartMopMode = 110;
+        const smartMopRoute = 306;
+        const customMopMode = 106;
+        const customMopRoute = 302;
+        if (currentMopMode == smartMopMode && mopRoute == smartMopRoute)
+            return;
+        if (currentMopMode == customMopMode && mopRoute == customMopRoute)
+            return;
+        if (currentMopMode == smartMopMode) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [customMopRoute] }));
         }
         if (suctionPower && suctionPower != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_custom_mode', params: [suctionPower] }));
         }
-        if (waterFlow && waterFlow != 0) {
+        const CustomizeWithDistanceOff = 207;
+        if (waterFlow && waterFlow == CustomizeWithDistanceOff && distance_off && distance_off != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: { 'water_box_mode': waterFlow, 'distance_off': distance_off } }));
+        }
+        else if (waterFlow && waterFlow != 0) {
             await this.client.send(duid, new RequestMessage({ method: 'set_water_box_custom_mode', params: [waterFlow] }));
         }
+        if (mopRoute && mopRoute != 0) {
+            await this.client.send(duid, new RequestMessage({ method: 'set_mop_mode', params: [mopRoute] }));
+        }
     }
 }

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -7,10 +7,12 @@ import { CryptoUtils, MessageUtils } from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
 export class MessageDeserializer {
     context;
-    mqttMessageParser;
-    constructor(context) {
+    messageParser;
+    logger;
+    constructor(context, logger) {
         this.context = context;
-        this.mqttMessageParser = new Parser()
+        this.logger = logger;
+        this.messageParser = new Parser()
             .endianess('big')
             .string('version', {
             length: 3,
@@ -31,13 +33,13 @@ export class MessageDeserializer {
             throw new Error('unknown protocol version ' + version);
         }
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
-        const expectedCrc32 = message.readUint32BE(message.length - 4);
+        const expectedCrc32 = message.readUInt32BE(message.length - 4);
         if (crc32 != expectedCrc32) {
-            return new ResponseMessage(duid, { dps: { id: 0, result: null } });
+            throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
         }
         const localKey = this.context.getLocalKey(duid);
         assert(localKey, 'unable to retrieve local key for ' + duid);
-        const data = this.mqttMessageParser.parse(message);
+        const data = this.messageParser.parse(message);
         if (version == '1.0') {
             const aesKey = CryptoUtils.md5bin(MessageUtils.encodeTimestamp(data.timestamp) + localKey + MessageUtils.SALT);
             const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
@@ -55,6 +57,7 @@ export class MessageDeserializer {
             return this.deserializeProtocolRpcResponse(duid, data);
         }
         else {
+            this.logger.error('unknown protocol: ' + data.protocol);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
     }

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -3,10 +3,12 @@ import crypto from 'crypto';
 import CRC32 from 'crc-32';
 export class MessageSerializer {
     context;
+    logger;
     seq = 1;
     random = 4711;
-    constructor(context) {
+    constructor(context, logger) {
         this.context = context;
+        this.logger = logger;
     }
     serialize(duid, request) {
         const messageId = request.messageId;

package/dist/roborockService.js

@@ -48,9 +48,9 @@ export default class RoborockService {
     getSupportedAreas(duid) {
         return this.supportedAreas.get(duid);
     }
-    async changeCleanMode(duid, { suctionPower, waterFlow, mopRoute }) {
+    async changeCleanMode(duid, { suctionPower, waterFlow, distance_off, mopRoute }) {
         this.logger.notice('changeCleanMode');
-        return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute);
+        return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
     }
     async startClean(duid) {
         const areas = this.supportedAreas.get(duid);
@@ -89,6 +89,9 @@ export default class RoborockService {
         this.logger.debug('customGetInSecure-message', method);
         return this.getMessageProcessor()?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
     }
+    async customSend(duid, request) {
+        return this.getMessageProcessor()?.sendCustomMessage(duid, request);
+    }
     stopService() {
         if (this.messageClient) {
             this.messageClient.disconnect();

package/dist/share/function.js

@@ -63,12 +63,6 @@ export function state_to_matter_operational_status(state) {
         case OperationStatusCode.ZoneCleanMopCleaning:
         case OperationStatusCode.ZoneCleanMopMopping:
         case OperationStatusCode.RobotStatusMopping:
-        case OperationStatusCode.WashingTheMop:
-        case OperationStatusCode.WashingTheMop2:
-        case OperationStatusCode.ReturnToDock:
-        case OperationStatusCode.GoingToWashTheMop:
-        case OperationStatusCode.BackToDockWashingDuster:
-        case OperationStatusCode.EmptyingDustContainer:
             return RvcOperationalState.OperationalState.Running;
         case OperationStatusCode.InError:
         case OperationStatusCode.ChargingError:
@@ -82,7 +76,13 @@ export function state_to_matter_operational_status(state) {
         case OperationStatusCode.ShuttingDown:
         case OperationStatusCode.Locked:
             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:

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.0.7-rc03",
+  "version": "1.0.8-rc01",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,

package/matterbridge-roborock-vacuum-plugin.schema.json

@@ -1,8 +1,8 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.0.7-rc03 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.0.8-rc01 by https://github.com/RinDevJunior",
   "type": "object",
-  "required": [],
+  "required": ["username", "password"],
   "properties": {
     "name": {
       "description": "Plugin name",
@@ -17,7 +17,7 @@
       "ui:widget": "hidden"
     },
     "whiteList": {
-      "description": "(ONLY SET IF YOU HAVE MULTIPLE VACUUMS) Only THE FIRST ONE device with DUID in the list will be exposed. If the list is empty, THE FIRST device will be exposed.",
+      "description": "(ONLY SET IF YOU HAVE MULTIPLE VACUUMS) Only THE FIRST ONE device with <Name>-<duid> in the list will be exposed. If the list is empty, THE FIRST device will be exposed.",
       "type": "array",
       "items": {
         "type": "string"
@@ -31,7 +31,8 @@
     },
     "password": {
       "description": "Roborock password (required for the plugin to work)",
-      "type": "string"
+      "type": "string",
+      "ui:widget": "password"
     },
     "refreshInterval": {
       "description": "Refresh interval in seconds (default: 60)",
@@ -43,6 +44,103 @@
       "type": "boolean",
       "default": false
     },
+    "cleanModeSettings": {
+      "description": "Configure default cleaning parameters for vacuum.",
+      "type": "object",
+      "properties": {
+        "vacuuming": {
+          "description": "Vacuuming only",
+          "type": "object",
+          "properties": {
+            "fanMode": {
+              "type": "string",
+              "description": "Suction power mode to use in Vacuuming only mode (e.g., 'Quiet', 'Balanced', 'Turbo', 'Max', 'MaxPlus').",
+              "default": "Balanced"
+            },
+            "mopRouteMode": {
+              "type": "string",
+              "description": "Mop route intensity to use in Vacuuming only mode (e.g., 'Standard', 'Deep', 'DeepPlus', 'Fast').",
+              "default": "Standard"
+            }
+          }
+        },
+        "mopping": {
+          "description": "Mopping only",
+          "type": "object",
+          "properties": {
+            "waterFlowMode": {
+              "type": "string",
+              "description": "Water flow mode to use in Mopping only mode (e.g., 'Low', 'Medium', 'High', 'CustomizeWithDistanceOff').",
+              "default": "Medium"
+            },
+            "mopRouteMode": {
+              "type": "string",
+              "description": "Mop route intensity to use in Mopping only mode (e.g., 'Standard', 'Deep', 'DeepPlus', 'Fast').",
+              "default": "Standard"
+            }
+          },
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "waterFlowMode": { "const": "CustomizeWithDistanceOff" }
+                }
+              },
+              "then": {
+                "properties": {
+                  "distanceOff": {
+                    "type": "number",
+                    "description": "Distance Off - Default = 25",
+                    "default": 25
+                  }
+                },
+                "required": ["distanceOff"]
+              }
+            }
+          ]
+        },
+        "vacmop": {
+          "description": "Vacuuming and Mopping",
+          "type": "object",
+          "properties": {
+            "fanMode": {
+              "type": "string",
+              "description": "Suction power mode to use in Vacuuming and Mopping mode (e.g., 'Quiet', 'Balanced', 'Turbo', 'Max', 'MaxPlus').",
+              "default": "Balanced"
+            },
+            "waterFlowMode": {
+              "type": "string",
+              "description": "Water flow mode to use in Vacuuming and Mopping mode (e.g., 'Low', 'Medium', 'High', 'CustomizeWithDistanceOff').",
+              "default": "Medium"
+            },
+            "mopRouteMode": {
+              "type": "string",
+              "description": "Mop route intensity to use in Vacuuming and Mopping mode (e.g., 'Standard', 'Deep', 'DeepPlus', 'Fast').",
+              "default": "Standard"
+            }
+          },
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "waterFlowMode": { "const": "CustomizeWithDistanceOff" }
+                }
+              },
+              "then": {
+                "properties": {
+                  "distanceOff": {
+                    "type": "number",
+                    "description": "Distance Off - Default = 25",
+                    "default": 25
+                  }
+                },
+                "required": ["distanceOff"]
+              }
+            }
+          ]
+        }
+      }
+    },
     "debug": {
       "description": "Enable the debug for the plugin (development only)",
       "type": "boolean",
@@ -53,5 +151,20 @@
       "type": "boolean",
       "default": false
     }
-  }
+  },
+  "dependencies": {
+    "cleanModeSettings": ["enableExperimentalFeature"]
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "enableExperimentalFeature": { "const": false } }
+      },
+      "then": {
+        "properties": {
+          "cleanModeSettings": false
+        }
+      }
+    }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.0.7-rc03",
+  "version": "1.0.8-rc01",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",