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

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

@@ -0,0 +1,174 @@
+import { Socket } from 'node:net';
+import { clearInterval } from 'node:timers';
+import { Protocol } from '../model/protocol.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { debugStringify } from 'matterbridge/logger';
+import { AbstractClient } from '../abstractClient.js';
+import { Sequence } from '../../helper/sequence.js';
+import { ChunkBuffer } from '../../helper/chunkBuffer.js';
+export class LocalNetworkClient extends AbstractClient {
+    clientName = 'LocalNetworkClient';
+    shouldReconnect = true;
+    socket = undefined;
+    buffer = new ChunkBuffer();
+    messageIdSeq;
+    pingInterval;
+    keepConnectionAliveInterval = undefined;
+    duid;
+    ip;
+    constructor(logger, context, duid, ip) {
+        super(logger, context);
+        this.duid = duid;
+        this.ip = ip;
+        this.messageIdSeq = new Sequence(100000, 999999);
+        this.initializeConnectionStateListener();
+    }
+    connect() {
+        if (this.socket) {
+            return;
+        }
+        this.socket = new Socket();
+        this.socket.on('close', this.onDisconnect.bind(this));
+        this.socket.on('end', this.onEnd.bind(this));
+        this.socket.on('error', this.onError.bind(this));
+        this.socket.on('connect', this.onConnect.bind(this));
+        this.socket.on('timeout', this.onTimeout.bind(this));
+        this.socket.on('data', this.onMessage.bind(this));
+        this.socket.connect(58867, this.ip);
+        this.keepConnectionAlive();
+    }
+    async disconnect() {
+        if (!this.socket) {
+            return;
+        }
+        this.isInDisconnectingStep = true;
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        this.socket.destroy();
+        this.socket = undefined;
+    }
+    async send(duid, request) {
+        if (!this.socket || !this.connected) {
+            this.logger.error(`${duid}: socket is not online, , ${debugStringify(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.logger.debug(` [LocalNetworkClient]: ${this.duid} connected to ${this.ip}`);
+        this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
+        this.connected = true;
+        this.retryCount = 0;
+        await this.sendHelloMessage();
+        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
+        await this.connectionListeners.onConnected(this.duid);
+    }
+    async onDisconnect(hadError) {
+        this.logger.info(` [LocalNetworkClient]: ${this.duid} socket disconnected. Had error: ${hadError}`);
+        this.connected = false;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
+    }
+    async onError(error) {
+        this.logger.error(` [LocalNetworkClient]: Socket error for ${this.duid}: ${error.message}`);
+        await this.connectionListeners.onError(this.duid, error.message);
+    }
+    async onTimeout() {
+        this.logger.error(` [LocalNetworkClient]: Socket for ${this.duid} timed out.`);
+    }
+    async onEnd() {
+        this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket ended.`);
+    }
+    async onMessage(message) {
+        if (!this.socket) {
+            return;
+        }
+        if (!message || message.length == 0) {
+            this.logger.debug('LocalNetworkClient received empty message from socket.');
+            return;
+        }
+        try {
+            this.buffer.append(message);
+            const receivedBuffer = this.buffer.get();
+            if (!this.isMessageComplete(receivedBuffer)) {
+                return;
+            }
+            this.buffer.reset();
+            let offset = 0;
+            while (offset + 4 <= receivedBuffer.length) {
+                const segmentLength = receivedBuffer.readUInt32BE(offset);
+                if (segmentLength == 17) {
+                    offset += 4 + segmentLength;
+                    continue;
+                }
+                try {
+                    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('LocalNetworkClient: unable to process message with error: ' + error);
+                }
+                offset += 4 + segmentLength;
+            }
+        }
+        catch (error) {
+            this.logger.error('LocalNetworkClient: read socket buffer error: ' + 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(),
+            nonce: this.context.nonce,
+        });
+        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);
+    }
+    keepConnectionAlive() {
+        if (this.keepConnectionAliveInterval) {
+            clearTimeout(this.keepConnectionAliveInterval);
+            this.keepConnectionAliveInterval.unref();
+        }
+        this.keepConnectionAliveInterval = setInterval(() => {
+            if (this.socket === undefined || !this.connected || !this.socket.writable || this.socket.readable) {
+                this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket is not writable or readable, reconnecting...`);
+                this.connect();
+            }
+        }, 60 * 60 * 1000);
+    }
+}

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

@@ -0,0 +1,129 @@
+import * as dgram from 'node:dgram';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { AbstractClient } from '../abstractClient.js';
+export class LocalNetworkUDPClient extends AbstractClient {
+    clientName = 'LocalNetworkUDPClient';
+    shouldReconnect = false;
+    PORT = 58866;
+    server = undefined;
+    V10Parser;
+    L01Parser;
+    constructor(logger, context) {
+        super(logger, context);
+        this.V10Parser = new Parser()
+            .endianness('big')
+            .string('version', { length: 3 })
+            .uint32('seq')
+            .uint16('protocol')
+            .uint16('payloadLen')
+            .buffer('payload', { length: 'payloadLen' })
+            .uint32('crc32');
+        this.L01Parser = new Parser()
+            .endianness('big')
+            .string('version', { length: 3 })
+            .string('field1', { length: 4 })
+            .string('field2', { length: 2 })
+            .uint16('payloadLen')
+            .buffer('payload', { length: 'payloadLen' })
+            .uint32('crc32');
+        this.logger = logger;
+    }
+    connect() {
+        try {
+            this.server = dgram.createSocket('udp4');
+            this.server.bind(this.PORT);
+            this.server.on('message', this.onMessage.bind(this));
+            this.server.on('error', this.onError.bind(this));
+        }
+        catch (err) {
+            this.logger.error(`Failed to create UDP socket: ${err}`);
+            this.server = undefined;
+        }
+    }
+    disconnect() {
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server?.close(() => {
+                    this.server = undefined;
+                    resolve();
+                });
+            });
+        }
+        return Promise.resolve();
+    }
+    send(duid, request) {
+        this.logger.debug(`Sending request to ${duid}: ${JSON.stringify(request)}`);
+        return Promise.resolve();
+    }
+    async onError(result) {
+        this.logger.error(`UDP socket error: ${result}`);
+        if (this.server) {
+            this.server.close();
+            this.server = undefined;
+        }
+    }
+    async onMessage(buffer) {
+        const message = await this.deserializeMessage(buffer);
+        this.logger.debug('Received message: ' + JSON.stringify(message));
+    }
+    async deserializeMessage(buffer) {
+        const version = buffer.toString('latin1', 0, 3);
+        if (version !== '1.0' && version !== 'L01' && version !== 'A01') {
+            throw new Error('unknown protocol version ' + version);
+        }
+        let data;
+        switch (version) {
+            case '1.0':
+                data = await this.deserializeV10Message(buffer);
+                return JSON.parse(data);
+            case 'L01':
+                data = await this.deserializeL01Message(buffer);
+                return JSON.parse(data);
+            case 'A01':
+                return undefined;
+            default:
+                throw new Error('unknown protocol version ' + version);
+        }
+    }
+    async deserializeV10Message(message) {
+        const data = this.V10Parser.parse(message);
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = data.crc32;
+        if (crc32 != expectedCrc32) {
+            throw new Error('wrong CRC32 ' + crc32 + ', expected ' + expectedCrc32);
+        }
+        const decipher = crypto.createDecipheriv('aes-128-ecb', Buffer.from('qWKYcdQWrbm9hPqe', 'utf8'), null);
+        decipher.setAutoPadding(false);
+        let decrypted = decipher.update(data.payload, 'binary', 'utf8');
+        decrypted += decipher.final('utf8');
+        const paddingLength = decrypted.charCodeAt(decrypted.length - 1);
+        return decrypted.slice(0, -paddingLength);
+    }
+    async deserializeL01Message(message) {
+        const data = this.L01Parser.parse(message);
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = data.crc32;
+        if (crc32 != expectedCrc32) {
+            throw new Error('wrong CRC32 ' + crc32 + ', expected ' + expectedCrc32);
+        }
+        const payload = data.payload;
+        const key = crypto.createHash('sha256').update(Buffer.from('qWKYcdQWrbm9hPqe', 'utf8')).digest();
+        const digestInput = message.subarray(0, 9);
+        const digest = crypto.createHash('sha256').update(digestInput).digest();
+        const iv = digest.subarray(0, 12);
+        const tag = payload.subarray(payload.length - 16);
+        const ciphertext = payload.subarray(0, payload.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        try {
+            const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+            return decrypted.toString('utf8');
+        }
+        catch (e) {
+            const message = e && typeof e === 'object' && 'message' in e ? e.message : String(e);
+            throw new Error('failed to decrypt: ' + message + ' / iv: ' + iv.toString('hex') + ' / tag: ' + tag.toString('hex') + ' / encrypted: ' + ciphertext.toString('hex'));
+        }
+    }
+}

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

@@ -0,0 +1,139 @@
+import mqtt from 'mqtt';
+import * as CryptoUtils from '../../helper/cryptoHelper.js';
+import { AbstractClient } from '../abstractClient.js';
+import { debugStringify } from 'matterbridge/logger';
+export class MQTTClient extends AbstractClient {
+    clientName = 'MQTTClient';
+    shouldReconnect = false;
+    rriot;
+    mqttUsername;
+    mqttPassword;
+    mqttClient = undefined;
+    keepConnectionAliveInterval = 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);
+        this.initializeConnectionStateListener();
+    }
+    connect() {
+        if (this.mqttClient) {
+            return;
+        }
+        this.mqttClient = mqtt.connect(this.rriot.r.m, {
+            clientId: this.mqttUsername,
+            username: this.mqttUsername,
+            password: this.mqttPassword,
+            keepalive: 30,
+            log: () => {
+            },
+        });
+        this.mqttClient.on('connect', this.onConnect.bind(this));
+        this.mqttClient.on('error', this.onError.bind(this));
+        this.mqttClient.on('reconnect', this.onReconnect.bind(this));
+        this.mqttClient.on('close', this.onClose.bind(this));
+        this.mqttClient.on('disconnect', this.onDisconnect.bind(this));
+        this.mqttClient.on('offline', this.onOffline.bind(this));
+        this.mqttClient.on('message', this.onMessage.bind(this));
+        this.keepConnectionAlive();
+    }
+    async disconnect() {
+        if (!this.mqttClient || !this.connected) {
+            return;
+        }
+        try {
+            this.isInDisconnectingStep = true;
+            this.mqttClient.end();
+        }
+        catch (error) {
+            this.logger.error('MQTT client failed to disconnect with error: ' + error);
+        }
+    }
+    async send(duid, request) {
+        if (!this.mqttClient || !this.connected) {
+            this.logger.error(`${duid}: mqtt is not available, ${debugStringify(request)}`);
+            return;
+        }
+        const mqttRequest = request.toMqttRequest();
+        const message = this.serializer.serialize(duid, mqttRequest);
+        this.logger.debug(`MQTTClient sending message to ${duid}: ${debugStringify(mqttRequest)}`);
+        this.mqttClient.publish(`rr/m/i/${this.rriot.u}/${this.mqttUsername}/${duid}`, message.buffer, { qos: 1 });
+        this.logger.debug(`MQTTClient published message to topic: rr/m/i/${this.rriot.u}/${this.mqttUsername}/${duid}`);
+    }
+    keepConnectionAlive() {
+        if (this.keepConnectionAliveInterval) {
+            clearTimeout(this.keepConnectionAliveInterval);
+            this.keepConnectionAliveInterval.unref();
+        }
+        this.keepConnectionAliveInterval = setInterval(() => {
+            if (this.mqttClient) {
+                this.mqttClient.end();
+                this.mqttClient.reconnect();
+            }
+            else {
+                this.connect();
+            }
+        }, 30 * 60 * 1000);
+    }
+    async onConnect(result) {
+        if (!result) {
+            return;
+        }
+        this.connected = true;
+        await this.connectionListeners.onConnected('mqtt-' + this.mqttUsername);
+        this.subscribeToQueue();
+    }
+    subscribeToQueue() {
+        if (!this.mqttClient || !this.connected) {
+            return;
+        }
+        this.mqttClient.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
+    }
+    async onSubscribe(err, granted) {
+        if (!err) {
+            this.logger.info('onSubscribe: ' + JSON.stringify(granted));
+            return;
+        }
+        this.logger.error('failed to subscribe: ' + err);
+        this.connected = false;
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Failed to subscribe to the queue: ' + err.toString());
+    }
+    async onDisconnect() {
+        this.connected = false;
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Disconnected from MQTT broker');
+    }
+    async onError(result) {
+        this.logger.error('MQTT connection error: ' + result);
+        this.connected = false;
+        await this.connectionListeners.onError('mqtt-' + this.mqttUsername, result.toString());
+    }
+    async onClose() {
+        if (this.connected) {
+            await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection closed');
+        }
+        this.connected = false;
+    }
+    async onOffline() {
+        this.connected = false;
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection offline');
+    }
+    onReconnect() {
+        this.subscribeToQueue();
+        this.connectionListeners.onReconnect('mqtt-' + this.mqttUsername, 'Reconnected to MQTT broker');
+    }
+    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('MQTTClient: unable to process message with error: ' + topic + ': ' + error);
+        }
+    }
+}

package/dist/roborockCommunication/broadcast/client.js

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

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -0,0 +1,82 @@
+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;
+    localClients = new Map();
+    logger;
+    mqttClient;
+    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, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
+    }
+    updateNonce(duid, nonce) {
+        this.context.updateNonce(duid, nonce);
+    }
+    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) => {
+            client.connect();
+        });
+    }
+    async disconnect() {
+        await this.mqttClient.disconnect();
+        this.localClients.forEach((client) => {
+            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,26 @@
+export class ChainedConnectionListener {
+    listeners = [];
+    register(listener) {
+        this.listeners.push(listener);
+    }
+    async onConnected(duid) {
+        for (const listener of this.listeners) {
+            await listener.onConnected(duid);
+        }
+    }
+    async onDisconnected(duid, message) {
+        for (const listener of this.listeners) {
+            await listener.onDisconnected(duid, message);
+        }
+    }
+    async onError(duid, message) {
+        for (const listener of this.listeners) {
+            await listener.onError(duid, message);
+        }
+    }
+    async onReconnect(duid, message) {
+        for (const listener of this.listeners) {
+            await listener.onReconnect(duid, 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/connectionStateListener.js

@@ -0,0 +1,43 @@
+export class ConnectionStateListener {
+    logger;
+    client;
+    clientName;
+    shouldReconnect;
+    constructor(logger, client, clientName, shouldReconnect = false) {
+        this.logger = logger;
+        this.client = client;
+        this.clientName = clientName;
+        this.shouldReconnect = shouldReconnect;
+    }
+    async onConnected(duid) {
+        this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
+    }
+    async onReconnect(duid, message) {
+        this.logger.info(`Device ${duid} reconnected to ${this.clientName} with message: ${message}`);
+    }
+    async onDisconnected(duid, message) {
+        this.logger.error(`Device ${duid} disconnected from ${this.clientName} with message: ${message}`);
+        if (!this.shouldReconnect) {
+            this.logger.notice(`Device ${duid} disconnected from ${this.clientName}, but re-registration is disabled.`);
+            return;
+        }
+        if (this.client.retryCount > 10) {
+            this.logger.error(`Device with DUID ${duid} has exceeded retry limit, not re-registering.`);
+            return;
+        }
+        this.client.retryCount++;
+        const isInDisconnectingStep = this.client.isInDisconnectingStep;
+        if (isInDisconnectingStep) {
+            this.logger.info(`Device with DUID ${duid} is in disconnecting step, skipping re-registration.`);
+            return;
+        }
+        setTimeout(() => {
+            this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
+            this.client.connect();
+        }, 10000);
+        this.client.isInDisconnectingStep = false;
+    }
+    async onError(duid, message) {
+        this.logger.error(`Error on device with DUID ${duid}: ${message}`);
+    }
+}

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

@@ -0,0 +1,28 @@
+import { Protocol } from '../../model/protocol.js';
+export class GeneralSyncMessageListener {
+    duid;
+    handler;
+    timer;
+    constructor(duid) {
+        this.duid = duid;
+    }
+    waitFor() {
+        return new Promise((resolve, reject) => {
+            this.handler = resolve;
+            this.timer = setTimeout(() => {
+                reject('no ping response received for ' + this.duid + ' within ' + 30 + 'second');
+            }, 30 * 1000);
+        });
+    }
+    async onMessage(message) {
+        if (message.contain(Protocol.hello_response)) {
+            if (this.handler) {
+                this.handler(message);
+            }
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer.unref();
+            }
+        }
+    }
+}

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));
+        }
+    }
+}