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

package/dist/runtimes/handleLocalMessage.js

@@ -0,0 +1,169 @@
+import { PowerSource, RvcCleanMode, RvcOperationalState, RvcRunMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { state_to_matter_state } from '../share/function.js';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { getRoomMap } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { getBatteryState, getBatteryStatus } from '../initialData/index.js';
+import { getCurrentCleanModeFunc } from '../share/runtimeHelper.js';
+import { hasDockingStationError, parseDockingStationStatus } from '../model/DockingStationStatus.js';
+export async function handleLocalMessage(data, platform, duid = '') {
+    const robot = platform.robots.get(duid);
+    if (!robot) {
+        platform.log.error(`Robot with DUID ${duid} not found.`);
+        return;
+    }
+    const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+    const roomIndexMap = platform.roborockService?.getSupportedAreasIndexMap(duid);
+    const roomMap = await getRoomMap(duid, platform);
+    platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+    platform.log.debug(`Current mapped areas: ${currentMappedAreas ? debugStringify(currentMappedAreas) : 'undefined'}`);
+    platform.log.debug(`RoomIndexMap:
+    `, roomIndexMap);
+    const deviceData = robot.device.data;
+    const state = state_to_matter_state(data.state);
+    if (state) {
+        robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
+    }
+    if (data.state === OperationStatusCode.Idle) {
+        const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
+        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
+    }
+    if (state === RvcRunMode.ModeTag.Cleaning && !data.cleaning_info) {
+        platform.log.debug('No cleaning_info, setting currentArea to null');
+        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+    }
+    else {
+        const isMultipleMapEnable = platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap;
+        if (isMultipleMapEnable) {
+            await mapRoomsToAreasFeatureOn(platform, duid, data);
+        }
+        else {
+            await mapRoomsToAreasFeatureOff(platform, duid, data);
+        }
+    }
+    if (data.battery) {
+        const batteryLevel = data.battery;
+        robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
+        robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(data.state, data.battery), platform.log);
+        robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+    }
+    const currentCleanModeSetting = {
+        suctionPower: data.cleaning_info?.fan_power ?? data.fan_power,
+        waterFlow: data.cleaning_info?.water_box_status ?? data.water_box_mode,
+        distance_off: data.distance_off,
+        mopRoute: data.cleaning_info?.mop_mode ?? data.mop_mode,
+        segment_id: data.cleaning_info?.segment_id,
+        target_segment_id: data.cleaning_info?.target_segment_id,
+    };
+    platform.log.debug(`data: ${debugStringify(data)}`);
+    platform.log.notice(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
+    if (currentCleanModeSetting.mopRoute && currentCleanModeSetting.suctionPower && currentCleanModeSetting.waterFlow) {
+        const currentCleanMode = getCurrentCleanModeFunc(deviceData.model, platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)(currentCleanModeSetting);
+        platform.log.debug(`Current clean mode: ${currentCleanMode}`);
+        if (currentCleanMode) {
+            robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+        }
+    }
+    processAdditionalProps(robot, data, duid, platform);
+}
+export function triggerDssError(robot, platform) {
+    const currentOperationState = robot.getAttribute(RvcOperationalState.Cluster.id, 'operationalState');
+    if (currentOperationState === RvcOperationalState.OperationalState.Error) {
+        return true;
+    }
+    if (currentOperationState === RvcOperationalState.OperationalState.Docked) {
+        robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
+        return true;
+    }
+    return false;
+}
+async function processAdditionalProps(robot, message, duid, platform) {
+    const dssStatus = getDssStatus(message, duid, platform);
+    if (dssStatus) {
+        triggerDssError(robot, platform);
+    }
+}
+function getDssStatus(message, duid, platform) {
+    const robot = platform.robots.get(duid);
+    if (robot === undefined) {
+        platform.log.error(`Error4: Robot with DUID ${duid} not found`);
+        return undefined;
+    }
+    if (platform.enableExperimentalFeature &&
+        platform.enableExperimentalFeature.enableExperimentalFeature &&
+        platform.enableExperimentalFeature.advancedFeature.includeDockStationStatus &&
+        message.dss !== undefined) {
+        const dss = parseDockingStationStatus(message.dss);
+        if (dss && robot) {
+            robot.dockStationStatus = dss;
+        }
+        if (dss && hasDockingStationError(dss)) {
+            return RvcOperationalState.OperationalState.Error;
+        }
+    }
+    return undefined;
+}
+async function mapRoomsToAreasFeatureOff(platform, duid, data) {
+    const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+    const robot = platform.robots.get(duid);
+    if (!robot) {
+        platform.log.error(`Robot with DUID ${duid} not found.`);
+        return;
+    }
+    if (!data.cleaning_info) {
+        return;
+    }
+    const source_segment_id = data.cleaning_info.segment_id ?? -1;
+    const source_target_segment_id = data.cleaning_info.target_segment_id ?? -1;
+    const segment_id = source_segment_id !== -1 ? source_segment_id : source_target_segment_id;
+    const mappedArea = currentMappedAreas?.find((x) => x.areaId == segment_id);
+    platform.log.debug(`mappedArea:
+    source_segment_id: ${source_segment_id},
+    source_target_segment_id: ${source_target_segment_id},
+    segment_id: ${segment_id},
+    result: ${mappedArea ? debugStringify(mappedArea) : 'undefined'}
+    `);
+    if (segment_id !== -1 && mappedArea) {
+        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', segment_id, platform.log);
+    }
+    if (segment_id == -1) {
+        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+    }
+}
+async function mapRoomsToAreasFeatureOn(platform, duid, data) {
+    const robot = platform.robots.get(duid);
+    if (!robot) {
+        platform.log.error(`Robot with DUID ${duid} not found.`);
+        return;
+    }
+    if (!data.cleaning_info) {
+        return;
+    }
+    const currentMappedAreas = platform.roborockService?.getSupportedAreas(duid);
+    const roomIndexMap = platform.roborockService?.getSupportedAreasIndexMap(duid);
+    const source_segment_id = data.cleaning_info.segment_id ?? -1;
+    const source_target_segment_id = data.cleaning_info.target_segment_id ?? -1;
+    const segment_id = source_segment_id !== -1 ? source_segment_id : source_target_segment_id;
+    const areaId = roomIndexMap?.getAreaId(segment_id, 0);
+    if (!areaId) {
+        platform.log.debug(`
+      source_segment_id: ${source_segment_id}, 
+      source_target_segment_id: ${source_target_segment_id}, 
+      segment_id: ${segment_id}, 
+      areaId: ${areaId}`);
+        return;
+    }
+    const mappedArea = currentMappedAreas?.find((x) => x.areaId == areaId);
+    platform.log.debug(`mappedArea:
+    source_segment_id: ${source_segment_id},
+    source_target_segment_id: ${source_target_segment_id},
+    segment_id: ${segment_id},
+    areaId: ${areaId},
+    result: ${mappedArea ? debugStringify(mappedArea) : 'undefined'}
+    `);
+    if (areaId !== -1 && mappedArea) {
+        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log);
+    }
+}

package/dist/rvc.js

@@ -0,0 +1,51 @@
+import { RoboticVacuumCleaner } from 'matterbridge/devices';
+import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
+import { debugStringify } from 'matterbridge/logger';
+import { RvcOperationalState } from 'matterbridge/matter/clusters';
+export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
+    username;
+    device;
+    roomInfo;
+    dockStationStatus;
+    constructor(username, device, roomMap, routineAsRoom, enableExperimentalFeature, log) {
+        const cleanModes = getSupportedCleanModes(device.data.model, enableExperimentalFeature);
+        const supportedRunModes = getSupportedRunModes();
+        const enableMultipleMap = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableMultipleMap;
+        const { supportedAreas, supportedMaps } = getSupportedAreas(device.rooms, roomMap, enableMultipleMap, log);
+        const supportedAreaAndRoutines = [...supportedAreas, ...routineAsRoom];
+        const deviceName = `${device.name}-${device.duid}`.replace(/\s+/g, '');
+        log.debug(`Creating RoborockVacuumCleaner for device: ${deviceName}, model: ${device.data.model}, forceRunAtDefault: ${enableExperimentalFeature?.advancedFeature?.forceRunAtDefault}`);
+        log.debug(`Supported Clean Modes: ${JSON.stringify(cleanModes)}`);
+        log.debug(`Supported Run Modes: ${JSON.stringify(supportedRunModes)}`);
+        log.debug(`Supported Areas: ${JSON.stringify(supportedAreas)}`);
+        log.debug(`Supported Maps: ${JSON.stringify(supportedMaps)}`);
+        const bridgeMode = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableServerMode ? 'server' : undefined;
+        super(deviceName, device.duid, bridgeMode, supportedRunModes[0].mode, supportedRunModes, cleanModes[0].mode, cleanModes, undefined, undefined, RvcOperationalState.OperationalState.Docked, getOperationalStates(), supportedAreaAndRoutines, undefined, supportedAreas[0].areaId, supportedMaps);
+        this.username = username;
+        this.device = device;
+    }
+    configurateHandler(behaviorHandler) {
+        this.addCommandHandler('identify', async ({ request, cluster, attributes, endpoint }) => {
+            this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${debugStringify(attributes)}, request: ${JSON.stringify(request)}`);
+            behaviorHandler.executeCommand('playSoundToLocate', request.identifyTime ?? 0);
+        });
+        this.addCommandHandler('selectAreas', async ({ request }) => {
+            const { newAreas } = request;
+            this.log.info(`Selecting areas: ${newAreas?.join(', ')}`);
+            behaviorHandler.executeCommand('selectAreas', newAreas);
+        });
+        this.addCommandHandler('changeToMode', async ({ request }) => {
+            const { newMode } = request;
+            behaviorHandler.executeCommand('changeToMode', newMode);
+        });
+        this.addCommandHandler('pause', async () => {
+            behaviorHandler.executeCommand('pause');
+        });
+        this.addCommandHandler('resume', async () => {
+            behaviorHandler.executeCommand('resume');
+        });
+        this.addCommandHandler('goHome', async () => {
+            behaviorHandler.executeCommand('goHome');
+        });
+    }
+}

package/dist/settings.js

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

package/dist/share/function.js

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

package/dist/share/runtimeHelper.js

@@ -0,0 +1,17 @@
+import { getCurrentCleanModeDefault } from '../behaviors/roborock.vacuum/default/runtimes.js';
+import { getCurrentCleanModeSmart } from '../behaviors/roborock.vacuum/smart/runtimes.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+export function getCurrentCleanModeFunc(model, forceRunAtDefault) {
+    if (forceRunAtDefault) {
+        return getCurrentCleanModeDefault;
+    }
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1:
+            return getCurrentCleanModeSmart;
+        case DeviceModel.S7_MAXV:
+        case DeviceModel.S8_PRO_ULTRA:
+        case DeviceModel.S6_PURE:
+        default:
+            return getCurrentCleanModeDefault;
+    }
+}