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

package/dist/helper.js

@@ -0,0 +1,76 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
+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.');
+}
+export function isStatusUpdate(result) {
+    return (Array.isArray(result) &&
+        result.length > 0 &&
+        typeof result[0] === 'object' &&
+        result[0] !== null &&
+        'msg_ver' in result[0] &&
+        result[0].msg_ver !== undefined &&
+        result[0].msg_ver !== null);
+}
+export async function getRoomMap(duid, platform) {
+    const robot = platform.robots.get(duid);
+    const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature.enableMultipleMap) ?? false;
+    if (robot === undefined) {
+        platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+        return undefined;
+    }
+    if (platform.roborockService === undefined)
+        return undefined;
+    const rooms = robot.device.rooms ?? [];
+    if (robot.roomInfo === undefined) {
+        const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+        if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+            platform.log.info(`getRoomMap - mapInfo: ${debugStringify(mapInfo.allRooms)}`);
+            robot.roomInfo = new RoomMap(mapInfo.allRooms, rooms, mapInfo.maps, enableMultipleMap);
+        }
+    }
+    if (robot.roomInfo === undefined) {
+        const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            const roomDataMap = roomData.map((r) => ({ id: r[0], iot_name_id: String(r[1]), globalId: r[1], tag: r[2], mapId: 0, displayName: undefined }));
+            robot.roomInfo = new RoomMap(roomDataMap, rooms, [], enableMultipleMap);
+            return robot.roomInfo;
+        }
+    }
+    return robot.roomInfo;
+}
+export async function getRoomMapFromDevice(device, platform) {
+    const rooms = device?.rooms ?? [];
+    const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature.enableMultipleMap) ?? false;
+    if (device && platform.roborockService) {
+        const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+        platform.log.debug(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+        platform.log.debug(`getRoomMapFromDevice - rooms: ${debugStringify(rooms)}`);
+        if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+            const roomDataMap = mapInfo.allRooms;
+            const roomMap = new RoomMap(roomDataMap, rooms, mapInfo.maps, enableMultipleMap);
+            return roomMap;
+        }
+        const roomData = await platform.roborockService.getRoomMappings(device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+            const roomDataMap = roomData.map((r) => ({ id: r[0], iot_name_id: String(r[1]), globalId: r[1], tag: r[2], mapId: 0, displayName: undefined }));
+            const roomMap = new RoomMap(roomDataMap ?? [], rooms, [], enableMultipleMap);
+            return roomMap;
+        }
+    }
+    return new RoomMap([], rooms, [], enableMultipleMap);
+}

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,82 @@
+import { RvcOperationalState } from 'matterbridge/matter/clusters';
+import { getDefaultOperationalStates } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { VacuumErrorCode } from '../roborockCommunication/Zenum/vacuumAndDockErrorCode.js';
+import { DockingStationStatusType, hasDockingStationError } from '../model/DockingStationStatus.js';
+export function getOperationalStates() {
+    return getDefaultOperationalStates();
+}
+export function getOperationalErrorState(errorCode) {
+    switch (errorCode) {
+        case VacuumErrorCode.None:
+            return undefined;
+        default: {
+            return RvcOperationalState.OperationalState.Error;
+        }
+    }
+}
+export function getErrorFromErrorCode(errorCode) {
+    const operationalState = getOperationalErrorState(errorCode);
+    if (operationalState) {
+        return {
+            errorStateId: RvcOperationalState.ErrorState.NoError,
+            errorStateLabel: `${RvcOperationalState.ErrorState.NoError}`,
+            errorStateDetails: `Error code: ${errorCode}`,
+        };
+    }
+    return undefined;
+}
+export function getErrorFromDSS(status) {
+    if (!status) {
+        return {
+            errorStateId: RvcOperationalState.ErrorState.NoError,
+            errorStateLabel: 'No Docking Station Status',
+            errorStateDetails: 'Docking station status is not available.',
+        };
+    }
+    const hasError = hasDockingStationError(status);
+    if (hasError) {
+        if (status.cleanFluidStatus === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.MopCleaningPadMissing,
+                errorStateLabel: 'Clean Fluid Error',
+                errorStateDetails: 'The clean fluid is not available or has an issue.',
+            };
+        }
+        if (status.waterBoxFilterStatus === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty,
+                errorStateLabel: 'Water Box Filter Error',
+                errorStateDetails: 'The water box filter is not available or has an issue.',
+            };
+        }
+        if (status.dustBagStatus === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.DustBinMissing,
+                errorStateLabel: 'Dust Bag Error',
+                errorStateDetails: 'The dust bag is not available or has an issue.',
+            };
+        }
+        if (status.dirtyWaterBoxStatus === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty,
+                errorStateLabel: 'Dirty Water Box Error',
+                errorStateDetails: 'The dirty water box is not available or has an issue.',
+            };
+        }
+        if (status.clearWaterBoxStatus === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty,
+                errorStateLabel: 'Clear Water Box Error',
+                errorStateDetails: 'The clear water box is not available or has an issue.',
+            };
+        }
+        if (status.isUpdownWaterReady === DockingStationStatusType.Error) {
+            return {
+                errorStateId: RvcOperationalState.ErrorState.WaterTankMissing,
+                errorStateLabel: 'Updown Water Ready Error',
+                errorStateDetails: 'The updown water tank is not ready or has an issue.',
+            };
+        }
+    }
+    return undefined;
+}

package/dist/initialData/getSupportedAreas.js

@@ -0,0 +1,120 @@
+import { debugStringify } from 'matterbridge/logger';
+import { randomInt } from 'node:crypto';
+import { RoomIndexMap } from '../model/roomIndexMap.js';
+export function getSupportedAreas(vacuumRooms, roomMap, enableMultipleMap = false, log) {
+    log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
+    log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
+    const noVacuumRooms = !vacuumRooms || vacuumRooms.length === 0;
+    const noRoomMap = !roomMap?.rooms || roomMap.rooms.length === 0;
+    if (noVacuumRooms || noRoomMap) {
+        if (noVacuumRooms) {
+            log?.error('No rooms found');
+        }
+        if (noRoomMap) {
+            log?.error('No room map found');
+        }
+        return {
+            supportedAreas: [
+                {
+                    areaId: 1,
+                    mapId: null,
+                    areaInfo: {
+                        locationInfo: {
+                            locationName: 'Unknown',
+                            floorNumber: null,
+                            areaType: null,
+                        },
+                        landmarkInfo: null,
+                    },
+                },
+            ],
+            supportedMaps: [],
+            roomIndexMap: new RoomIndexMap(new Map([[1, { roomId: 1, mapId: null }]])),
+        };
+    }
+    const { supportedAreas, indexMap } = processValidData(enableMultipleMap, vacuumRooms, roomMap);
+    const duplicated = findDuplicatedAreaIds(supportedAreas, log);
+    if (duplicated) {
+        return {
+            supportedAreas: [
+                {
+                    areaId: 2,
+                    mapId: null,
+                    areaInfo: {
+                        locationInfo: {
+                            locationName: 'Unknown - Duplicated Areas Found',
+                            floorNumber: null,
+                            areaType: null,
+                        },
+                        landmarkInfo: null,
+                    },
+                },
+            ],
+            supportedMaps: [],
+            roomIndexMap: new RoomIndexMap(new Map([[2, { roomId: 2, mapId: null }]])),
+        };
+    }
+    const supportedMaps = getSupportedMaps(enableMultipleMap, supportedAreas, roomMap);
+    log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
+    log?.debug('getSupportedAreas - supportedMaps', debugStringify(supportedMaps));
+    const roomIndexMap = new RoomIndexMap(indexMap);
+    return {
+        supportedAreas,
+        supportedMaps,
+        roomIndexMap,
+    };
+}
+function findDuplicatedAreaIds(areas, log) {
+    const seen = new Set();
+    const duplicates = [];
+    for (const area of areas) {
+        const key = `${area.areaId}=${area.mapId}`;
+        if (seen.has(key)) {
+            duplicates.push({ areaId: area.areaId, mapId: area.mapId ?? 0 });
+        }
+        else {
+            seen.add(key);
+        }
+    }
+    if (duplicates.length > 0 && log) {
+        const duplicated = areas.filter(({ areaId, mapId }) => duplicates.some((y) => y.areaId === areaId && y.mapId === (mapId ?? 0)));
+        log.error(`Duplicated areaId(s) found: ${debugStringify(duplicated)}`);
+    }
+    return duplicates.length > 0;
+}
+function processValidData(enableMultipleMap, vacuumRooms, roomMap) {
+    const indexMap = new Map();
+    const supportedAreas = roomMap?.rooms !== undefined && roomMap.rooms.length > 0
+        ? roomMap.rooms.map((room, index) => {
+            const locationName = room.displayName ?? vacuumRooms.find((r) => r.id === room.globalId || r.id === room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`;
+            const areaId = enableMultipleMap ? index + 100 : room.id;
+            const mapId = enableMultipleMap ? (room.mapId ?? null) : null;
+            indexMap.set(areaId, { roomId: room.id, mapId: room.mapId ?? null });
+            return {
+                areaId: areaId,
+                mapId: mapId,
+                areaInfo: {
+                    locationInfo: {
+                        locationName: locationName,
+                        floorNumber: room.mapId ?? null,
+                        areaType: null,
+                    },
+                    landmarkInfo: null,
+                },
+            };
+        })
+        : [];
+    return {
+        supportedAreas,
+        indexMap,
+    };
+}
+function getSupportedMaps(enableMultipleMap, supportedAreas, roomMap) {
+    if (enableMultipleMap) {
+        return (roomMap?.mapInfo?.map((map) => ({
+            mapId: map.id,
+            name: map.name ?? `Map ${map.id}`,
+        })) ?? []);
+    }
+    return [];
+}

package/dist/initialData/getSupportedCleanModes.js

@@ -0,0 +1,17 @@
+import { getSupportedCleanModesSmart } from '../behaviors/roborock.vacuum/smart/initalData.js';
+import { getDefaultSupportedCleanModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+export function getSupportedCleanModes(model, enableExperimentalFeature) {
+    if (enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false) {
+        return getDefaultSupportedCleanModes(enableExperimentalFeature);
+    }
+    switch (model) {
+        case DeviceModel.QREVO_EDGE_5V1:
+            return getSupportedCleanModesSmart(enableExperimentalFeature);
+        case DeviceModel.S7_MAXV:
+        case DeviceModel.S8_PRO_ULTRA:
+        case DeviceModel.S6_PURE:
+        default:
+            return getDefaultSupportedCleanModes(enableExperimentalFeature);
+    }
+}

package/dist/initialData/getSupportedRunModes.js

@@ -0,0 +1,11 @@
+import { getDefaultSupportedRunModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+export function getRunningMode(modeTag) {
+    if (!modeTag)
+        return null;
+    const supportedMode = getDefaultSupportedRunModes();
+    const runningMode = supportedMode.find((s) => s.modeTags.some((mt) => mt.value === modeTag));
+    return runningMode?.mode ?? null;
+}
+export function getSupportedRunModes() {
+    return getDefaultSupportedRunModes();
+}

package/dist/initialData/getSupportedScenes.js

@@ -0,0 +1,26 @@
+import { debugStringify } from 'matterbridge/logger';
+import { randomInt } from 'node:crypto';
+export function getSupportedScenes(scenes, log) {
+    log?.debug('getSupportedScenes', debugStringify(scenes));
+    if (!scenes || scenes.length === 0) {
+        log?.error('No scenes found');
+        return [];
+    }
+    const supportedAreas = scenes
+        .filter((s) => s.enabled && s.id)
+        .map((scene) => {
+        return {
+            areaId: scene.id ?? 0 + randomInt(5000, 9000),
+            mapId: null,
+            areaInfo: {
+                locationInfo: {
+                    locationName: `Scene: ${scene.name}`,
+                    floorNumber: null,
+                    areaType: null,
+                },
+                landmarkInfo: null,
+            },
+        };
+    });
+    return supportedAreas;
+}

package/dist/initialData/index.js

@@ -0,0 +1,6 @@
+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';
+export { getSupportedScenes } from './getSupportedScenes.js';

package/dist/model/CloudMessageModel.js

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

package/dist/model/DockingStationStatus.js

@@ -0,0 +1,26 @@
+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) {
+    if (!status) {
+        return false;
+    }
+    return (status.cleanFluidStatus === DockingStationStatusType.Error ||
+        status.waterBoxFilterStatus === DockingStationStatusType.Error ||
+        status.dustBagStatus === DockingStationStatusType.Error ||
+        status.dirtyWaterBoxStatus === DockingStationStatusType.Error ||
+        status.clearWaterBoxStatus === DockingStationStatusType.Error);
+}

package/dist/model/ExperimentalFeatureSetting.js

@@ -0,0 +1,30 @@
+export function createDefaultExperimentalFeatureSetting() {
+    return {
+        enableExperimentalFeature: false,
+        advancedFeature: {
+            showRoutinesAsRoom: false,
+            includeDockStationStatus: false,
+            forceRunAtDefault: false,
+            useVacationModeToSendVacuumToDock: false,
+            enableServerMode: false,
+            alwaysExecuteAuthentication: false,
+            enableMultipleMap: false,
+        },
+        cleanModeSettings: {
+            enableCleanModeMapping: false,
+            vacuuming: {
+                fanMode: 'Balanced',
+                mopRouteMode: 'Standard',
+            },
+            mopping: {
+                waterFlowMode: 'Medium',
+                mopRouteMode: 'Standard',
+            },
+            vacmop: {
+                fanMode: 'Balanced',
+                waterFlowMode: 'Medium',
+                mopRouteMode: 'Standard',
+            },
+        },
+    };
+}

package/dist/model/RoomMap.js

@@ -0,0 +1,19 @@
+export class RoomMap {
+    rooms;
+    mapInfo;
+    constructor(roomData, rooms, mapInfo, enableMultipleMap) {
+        const mapid = mapInfo[0]?.id ?? 0;
+        const roomDataTmp = enableMultipleMap ? roomData : roomData.filter((room) => room.mapId === undefined || room.mapId === mapid);
+        this.rooms = roomDataTmp.map(({ id, globalId, tag, mapId }) => {
+            const room = rooms.find((r) => Number(r.id) === Number(globalId) || Number(r.id) === Number(id));
+            return {
+                id,
+                globalId: globalId !== undefined ? Number(globalId) : undefined,
+                displayName: room?.name ?? `Room ${id}`,
+                alternativeId: `${id}${tag}`,
+                mapId,
+            };
+        });
+        this.mapInfo = mapInfo;
+    }
+}

package/dist/model/roomIndexMap.js

@@ -0,0 +1,21 @@
+export class RoomIndexMap {
+    indexMap;
+    roomMap;
+    constructor(roomMap) {
+        this.indexMap = roomMap;
+        this.roomMap = new Map();
+        for (const [areaId, r] of roomMap.entries()) {
+            this.roomMap.set(`${r.roomId}:${r.mapId}`, areaId);
+        }
+    }
+    getAreaId(roomId, mapId) {
+        const areaId = this.roomMap.get(`${roomId}:${mapId}`);
+        if (areaId === undefined) {
+            return undefined;
+        }
+        return areaId;
+    }
+    getRoomId(areaId) {
+        return this.indexMap.get(areaId)?.roomId;
+    }
+}

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 = {}));