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

Matterbridge Roborock Vacuum Plugin

import { MessageDeserializer } from '../protocol/deserializers/messageDeserializer.js';
import { MessageSerializer } from '../protocol/serializers/messageSerializer.js';
import { ConnectionBroadcaster } from './listeners/connectionBroadcaster.js';
import { ConnectionStateListener } from './listeners/implementation/connectionStateListener.js';
import { OneShotResponseListener } from './listeners/oneShotResponseListener.js';
export class AbstractClient {
    logger;
    context;
    responseBroadcaster;
    isInDisconnectingStep = false;
    retryCount = 0;
    connectionBroadcaster;
    serializer;
    deserializer;
    connectionStateListener;
    constructor(logger, context, responseBroadcaster) {
        this.logger = logger;
        this.context = context;
        this.responseBroadcaster = responseBroadcaster;
        this.serializer = new MessageSerializer(this.context, this.logger);
        this.deserializer = new MessageDeserializer(this.context, this.logger);
        this.connectionBroadcaster = new ConnectionBroadcaster(this.logger);
    }
    isReady() {
        return this.isConnected();
    }
    initializeConnectionStateListener(client) {
        this.connectionStateListener = new ConnectionStateListener(this.logger, client, this.clientName);
        this.connectionBroadcaster.register(this.connectionStateListener);
    }
    registerMessageListener(listener) {
        this.responseBroadcaster.register(listener);
    }
    async send(duid, request) {
        this.sendInternal(duid, request);
    }
    connect() {
        if (this.connectionStateListener) {
            this.connectionStateListener.start();
        }
        this.isInDisconnectingStep = false;
    }
    disconnect() {
        if (this.connectionStateListener) {
            this.connectionStateListener.stop();
        }
        this.isInDisconnectingStep = true;
        return Promise.resolve();
    }
    async query(duid, request, parseFn, timeoutMs) {
        const listener = new OneShotResponseListener(duid, parseFn, timeoutMs);
        this.responseBroadcaster.register(listener);
        try {
            this.sendInternal(duid, request);
            return await listener.waitFor();
        }
        catch (error) {
            this.logger.error(error instanceof Error ? error.message : String(error));
            return undefined;
        }
        finally {
            this.responseBroadcaster.deregister(listener);
        }
    }
    registerDevice(duid, localKey, pv, nonce) {
        this.context.registerDevice(duid, localKey, pv, nonce);
    }
    registerConnectionListener(listener) {
        this.connectionBroadcaster.register(listener);
    }
}
//# sourceMappingURL=abstractClient.js.map