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

package/src/roborockCommunication/broadcast/client/LocalNetworkUDPClient.ts

@@ -0,0 +1,157 @@
+import * as dgram from 'node:dgram';
+import { Socket } from 'node:dgram';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { AnsiLogger } from 'matterbridge/logger';
+import { AbstractClient } from '../abstractClient.js';
+import { RequestMessage, ResponseMessage } from '../../index.js';
+import { MessageContext } from '../model/messageContext.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class LocalNetworkUDPClient extends AbstractClient {
+  protected override clientName = 'LocalNetworkUDPClient';
+  protected override shouldReconnect = false;
+
+  private readonly PORT = 58866;
+  private server: Socket | undefined = undefined;
+
+  private readonly V10Parser: Parser;
+  private readonly L01Parser: Parser;
+
+  constructor(logger: AnsiLogger, context: MessageContext) {
+    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;
+  }
+
+  public connect(): void {
+    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;
+    }
+  }
+
+  public disconnect(): Promise<void> {
+    if (this.server) {
+      return new Promise<void>((resolve) => {
+        this.server?.close(() => {
+          this.server = undefined;
+          resolve();
+        });
+      });
+    }
+
+    return Promise.resolve();
+  }
+
+  public override send(duid: string, request: RequestMessage): Promise<void> {
+    this.logger.debug(`Sending request to ${duid}: ${JSON.stringify(request)}`);
+    return Promise.resolve();
+  }
+
+  private async onError(result: any) {
+    this.logger.error(`UDP socket error: ${result}`);
+
+    if (this.server) {
+      this.server.close();
+      this.server = undefined;
+    }
+  }
+
+  private async onMessage(buffer: Buffer) {
+    const message = await this.deserializeMessage(buffer);
+    this.logger.debug('Received message: ' + JSON.stringify(message));
+  }
+
+  private async deserializeMessage(buffer: Buffer): Promise<ResponseMessage | undefined> {
+    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':
+        // TODO: Implement A01 deserialization
+        return undefined; // Placeholder for A01 deserialization
+      default:
+        throw new Error('unknown protocol version ' + version);
+    }
+  }
+
+  private async deserializeV10Message(message: Buffer<ArrayBufferLike>): Promise<string> {
+    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);
+  }
+
+  private async deserializeL01Message(message: Buffer<ArrayBufferLike>): Promise<string> {
+    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: unknown) {
+      const message = e && typeof e === 'object' && 'message' in e ? (e as any).message : String(e);
+      throw new Error('failed to decrypt: ' + message + ' / iv: ' + iv.toString('hex') + ' / tag: ' + tag.toString('hex') + ' / encrypted: ' + ciphertext.toString('hex'));
+    }
+  }
+}

package/src/roborockCommunication/broadcast/client/MQTTClient.ts

@@ -0,0 +1,174 @@
+import mqtt, { ErrorWithReasonCode, IConnackPacket, ISubscriptionGrant, MqttClient as MqttLibClient } from 'mqtt';
+import * as CryptoUtils from '../../helper/cryptoHelper.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { AbstractClient } from '../abstractClient.js';
+import { MessageContext } from '../model/messageContext.js';
+import { Rriot, UserData } from '../../Zmodel/userData.js';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+
+export class MQTTClient extends AbstractClient {
+  protected override clientName = 'MQTTClient';
+  protected override shouldReconnect = false;
+
+  private readonly rriot: Rriot;
+  private readonly mqttUsername: string;
+  private readonly mqttPassword: string;
+  private mqttClient: MqttLibClient | undefined = undefined;
+  private keepConnectionAliveInterval: NodeJS.Timeout | undefined = undefined;
+
+  public constructor(logger: AnsiLogger, context: MessageContext, userdata: 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();
+  }
+
+  public connect(): void {
+    if (this.mqttClient) {
+      return; // Already connected
+    }
+
+    this.mqttClient = mqtt.connect(this.rriot.r.m, {
+      clientId: this.mqttUsername,
+      username: this.mqttUsername,
+      password: this.mqttPassword,
+      keepalive: 30,
+      log: () => {
+        // ...args: unknown[] this.logger.debug(`MQTTClient args: ${debugStringify(args)}`);
+      },
+    });
+
+    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();
+  }
+
+  public async disconnect(): Promise<void> {
+    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);
+    }
+  }
+
+  public async send(duid: string, request: RequestMessage): Promise<void> {
+    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}`);
+  }
+
+  private keepConnectionAlive(): void {
+    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,
+    );
+  }
+
+  private async onConnect(result: IConnackPacket): Promise<void> {
+    if (!result) {
+      return;
+    }
+
+    this.connected = true;
+    await this.connectionListeners.onConnected('mqtt-' + this.mqttUsername);
+    this.subscribeToQueue();
+  }
+
+  private subscribeToQueue(): void {
+    if (!this.mqttClient || !this.connected) {
+      return;
+    }
+
+    this.mqttClient.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
+  }
+
+  private async onSubscribe(err: Error | null, granted: ISubscriptionGrant[] | undefined): Promise<void> {
+    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());
+  }
+
+  private async onDisconnect(): Promise<void> {
+    this.connected = false;
+    await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Disconnected from MQTT broker');
+  }
+
+  private async onError(result: Error | ErrorWithReasonCode): Promise<void> {
+    this.logger.error('MQTT connection error: ' + result);
+    this.connected = false;
+
+    await this.connectionListeners.onError('mqtt-' + this.mqttUsername, result.toString());
+  }
+
+  private async onClose(): Promise<void> {
+    if (this.connected) {
+      await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection closed');
+    }
+
+    this.connected = false;
+  }
+
+  private async onOffline(): Promise<void> {
+    this.connected = false;
+    await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection offline');
+  }
+
+  private onReconnect(): void {
+    this.subscribeToQueue();
+    this.connectionListeners.onReconnect('mqtt-' + this.mqttUsername, 'Reconnected to MQTT broker');
+  }
+
+  private async onMessage(topic: string, message: Buffer<ArrayBufferLike>): Promise<void> {
+    if (!message) {
+      // Ignore empty messages
+      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/src/roborockCommunication/broadcast/client.ts

@@ -0,0 +1,19 @@
+import { AbstractConnectionListener } from './listener/abstractConnectionListener.js';
+import { AbstractMessageListener } from './listener/abstractMessageListener.js';
+import { RequestMessage } from './model/requestMessage.js';
+
+export interface Client {
+  registerConnectionListener(listener: AbstractConnectionListener): void;
+
+  registerMessageListener(listener: AbstractMessageListener): void;
+
+  isConnected(): boolean;
+
+  connect(): void;
+
+  disconnect(): Promise<void>;
+
+  send(duid: string, request: RequestMessage): Promise<void>;
+
+  get<T>(duid: string, request: RequestMessage): Promise<T | undefined>;
+}

package/src/roborockCommunication/broadcast/clientRouter.ts

@@ -0,0 +1,104 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { AbstractConnectionListener } from './listener/abstractConnectionListener.js';
+import { AbstractMessageListener } from './listener/abstractMessageListener.js';
+import { RequestMessage } from './model/requestMessage.js';
+import { UserData } from '../Zmodel/userData.js';
+import { Client } from './client.js';
+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 implements Client {
+  protected readonly connectionListeners = new ChainedConnectionListener();
+  protected readonly messageListeners = new ChainedMessageListener();
+
+  private readonly context: MessageContext;
+  private readonly localClients = new Map<string, LocalNetworkClient>();
+  private readonly logger: AnsiLogger;
+  private mqttClient: MQTTClient;
+
+  public constructor(logger: AnsiLogger, userdata: 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);
+  }
+
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void {
+    this.context.registerDevice(duid, localKey, pv, nonce);
+  }
+
+  public updateNonce(duid: string, nonce: number): void {
+    this.context.updateNonce(duid, nonce);
+  }
+
+  public registerClient(duid: string, ip: string): Client {
+    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;
+  }
+
+  public unregisterClient(duid: string): void {
+    this.localClients.delete(duid);
+  }
+
+  public registerConnectionListener(listener: AbstractConnectionListener): void {
+    this.connectionListeners.register(listener);
+  }
+
+  public registerMessageListener(listener: AbstractMessageListener): void {
+    this.messageListeners.register(listener);
+  }
+
+  public isConnected(): boolean {
+    return this.mqttClient.isConnected();
+  }
+
+  public connect(): void {
+    this.mqttClient.connect();
+
+    this.localClients.forEach((client) => {
+      client.connect();
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    await this.mqttClient.disconnect();
+
+    this.localClients.forEach((client) => {
+      client.disconnect();
+    });
+  }
+
+  async send(duid: string, request: RequestMessage): Promise<void> {
+    if (request.secure) {
+      await this.mqttClient.send(duid, request);
+    } else {
+      await this.getClient(duid).send(duid, request);
+    }
+  }
+
+  async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
+    if (request.secure) {
+      return await this.mqttClient.get(duid, request);
+    } else {
+      return await this.getClient(duid).get(duid, request);
+    }
+  }
+
+  private getClient(duid: string): Client {
+    const localClient = this.localClients.get(duid);
+    if (localClient === undefined || !localClient.isConnected()) {
+      return this.mqttClient;
+    } else {
+      return localClient;
+    }
+  }
+}

package/src/roborockCommunication/broadcast/listener/abstractConnectionListener.ts

@@ -0,0 +1,6 @@
+export interface AbstractConnectionListener {
+  onConnected(duid: string): Promise<void>;
+  onDisconnected(duid: string, message: string): Promise<void>;
+  onError(duid: string, message: string): Promise<void>;
+  onReconnect(duid: string, message: string): Promise<void>;
+}

package/src/roborockCommunication/broadcast/listener/abstractMessageHandler.ts

@@ -0,0 +1,11 @@
+import { VacuumErrorCode } from '../../Zenum/vacuumAndDockErrorCode.js';
+
+/*
+  Skeleton only, implementation is no needed
+*/
+export interface AbstractMessageHandler {
+  onError(error: VacuumErrorCode): Promise<void>;
+  onBatteryUpdate(percentage: number): Promise<void>;
+  onStatusChanged(): Promise<void>;
+  onAdditionalProps(value: number): Promise<void>;
+}

package/src/roborockCommunication/broadcast/listener/abstractMessageListener.ts

@@ -0,0 +1,5 @@
+import { ResponseMessage } from '../model/responseMessage.js';
+
+export interface AbstractMessageListener {
+  onMessage(message: ResponseMessage): Promise<void>;
+}

package/src/roborockCommunication/broadcast/listener/implementation/chainedConnectionListener.ts

@@ -0,0 +1,33 @@
+import { AbstractConnectionListener } from '../abstractConnectionListener.js';
+
+export class ChainedConnectionListener implements AbstractConnectionListener {
+  private listeners: AbstractConnectionListener[] = [];
+
+  public register(listener: AbstractConnectionListener): void {
+    this.listeners.push(listener);
+  }
+
+  public async onConnected(duid: string): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onConnected(duid);
+    }
+  }
+
+  public async onDisconnected(duid: string, message: string): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onDisconnected(duid, message);
+    }
+  }
+
+  public async onError(duid: string, message: string): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onError(duid, message);
+    }
+  }
+
+  public async onReconnect(duid: string, message: string): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onReconnect(duid, message);
+    }
+  }
+}

package/src/roborockCommunication/broadcast/listener/implementation/chainedMessageListener.ts

@@ -0,0 +1,16 @@
+import { ResponseMessage } from '../../model/responseMessage.js';
+import { AbstractMessageListener } from '../abstractMessageListener.js';
+
+export class ChainedMessageListener implements AbstractMessageListener {
+  private listeners: AbstractMessageListener[] = [];
+
+  public register(listener: AbstractMessageListener): void {
+    this.listeners.push(listener);
+  }
+
+  public async onMessage(message: ResponseMessage): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onMessage(message);
+    }
+  }
+}

package/src/roborockCommunication/broadcast/listener/implementation/connectionStateListener.ts

@@ -0,0 +1,57 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { AbstractConnectionListener } from '../abstractConnectionListener.js';
+import { AbstractClient } from '../../abstractClient.js';
+
+export class ConnectionStateListener implements AbstractConnectionListener {
+  protected logger: AnsiLogger;
+  protected client: AbstractClient;
+  protected clientName: string;
+  protected shouldReconnect: boolean;
+
+  constructor(logger: AnsiLogger, client: AbstractClient, clientName: string, shouldReconnect = false) {
+    this.logger = logger;
+    this.client = client;
+    this.clientName = clientName;
+    this.shouldReconnect = shouldReconnect;
+  }
+
+  public async onConnected(duid: string): Promise<void> {
+    this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
+  }
+
+  public async onReconnect(duid: string, message: string): Promise<void> {
+    this.logger.info(`Device ${duid} reconnected to ${this.clientName} with message: ${message}`);
+  }
+
+  public async onDisconnected(duid: string, message: string): Promise<void> {
+    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;
+  }
+
+  public async onError(duid: string, message: string): Promise<void> {
+    this.logger.error(`Error on device with DUID ${duid}: ${message}`);
+  }
+}

package/src/roborockCommunication/broadcast/listener/implementation/generalSyncMessageListener.ts

@@ -0,0 +1,38 @@
+import { Protocol } from '../../model/protocol.js';
+import { ResponseMessage } from '../../model/responseMessage.js';
+import { AbstractMessageListener } from '../abstractMessageListener.js';
+
+export class GeneralSyncMessageListener implements AbstractMessageListener {
+  private readonly duid: string;
+
+  private handler?: (data: ResponseMessage) => void;
+  private timer?: NodeJS.Timeout;
+
+  constructor(duid: string) {
+    this.duid = duid;
+  }
+
+  public waitFor(): Promise<ResponseMessage> {
+    return new Promise<ResponseMessage>((resolve, reject) => {
+      this.handler = resolve;
+      this.timer = setTimeout(() => {
+        reject('no ping response received for ' + this.duid + ' within ' + 30 + 'second');
+      }, 30 * 1000);
+    });
+  }
+
+  public async onMessage(message: ResponseMessage): Promise<void> {
+    if (message.contain(Protocol.hello_response)) {
+      // trigger our waiters that we have received the response.
+      if (this.handler) {
+        this.handler(message);
+      }
+
+      // cleanup the timer
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer.unref();
+      }
+    }
+  }
+}

package/src/roborockCommunication/broadcast/listener/implementation/simpleMessageListener.ts

@@ -0,0 +1,37 @@
+import { ResponseMessage } from '../../model/responseMessage.js';
+import { AbstractMessageListener } from '../index.js';
+import { Protocol } from '../../model/protocol.js';
+import { AbstractMessageHandler } from '../abstractMessageHandler.js';
+
+export class SimpleMessageListener implements AbstractMessageListener {
+  private handler: AbstractMessageHandler | undefined;
+
+  public registerListener(handler: AbstractMessageHandler): void {
+    this.handler = handler;
+  }
+
+  public async onMessage(message: ResponseMessage): Promise<void> {
+    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) as string;
+      await this.handler.onError(Number(value));
+    }
+
+    if (message.contain(Protocol.battery) && this.handler.onBatteryUpdate) {
+      const value = message.get(Protocol.battery) as string;
+      await this.handler.onBatteryUpdate(Number(value));
+    }
+
+    if (message.contain(Protocol.additional_props) && this.handler.onAdditionalProps) {
+      const value = message.get(Protocol.additional_props) as string;
+      await this.handler.onAdditionalProps(Number(value));
+    }
+  }
+}