matterbridge-roborock-vacuum-plugin 1.0.5

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

@@ -0,0 +1,81 @@
+import { RvcCleanMode, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+export function getSupportedRunModesA187() {
+    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 getSupportedCleanModesA187() {
+    return [
+        {
+            label: 'Smart Plan',
+            mode: 4,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }, { value: RvcCleanMode.ModeTag.Vacuum }, { value: RvcCleanMode.ModeTag.Auto }],
+        },
+        {
+            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 getOperationalStatesA187() {
+    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/QREVO_EDGE_5V1/runtimes.js

@@ -0,0 +1,39 @@
+import { MopWaterFlowA187, VacuumSuctionPowerA187 } from './a187.js';
+export function getCurrentCleanModeA187(fan_power, water_box_mode) {
+    if (!fan_power || !water_box_mode)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA187.Smart || water_box_mode == MopWaterFlowA187.Smart)
+        return 4;
+    if (fan_power == VacuumSuctionPowerA187.Custom || water_box_mode == MopWaterFlowA187.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA187.Off)
+        return 5;
+    if (water_box_mode == MopWaterFlowA187.Off)
+        return 6;
+    else
+        return 7;
+}
+export function getCurrentCleanModeFromFanPowerA187(fan_power) {
+    if (!fan_power)
+        return undefined;
+    if (fan_power == VacuumSuctionPowerA187.Smart)
+        return 4;
+    if (fan_power == VacuumSuctionPowerA187.Custom)
+        return 8;
+    if (fan_power == VacuumSuctionPowerA187.Off)
+        return 5;
+    else
+        return undefined;
+}
+export function getCurrentCleanModeFromWaterBoxModeA187(water_box_mode) {
+    if (!water_box_mode)
+        return undefined;
+    if (water_box_mode == MopWaterFlowA187.Smart)
+        return 4;
+    if (water_box_mode == MopWaterFlowA187.Custom)
+        return 8;
+    if (water_box_mode == MopWaterFlowA187.Off)
+        return 6;
+    else
+        return undefined;
+}

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

@@ -0,0 +1,58 @@
+import { BehaviorRoborock } from '../../BehaviorDeviceGeneric.js';
+export class DefaultBehavior extends BehaviorRoborock {
+}
+export var DefaultBehaviorRoborock;
+(function (DefaultBehaviorRoborock) {
+    class State {
+        device;
+    }
+    DefaultBehaviorRoborock.State = State;
+})(DefaultBehaviorRoborock || (DefaultBehaviorRoborock = {}));
+const RvcRunMode = {
+    [1]: 'Idle',
+    [2]: 'Cleaning',
+    [3]: 'Mapping',
+};
+const RvcCleanMode = {
+    [4]: 'Mop',
+    [5]: 'Vacuum',
+};
+export function setDefaultCommandHandler(duid, handler, logger, roborockService) {
+    handler.setCommandHandler('changeToMode', async (newMode) => {
+        const activity = RvcRunMode[newMode] || RvcCleanMode[newMode];
+        switch (activity) {
+            case 'Cleaning': {
+                await roborockService.startClean(duid);
+                return;
+            }
+            case 'Mop':
+            case 'Vacuum': {
+                logger.notice('DefaultBehavior-ChangeCleanMode to: ', activity);
+                return;
+            }
+            default:
+                logger.notice('DefaultBehavior-changeToMode-Unknown: ', newMode);
+                return;
+        }
+    });
+    handler.setCommandHandler('selectAreas', async (newAreas) => {
+        logger.notice(`DefaultBehavior-selectAreas: ${newAreas}`);
+        roborockService.setSelectedAreas(duid, newAreas ?? []);
+    });
+    handler.setCommandHandler('pause', async () => {
+        logger.notice('DefaultBehavior-Pause');
+        await roborockService.pauseClean(duid);
+    });
+    handler.setCommandHandler('resume', async () => {
+        logger.notice('DefaultBehavior-Resume');
+        await roborockService.resumeClean(duid);
+    });
+    handler.setCommandHandler('goHome', async () => {
+        logger.notice('DefaultBehavior-GoHome');
+        await roborockService.stopAndGoHome(duid);
+    });
+    handler.setCommandHandler('PlaySoundToLocate', async (identifyTime) => {
+        logger.notice('DefaultBehavior-PlaySoundToLocate');
+        await roborockService.playSoundToLocate(duid);
+    });
+}

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

@@ -0,0 +1,66 @@
+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: 'Vacuum',
+            mode: 4,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }],
+        },
+        {
+            label: 'Mop',
+            mode: 5,
+            modeTags: [{ value: RvcCleanMode.ModeTag.Mop }],
+        },
+    ];
+}
+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/clientManager.js

@@ -0,0 +1,17 @@
+import { ClientRouter } from './roborockCommunication/broadcast/clientRouter.js';
+export default class ClientManager {
+    clients = new Map();
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    get(username, userdata) {
+        if (!this.clients.has(username)) {
+            this.clients.set(username, new ClientRouter(this.logger, userdata));
+        }
+        return this.clients.get(username);
+    }
+    destroy(username) {
+        this.clients.delete(username);
+    }
+}

package/dist/extensions/AxiosStaticExtensions.js

@@ -0,0 +1,22 @@
+import axios from 'axios';
+axios.interceptRequestAndResponse = function (logger) {
+    this.interceptors.request.use((request) => {
+        logger.debug('Axios Request:', {
+            method: request.method,
+            url: request.url,
+            data: request.data,
+            headers: request.headers,
+        });
+        return request;
+    });
+    this.interceptors.response.use((response) => {
+        logger.debug('Axios Response:', {
+            status: response.status,
+            data: response.data,
+            headers: response.headers,
+            url: response.config.url,
+        });
+        return response;
+    });
+    return this;
+};

package/dist/extensions/index.js

@@ -0,0 +1 @@
+import './AxiosStaticExtensions.js';

package/dist/helper.js

@@ -0,0 +1,16 @@
+export function getVacuumProperty(device, property) {
+    if (device) {
+        const schemas = device.schema;
+        const schema = schemas.find((sch) => sch.code == property);
+        if (schema && device.deviceStatus && device.deviceStatus[schema.id] != undefined) {
+            return Number(device.deviceStatus[schema.id]);
+        }
+        if (device.deviceStatus && device.deviceStatus[property] != undefined) {
+            return Number(device.deviceStatus[property]);
+        }
+    }
+    return undefined;
+}
+export function isSupportedDevice(model) {
+    return model.startsWith('roborock.vacuum.');
+}

package/dist/index.js

@@ -0,0 +1,4 @@
+import { RoborockMatterbridgePlatform } from './platform.js';
+export default function initializePlugin(matterbridge, log, config) {
+    return new RoborockMatterbridgePlatform(matterbridge, log, config);
+}

package/dist/initialData/getBatteryStatus.js

@@ -0,0 +1,24 @@
+import { PowerSource } from 'matterbridge/matter/clusters';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+export function getBatteryStatus(batteryLevel) {
+    if (batteryLevel === undefined)
+        return PowerSource.BatChargeLevel.Ok;
+    if (batteryLevel >= 70) {
+        return PowerSource.BatChargeLevel.Ok;
+    }
+    else if (batteryLevel >= 40) {
+        return PowerSource.BatChargeLevel.Warning;
+    }
+    else {
+        return PowerSource.BatChargeLevel.Critical;
+    }
+}
+export function getBatteryState(deviceState, batRemaining) {
+    if (deviceState == OperationStatusCode.Charging) {
+        return batRemaining < 100 ? PowerSource.BatChargeState.IsCharging : PowerSource.BatChargeState.IsAtFullCharge;
+    }
+    if (deviceState == OperationStatusCode.ChargingError) {
+        return PowerSource.BatChargeState.IsNotCharging;
+    }
+    return PowerSource.BatChargeState.IsAtFullCharge;
+}

package/dist/initialData/getOperationalStates.js

@@ -0,0 +1,22 @@
+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';
+export function getOperationalStates(model) {
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1:
+            return getOperationalStatesA187();
+        default:
+            return getDefaultOperationalStates();
+    }
+}
+export function getOperationalErrorState(errorCode) {
+    switch (errorCode) {
+        case VacuumErrorCode.None:
+            return undefined;
+        default: {
+            return RvcOperationalState.OperationalState.Error;
+        }
+    }
+}

package/dist/initialData/getSupportedAreas.js

@@ -0,0 +1,69 @@
+export function getSupportedAreas(rooms, roomMap, log) {
+    log?.debug('getSupportedAreas', JSON.stringify(rooms));
+    log?.debug('getSupportedAreas', JSON.stringify(roomMap));
+    if (!rooms || rooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
+        log?.error('No rooms found');
+        return [
+            {
+                areaId: 1,
+                mapId: null,
+                areaInfo: {
+                    locationInfo: {
+                        locationName: 'Unknown',
+                        floorNumber: null,
+                        areaType: null,
+                    },
+                    landmarkInfo: null,
+                },
+            },
+        ];
+    }
+    const supportedAreas = rooms.map((room, index) => {
+        return {
+            areaId: roomMap.getRoomId(room.id) ?? index + 1,
+            mapId: null,
+            areaInfo: {
+                locationInfo: {
+                    locationName: room.name,
+                    floorNumber: null,
+                    areaType: null,
+                },
+                landmarkInfo: null,
+            },
+        };
+    });
+    const duplicated = findDuplicatedAreaIds(supportedAreas, log);
+    return duplicated
+        ? [
+            {
+                areaId: 1,
+                mapId: null,
+                areaInfo: {
+                    locationInfo: {
+                        locationName: 'Unknown',
+                        floorNumber: null,
+                        areaType: null,
+                    },
+                    landmarkInfo: null,
+                },
+            },
+        ]
+        : supportedAreas;
+}
+function findDuplicatedAreaIds(areas, log) {
+    const seen = new Set();
+    const duplicates = [];
+    for (const area of areas) {
+        if (seen.has(area.areaId)) {
+            duplicates.push(area.areaId);
+        }
+        else {
+            seen.add(area.areaId);
+        }
+    }
+    if (duplicates.length > 0 && log) {
+        const duplicated = areas.filter((x) => duplicates.includes(x.areaId));
+        log.error(`Duplicated areaId(s) found: ${JSON.stringify(duplicated)}`);
+    }
+    return duplicates.length > 0;
+}

package/dist/initialData/getSupportedCleanModes.js

@@ -0,0 +1,11 @@
+import { getSupportedCleanModesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
+import { getDefaultSupportedCleanModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+export function getSupportedCleanModes(model) {
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1:
+            return getSupportedCleanModesA187();
+        default:
+            return getDefaultSupportedCleanModes();
+    }
+}

package/dist/initialData/getSupportedRunModes.js

@@ -0,0 +1,18 @@
+import { getSupportedRunModesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
+import { getDefaultSupportedRunModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+export function getRunningMode(model, modeTag) {
+    if (!model || !modeTag)
+        return null;
+    const supportedMode = getSupportedRunModes(model);
+    const runningMode = supportedMode.find((s) => s.modeTags.some((mt) => mt.value === modeTag));
+    return runningMode?.mode ?? null;
+}
+export function getSupportedRunModes(model) {
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1:
+            return getSupportedRunModesA187();
+        default:
+            return getDefaultSupportedRunModes();
+    }
+}

package/dist/initialData/index.js

@@ -0,0 +1,5 @@
+export { getSupportedRunModes } from './getSupportedRunModes.js';
+export { getOperationalStates, getOperationalErrorState } from './getOperationalStates.js';
+export { getSupportedCleanModes } from './getSupportedCleanModes.js';
+export { getSupportedAreas } from './getSupportedAreas.js';
+export { getBatteryStatus, getBatteryState } from './getBatteryStatus.js';

package/dist/model/CloudMessageModel.js

@@ -0,0 +1 @@
+export {};

package/dist/model/DockingStationStatus.js

@@ -0,0 +1,24 @@
+export var DockingStationStatusType;
+(function (DockingStationStatusType) {
+    DockingStationStatusType[DockingStationStatusType["Unknown"] = 0] = "Unknown";
+    DockingStationStatusType[DockingStationStatusType["Error"] = 1] = "Error";
+    DockingStationStatusType[DockingStationStatusType["OK"] = 2] = "OK";
+})(DockingStationStatusType || (DockingStationStatusType = {}));
+export function parseDockingStationStatus(dss) {
+    return {
+        cleanFluidStatus: (dss >> 10) & 0b11,
+        waterBoxFilterStatus: (dss >> 8) & 0b11,
+        dustBagStatus: (dss >> 6) & 0b11,
+        dirtyWaterBoxStatus: (dss >> 4) & 0b11,
+        clearWaterBoxStatus: (dss >> 2) & 0b11,
+        isUpdownWaterReady: dss & 0b11,
+    };
+}
+export function hasDockingStationError(status) {
+    return (status.cleanFluidStatus === DockingStationStatusType.Error ||
+        status.waterBoxFilterStatus === DockingStationStatusType.Error ||
+        status.dustBagStatus === DockingStationStatusType.Error ||
+        status.dirtyWaterBoxStatus === DockingStationStatusType.Error ||
+        status.clearWaterBoxStatus === DockingStationStatusType.Error ||
+        status.isUpdownWaterReady === DockingStationStatusType.Error);
+}

package/dist/model/RoomMap.js

@@ -0,0 +1,18 @@
+export default class RoomMap {
+    rooms = [];
+    constructor(roomData, rooms) {
+        this.rooms = roomData.map((entry) => {
+            return {
+                id: entry[0],
+                globalId: Number(entry[1]),
+                displayName: rooms.find((r) => Number(r.id) == Number(entry[1]))?.name,
+            };
+        });
+    }
+    getGlobalId(id) {
+        return this.rooms.find((r) => Number(r.id) == Number(id))?.globalId;
+    }
+    getRoomId(globalId) {
+        return this.rooms.find((r) => Number(r.globalId) == Number(globalId))?.id;
+    }
+}

package/dist/notifyMessageTypes.js

@@ -0,0 +1,9 @@
+export var NotifyMessageTypes;
+(function (NotifyMessageTypes) {
+    NotifyMessageTypes["LocalMessage"] = "LocalMessage";
+    NotifyMessageTypes["CloudMessage"] = "CloudMessage";
+    NotifyMessageTypes["BatteryUpdate"] = "BatteryUpdate";
+    NotifyMessageTypes["ErrorOccurred"] = "ErrorOccurred";
+    NotifyMessageTypes["HomeData"] = "HomeData";
+    NotifyMessageTypes["DeviceStatus"] = "DeviceStatus";
+})(NotifyMessageTypes || (NotifyMessageTypes = {}));