matterbridge-roborock-vacuum-plugin/dist/roborockCommunication/broadcast/clientRouter.js

Matterbridge Roborock Vacuum Plugin

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