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

Matterbridge Roborock Vacuum Plugin

import { LocalNetworkClient } from '../local/localClient.js';
import { MessageContext } from '../models/index.js';
import { MQTTClient } from '../mqtt/mqttClient.js';
import { ConnectionBroadcaster } from './listeners/connectionBroadcaster.js';
import { ResponseBroadcasterFactory } from './listeners/responseBroadcasterFactory.js';
export class ClientRouter {
    logger;
    connectionBroadcaster;
    broadcasterFactory;
    context;
    localClients = new Map();
    mqttClient;
    constructor(logger, userdata) {
        this.logger = logger;
        this.context = new MessageContext(userdata);
        this.broadcasterFactory = new ResponseBroadcasterFactory(this.context, this.logger);
        this.mqttClient = new MQTTClient(logger, this.context, userdata, this.broadcasterFactory, this.broadcasterFactory);
        this.connectionBroadcaster = new ConnectionBroadcaster(this.logger);
        this.mqttClient.registerConnectionListener(this.connectionBroadcaster);
    }
    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, this.broadcasterFactory, this.broadcasterFactory);
        localClient.registerConnectionListener(this.connectionBroadcaster);
        this.localClients.set(duid, localClient);
        return localClient;
    }
    unregisterClient(duid) {
        this.localClients.delete(duid);
    }
    registerConnectionListener(listener) {
        this.connectionBroadcaster.register(listener);
    }
    registerMessageListener(listener) {
        this.broadcasterFactory.register(listener);
    }
    isConnected() {
        return this.mqttClient.isConnected();
    }
    isReady() {
        return this.mqttClient.isReady();
    }
    connect() {
        this.mqttClient.connect();
        this.localClients.forEach((client) => {
            client.connect();
        });
    }
    async disconnect() {
        await this.mqttClient.disconnect();
        this.connectionBroadcaster.unregister();
        this.broadcasterFactory.unregister();
        this.context.unregisterAllDevices();
        for (const client of this.localClients.values()) {
            await client.disconnect();
        }
    }
    async send(duid, request) {
        if (request.secure) {
            await this.mqttClient.send(duid, request);
        }
        else {
            await this.getLocalClient(duid).send(duid, request);
        }
    }
    async get(duid, request) {
        if (request.secure) {
            return await this.mqttClient.get(duid, request);
        }
        else {
            return await this.getLocalClient(duid).get(duid, request);
        }
    }
    getLocalClient(duid) {
        const localClient = this.localClients.get(duid);
        if (localClient === undefined) {
            return this.mqttClient;
        }
        if (localClient instanceof LocalNetworkClient && localClient.isReconnecting()) {
            this.logger.notice(`[ClientRouter] Local client for ${duid} is reconnecting, falling back to MQTT`);
            return this.mqttClient;
        }
        if (!localClient.isReady()) {
            return this.mqttClient;
        }
        return localClient;
    }
}
//# sourceMappingURL=clientRouter.js.map