matterbridge-roborock-vacuum-plugin 1.0.5

package/dist/roborockCommunication/Zmodel/device.js

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

package/dist/roborockCommunication/Zmodel/deviceModel.js

@@ -0,0 +1,28 @@
+export var DeviceModel;
+(function (DeviceModel) {
+    DeviceModel["Q5"] = "roborock.vacuum.a34";
+    DeviceModel["Q5_PRO"] = "roborock.vacuum.a72";
+    DeviceModel["S5"] = "roborock.vacuum.s5";
+    DeviceModel["S5_MAX"] = "roborock.vacuum.s5e";
+    DeviceModel["S6"] = "roborock.vacuum.s6";
+    DeviceModel["S6_MAXV"] = "roborock.vacuum.a10";
+    DeviceModel["S6_PURE"] = "roborock.vacuum.a08";
+    DeviceModel["Q7"] = "roborock.vacuum.a40";
+    DeviceModel["Q7_MAX"] = "roborock.vacuum.a38";
+    DeviceModel["Q7_PLUS"] = "roborock.vacuum.a40";
+    DeviceModel["S7"] = "roborock.vacuum.a15";
+    DeviceModel["S7_MAXV"] = "roborock.vacuum.a27";
+    DeviceModel["S7_MAXV_ULTRA"] = "roborock.vacuum.a65";
+    DeviceModel["S7_PRO_ULTRA"] = "roborock.vacuum.a62";
+    DeviceModel["Q8_MAX"] = "roborock.vacuum.a73";
+    DeviceModel["S8"] = "roborock.vacuum.a51";
+    DeviceModel["S8_PRO_ULTRA"] = "roborock.vacuum.a70";
+    DeviceModel["S8_MAXV_ULTRA"] = "roborock.vacuum.a97";
+    DeviceModel["QREVO_MASTER"] = "roborock.vacuum.a117";
+    DeviceModel["QREVO_CURV"] = "roborock.vacuum.a135";
+    DeviceModel["QREVO_S"] = "roborock.vacuum.a104";
+    DeviceModel["QREVO_PRO"] = "roborock.vacuum.a101";
+    DeviceModel["QREVO_MAXV"] = "roborock.vacuum.a87";
+    DeviceModel["QREVO_EDGE_5V1"] = "roborock.vacuum.a187";
+    DeviceModel["QREVO_EDGE_5AE"] = "roborock.vacuum.xxxx";
+})(DeviceModel || (DeviceModel = {}));

package/dist/roborockCommunication/Zmodel/deviceSchema.js

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

package/dist/roborockCommunication/Zmodel/deviceStatus.js

@@ -0,0 +1,22 @@
+import { DockInfo } from './dockInfo.js';
+import { VacuumError } from './vacuumError.js';
+export class DeviceStatus {
+    errorStatus;
+    message;
+    constructor(message) {
+        this.message = message;
+        this.errorStatus = new VacuumError(message.error_code, message.dock_error_status);
+    }
+    getBattery() {
+        return this.message.battery;
+    }
+    getVacuumErrorCode() {
+        return this.message.error_code;
+    }
+    getDockInfo() {
+        return new DockInfo(this.message.dock_type);
+    }
+    getDockErrorCode() {
+        return this.message.dock_error_status;
+    }
+}

package/dist/roborockCommunication/Zmodel/dockInfo.js

@@ -0,0 +1,6 @@
+export class DockInfo {
+    dockType;
+    constructor(dockType) {
+        this.dockType = dockType;
+    }
+}

package/dist/roborockCommunication/Zmodel/home.js

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

package/dist/roborockCommunication/Zmodel/homeInfo.js

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

package/dist/roborockCommunication/Zmodel/messageResult.js

@@ -0,0 +1,7 @@
+export var CarpetCleanMode;
+(function (CarpetCleanMode) {
+    CarpetCleanMode[CarpetCleanMode["Avoid"] = 0] = "Avoid";
+    CarpetCleanMode[CarpetCleanMode["Ignore"] = 2] = "Ignore";
+    CarpetCleanMode[CarpetCleanMode["Cross"] = 3] = "Cross";
+    CarpetCleanMode[CarpetCleanMode["DynamicLift"] = 200] = "DynamicLift";
+})(CarpetCleanMode || (CarpetCleanMode = {}));

package/dist/roborockCommunication/Zmodel/networkInfo.js

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

package/dist/roborockCommunication/Zmodel/product.js

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

package/dist/roborockCommunication/Zmodel/room.js

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

package/dist/roborockCommunication/Zmodel/roomInfo.js

@@ -0,0 +1,22 @@
+import decodeComponent from '../helper/nameDecoder.js';
+export class RoomInfo {
+    rooms = [];
+    constructor(roomInfo, roomData) {
+        this.rooms = roomData
+            .map((entry) => {
+            return { id: entry[0], globalId: entry[1] };
+        })
+            .map((entry) => {
+            return {
+                id: entry.id,
+                room: roomInfo.find((el) => el.id == entry.globalId),
+            };
+        })
+            .map((entry) => {
+            return {
+                id: entry.id,
+                name: decodeComponent(entry.room?.name)?.toLowerCase(),
+            };
+        });
+    }
+}

package/dist/roborockCommunication/Zmodel/userData.js

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

package/dist/roborockCommunication/Zmodel/vacuumError.js

@@ -0,0 +1,27 @@
+import { DockErrorCode, VacuumErrorCode } from '../Zenum/vacuumAndDockErrorCode.js';
+export class VacuumError {
+    vacuumErrorCode;
+    dockErrorCode;
+    constructor(errorCode, dockErrorCode) {
+        this.vacuumErrorCode = errorCode;
+        this.dockErrorCode = dockErrorCode;
+    }
+    hasError() {
+        return this.vacuumErrorCode != 0 || this.dockErrorCode != 0;
+    }
+    isStuck() {
+        return this.vacuumErrorCode === VacuumErrorCode.RobotTrapped;
+    }
+    isBatteryLow() {
+        return this.vacuumErrorCode === VacuumErrorCode.LowBattery;
+    }
+    isBinFull() {
+        return this.vacuumErrorCode === VacuumErrorCode.CleanAutoEmptyDock || this.dockErrorCode == DockErrorCode.DuctBlockage;
+    }
+    isCleanWaterEmpty() {
+        return this.vacuumErrorCode === VacuumErrorCode.ClearWaterTankEmpty || this.dockErrorCode == DockErrorCode.WaterEmpty;
+    }
+    isWasteWaterFull() {
+        return this.dockErrorCode == DockErrorCode.WasteWaterTankFull;
+    }
+}

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -0,0 +1,41 @@
+import { MessageDeserializer } from '../helper/messageDeserializer.js';
+import { MessageSerializer } from '../helper/messageSerializer.js';
+import { ChainedConnectionListener } from './listener/implementation/chainedConnectionListener.js';
+import { ChainedMessageListener } from './listener/implementation/chainedMessageListener.js';
+import { SyncMessageListener } from './listener/implementation/syncMessageListener.js';
+export class AbstractClient {
+    connectionListeners = new ChainedConnectionListener();
+    messageListeners = new ChainedMessageListener();
+    connected = false;
+    context;
+    serializer;
+    deserializer;
+    syncMessageListener;
+    logger;
+    constructor(logger, context) {
+        this.context = context;
+        this.serializer = new MessageSerializer(this.context);
+        this.deserializer = new MessageDeserializer(this.context);
+        this.syncMessageListener = new SyncMessageListener(logger);
+        this.messageListeners.register(this.syncMessageListener);
+        this.logger = logger;
+    }
+    async get(duid, request) {
+        return new Promise((resolve, reject) => {
+            this.syncMessageListener.waitFor(request.messageId, resolve, reject);
+            this.send(duid, request);
+        });
+    }
+    registerDevice(duid, localKey, pv) {
+        this.context.registerDevice(duid, localKey, pv);
+    }
+    registerConnectionListener(listener) {
+        this.connectionListeners.register(listener);
+    }
+    registerMessageListener(listener) {
+        this.messageListeners.register(listener);
+    }
+    isConnected() {
+        return this.connected;
+    }
+}

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

@@ -0,0 +1,148 @@
+import { Socket } from 'node:net';
+import { clearInterval } from 'node:timers';
+import { Protocol } from '../model/protocol.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { AbstractClient } from '../abstractClient.js';
+import { Sequence } from '../../helper/sequence.js';
+import { ChunkBuffer } from '../../helper/chunkBuffer.js';
+export class LocalNetworkClient extends AbstractClient {
+    socket = undefined;
+    buffer = new ChunkBuffer();
+    messageIdSeq;
+    pingInterval;
+    duid;
+    ip;
+    constructor(logger, context, duid, ip) {
+        super(logger, context);
+        this.duid = duid;
+        this.ip = ip;
+        this.messageIdSeq = new Sequence(100000, 999999);
+    }
+    connect() {
+        this.socket = new Socket();
+        this.socket.on('close', this.onDisconnect.bind(this));
+        this.socket.on('end', this.onDisconnect.bind(this));
+        this.socket.on('error', this.onError.bind(this));
+        this.socket.on('data', this.onMessage.bind(this));
+        this.socket.connect(58867, this.ip, this.onConnect.bind(this));
+    }
+    async disconnect() {
+        if (!this.socket) {
+            return;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        this.socket.destroy();
+        this.socket = undefined;
+    }
+    async send(duid, request) {
+        if (!this.socket || !this.connected) {
+            this.logger.error(`failed to send request to ${duid}, socket is not online, ${JSON.stringify(request)}`);
+            return;
+        }
+        const localRequest = request.toLocalRequest();
+        const message = this.serializer.serialize(duid, localRequest);
+        this.logger.debug(`sending message ${message.messageId}, protocol:${localRequest.protocol}, method:${localRequest.method}, secure:${request.secure} to ${duid}`);
+        this.socket.write(this.wrapWithLengthData(message.buffer));
+    }
+    async onConnect() {
+        this.connected = true;
+        const address = this.socket?.address();
+        this.logger.debug(`${this.duid} connected to ${this.ip}, address: ${JSON.stringify(address)}`);
+        await this.sendHelloMessage();
+        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
+        await this.connectionListeners.onConnected();
+    }
+    async onDisconnect() {
+        this.logger.info('Socket has disconnected.');
+        this.connected = false;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        await this.connectionListeners.onDisconnected();
+    }
+    async onError(result) {
+        this.logger.error('Socket connection error: ' + result);
+        this.connected = false;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+        }
+        await this.connectionListeners.onError(result.toString());
+    }
+    async onMessage(message) {
+        if (!this.socket) {
+            this.logger.error('unable to receive data if there is no socket available');
+            return;
+        }
+        if (!message || message.length == 0) {
+            this.logger.debug('LocalNetworkClient received empty message from socket.');
+            return;
+        }
+        try {
+            this.buffer.append(message);
+            const recvBuffer = this.buffer.get();
+            if (!this.isMessageComplete(recvBuffer)) {
+                return;
+            }
+            this.buffer.reset();
+            let offset = 0;
+            while (offset + 4 <= recvBuffer.length) {
+                const segmentLength = recvBuffer.readUInt32BE(offset);
+                if (segmentLength == 17) {
+                    offset += 4 + segmentLength;
+                    continue;
+                }
+                try {
+                    const currentBuffer = recvBuffer.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);
+                }
+                offset += 4 + segmentLength;
+            }
+        }
+        catch (error) {
+            this.logger.error('failed to read from a socket: ' + error);
+        }
+    }
+    isMessageComplete(buffer) {
+        let totalLength = 0;
+        let offset = 0;
+        while (offset + 4 <= buffer.length) {
+            const segmentLength = buffer.readUInt32BE(offset);
+            totalLength += 4 + segmentLength;
+            offset += 4 + segmentLength;
+            if (offset > buffer.length) {
+                return false;
+            }
+        }
+        return totalLength <= buffer.length;
+    }
+    wrapWithLengthData(buffer) {
+        const lengthBuffer = Buffer.alloc(4);
+        lengthBuffer.writeUInt32BE(buffer.length, 0);
+        return Buffer.concat([lengthBuffer, buffer]);
+    }
+    async sendHelloMessage() {
+        const request = new RequestMessage({
+            protocol: Protocol.hello_request,
+            messageId: this.messageIdSeq.next(),
+        });
+        await this.send(this.duid, request);
+    }
+    async sendPingRequest() {
+        const request = new RequestMessage({
+            protocol: Protocol.ping_request,
+            messageId: this.messageIdSeq.next(),
+        });
+        await this.send(this.duid, request);
+    }
+}

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

@@ -0,0 +1,101 @@
+import mqtt from 'mqtt';
+import { CryptoUtils } from '../../helper/cryptoHelper.js';
+import { AbstractClient } from '../abstractClient.js';
+export class MQTTClient extends AbstractClient {
+    rriot;
+    mqttUsername;
+    mqttPassword;
+    client = undefined;
+    constructor(logger, context, userdata) {
+        super(logger, context);
+        this.rriot = userdata.rriot;
+        this.mqttUsername = CryptoUtils.md5hex(userdata.rriot.u + ':' + userdata.rriot.k).substring(2, 10);
+        this.mqttPassword = CryptoUtils.md5hex(userdata.rriot.s + ':' + userdata.rriot.k).substring(16);
+    }
+    connect() {
+        if (this.client) {
+            return;
+        }
+        this.client = mqtt.connect(this.rriot.r.m, {
+            clientId: this.mqttUsername,
+            username: this.mqttUsername,
+            password: this.mqttPassword,
+            keepalive: 30,
+            log: (...args) => {
+            },
+        });
+        this.client.on('connect', this.onConnect.bind(this));
+        this.client.on('error', this.onError.bind(this));
+        this.client.on('reconnect', this.onReconnect.bind(this));
+        this.client.on('close', this.onDisconnect.bind(this));
+        this.client.on('disconnect', this.onDisconnect.bind(this));
+        this.client.on('offline', this.onDisconnect.bind(this));
+        this.client.on('message', this.onMessage.bind(this));
+    }
+    async disconnect() {
+        if (!this.client || !this.connected) {
+            return;
+        }
+        try {
+            this.client.end();
+        }
+        catch (error) {
+            this.logger.error('MQTT client failed to disconnect with error: ' + error);
+        }
+    }
+    async send(duid, request) {
+        if (!this.client || !this.connected) {
+            return;
+        }
+        const mqttRequest = request.toMqttRequest();
+        const message = this.serializer.serialize(duid, mqttRequest);
+        this.client.publish('rr/m/i/' + this.rriot.u + '/' + this.mqttUsername + '/' + duid, message.buffer, { qos: 1 });
+    }
+    async onConnect(result) {
+        if (!result) {
+            return;
+        }
+        this.connected = true;
+        await this.connectionListeners.onConnected();
+        this.subscribeToQueue();
+    }
+    subscribeToQueue() {
+        if (!this.client) {
+            return;
+        }
+        this.client.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
+    }
+    async onSubscribe(err, granted) {
+        if (!err) {
+            return;
+        }
+        this.logger.error('failed to subscribe to the queue: ' + err);
+        this.connected = false;
+        await this.connectionListeners.onDisconnected();
+    }
+    async onDisconnect() {
+        await this.connectionListeners.onDisconnected();
+    }
+    async onError(result) {
+        this.logger.error('MQTT connection error: ' + result);
+        this.connected = false;
+        await this.connectionListeners.onError(result.toString());
+    }
+    onReconnect() {
+        this.subscribeToQueue();
+    }
+    async onMessage(topic, message) {
+        if (!message) {
+            this.logger.notice('MQTTClient received empty message from topic: ' + topic);
+            return;
+        }
+        try {
+            const duid = topic.split('/').slice(-1)[0];
+            const response = this.deserializer.deserialize(duid, message);
+            await this.messageListeners.onMessage(response);
+        }
+        catch (error) {
+            this.logger.error('unable to process message from queue ' + topic + ': ' + error);
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/client.js

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

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -0,0 +1,79 @@
+import { ChainedConnectionListener } from './listener/implementation/chainedConnectionListener.js';
+import { ChainedMessageListener } from './listener/implementation/chainedMessageListener.js';
+import { MessageContext } from './model/messageContext.js';
+import { LocalNetworkClient } from './client/LocalNetworkClient.js';
+import { MQTTClient } from './client/MQTTClient.js';
+export class ClientRouter {
+    connectionListeners = new ChainedConnectionListener();
+    messageListeners = new ChainedMessageListener();
+    context;
+    mqttClient;
+    localClients = new Map();
+    logger;
+    constructor(logger, userdata) {
+        this.context = new MessageContext(userdata);
+        this.logger = logger;
+        this.mqttClient = new MQTTClient(logger, this.context, userdata);
+        this.mqttClient.registerConnectionListener(this.connectionListeners);
+        this.mqttClient.registerMessageListener(this.messageListeners);
+    }
+    registerDevice(duid, localKey, pv) {
+        this.context.registerDevice(duid, localKey, pv);
+    }
+    registerClient(duid, ip) {
+        const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);
+        localClient.registerConnectionListener(this.connectionListeners);
+        localClient.registerMessageListener(this.messageListeners);
+        this.localClients.set(duid, localClient);
+        return localClient;
+    }
+    unregisterClient(duid) {
+        this.localClients.delete(duid);
+    }
+    registerConnectionListener(listener) {
+        this.connectionListeners.register(listener);
+    }
+    registerMessageListener(listener) {
+        this.messageListeners.register(listener);
+    }
+    isConnected() {
+        return this.mqttClient.isConnected();
+    }
+    connect() {
+        this.mqttClient.connect();
+        this.localClients.forEach((client, duid) => {
+            client.connect();
+        });
+    }
+    async disconnect() {
+        await this.mqttClient.disconnect();
+        this.localClients.forEach((client, duid) => {
+            client.disconnect();
+        });
+    }
+    async send(duid, request) {
+        if (request.secure) {
+            await this.mqttClient.send(duid, request);
+        }
+        else {
+            await this.getClient(duid).send(duid, request);
+        }
+    }
+    async get(duid, request) {
+        if (request.secure) {
+            return await this.mqttClient.get(duid, request);
+        }
+        else {
+            return await this.getClient(duid).get(duid, request);
+        }
+    }
+    getClient(duid) {
+        const localClient = this.localClients.get(duid);
+        if (localClient === undefined || !localClient.isConnected()) {
+            return this.mqttClient;
+        }
+        else {
+            return localClient;
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/abstractConnectionListener.js

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

package/dist/roborockCommunication/broadcast/listener/abstractMessageHandler.js

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

package/dist/roborockCommunication/broadcast/listener/abstractMessageListener.js

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

package/dist/roborockCommunication/broadcast/listener/implementation/chainedConnectionListener.js

@@ -0,0 +1,21 @@
+export class ChainedConnectionListener {
+    listeners = [];
+    register(listener) {
+        this.listeners.push(listener);
+    }
+    async onConnected() {
+        for (const listener of this.listeners) {
+            await listener.onConnected();
+        }
+    }
+    async onDisconnected() {
+        for (const listener of this.listeners) {
+            await listener.onDisconnected();
+        }
+    }
+    async onError(message) {
+        for (const listener of this.listeners) {
+            await listener.onError(message);
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/implementation/chainedMessageListener.js

@@ -0,0 +1,11 @@
+export class ChainedMessageListener {
+    listeners = [];
+    register(listener) {
+        this.listeners.push(listener);
+    }
+    async onMessage(message) {
+        for (const listener of this.listeners) {
+            await listener.onMessage(message);
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/implementation/simpleMessageListener.js

@@ -0,0 +1,27 @@
+import { Protocol } from '../../model/protocol.js';
+export class SimpleMessageListener {
+    handler;
+    registerListener(handler) {
+        this.handler = handler;
+    }
+    async onMessage(message) {
+        if (!this.handler || message.contain(Protocol.rpc_response) || message.contain(Protocol.map_response)) {
+            return;
+        }
+        if (message.contain(Protocol.status_update) && this.handler.onStatusChanged) {
+            await this.handler.onStatusChanged();
+        }
+        if (message.contain(Protocol.error) && this.handler.onError) {
+            const value = message.get(Protocol.error);
+            await this.handler.onError(Number(value));
+        }
+        if (message.contain(Protocol.battery) && this.handler.onBatteryUpdate) {
+            const value = message.get(Protocol.battery);
+            await this.handler.onBatteryUpdate(Number(value));
+        }
+        if (message.contain(Protocol.additional_props) && this.handler.onAdditionalProps) {
+            const value = message.get(Protocol.additional_props);
+            await this.handler.onAdditionalProps(Number(value));
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/implementation/syncMessageListener.js

@@ -0,0 +1,35 @@
+import { Protocol } from '../../model/protocol.js';
+export class SyncMessageListener {
+    pending = new Map();
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    waitFor(messageId, resolve, reject) {
+        this.pending.set(messageId, resolve);
+        setTimeout(() => {
+            this.pending.delete(messageId);
+            reject();
+        }, 10000);
+    }
+    async onMessage(message) {
+        if (message.contain(Protocol.rpc_response)) {
+            const dps = message.get(Protocol.rpc_response);
+            const messageId = dps.id;
+            const responseHandler = this.pending.get(messageId);
+            if (dps.result.length == 1 && dps.result[0] == 'ok') {
+                return;
+            }
+            if (responseHandler) {
+                responseHandler(dps.result);
+            }
+            this.pending.delete(messageId);
+            return;
+        }
+        if (message.contain(Protocol.map_response)) {
+            const dps = message.get(Protocol.map_response);
+            this.pending.delete(dps.id);
+            return;
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/listener/index.js

@@ -0,0 +1 @@
+export { SimpleMessageListener } from './implementation/simpleMessageListener.js';