matterbridge-roborock-vacuum-plugin/dist/roborockCommunication/protocol/dispatcher/Q10MessageDispatcher.js

Matterbridge Roborock Vacuum Plugin

import { CleanModeSetting } from '../../../behaviors/roborock.vacuum/core/CleanModeSetting.js';
import { CleanSequenceType } from '../../../behaviors/roborock.vacuum/enums/CleanSequenceType.js';
import { MapInfo } from '../../../core/application/models/index.js';
import { Q10RequestCode, Q10RequestMethod } from '../../enums/Q10RequestCode.js';
import { B01VacuumModeResolver } from '../../helper/B01VacuumModeResolver.js';
import { RequestMessage } from '../../models/requestMessage.js';
export class Q10MessageDispatcher {
    logger;
    client;
    dispatcherName = 'Q10MessageDispatcher';
    supportsMapQueryResponse = false;
    lastB01Id;
    get messageId() {
        let tmpMessageId = Math.floor(Date.now() / 1000);
        if (tmpMessageId <= this.lastB01Id) {
            tmpMessageId = this.lastB01Id + 1;
        }
        this.lastB01Id = tmpMessageId;
        return this.lastB01Id;
    }
    constructor(logger, client) {
        this.logger = logger;
        this.client = client;
        this.lastB01Id = Math.floor(Date.now() / 1000);
    }
    async getNetworkInfo(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.dps_request]: 1 } });
        await this.client.send(duid, request);
        return undefined;
    }
    async getSerialNumber(duid) {
        return duid;
    }
    getDeviceStatus(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.dps_request]: 1 } });
        return this.client.send(duid, request);
    }
    // #region Core Data Retrieval
    async getHomeMap(duid) {
        return {}; // TODO: Implement home map retrieval for Q10
    }
    async getMapInfo(duid) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: { [Q10RequestCode.common_request]: { [Q10RequestMethod.multimap]: { 'op': 'list' } } },
        });
        await this.client.send(duid, request);
        return new MapInfo({ max_multi_map: 0, max_bak_map: 0, multi_map_count: 0, map_info: [] });
    }
    getMapInfoV2(duid) {
        return this.client.send(duid, new RequestMessage({
            messageId: this.messageId,
            dps: { [Q10RequestCode.common_request]: { [Q10RequestMethod.multimap]: { 'op': 'list' } } },
        }));
    }
    async getRoomMap(duid, _activeMap) {
        await this.client.send(duid, new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.get_prop]: 1 } }));
        return [];
    }
    getRoomMapV2(duid, _activeMap) {
        return this.client.send(duid, new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.get_prop]: 1 } }));
    }
    switchMap(duid, mapId) {
        return this.client.send(duid, new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.multi_map_switch]: mapId } }));
    }
    // #endregion Core Data Retrieval
    // #region Cleaning Commands
    goHome(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.app_charge]: 0 } });
        return this.client.send(duid, request);
    }
    startCleaning(duid) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: { [Q10RequestCode.app_start]: { 'cmd': 1 } },
        });
        return this.client.send(duid, request);
    }
    startRoomCleaning(duid, roomIds, repeat) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: { [Q10RequestCode.app_start]: { 'cmd': 2, 'clean_paramters': roomIds } },
        });
        return this.client.send(duid, request);
    }
    pauseCleaning(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.app_pause]: 0 } });
        return this.client.send(duid, request);
    }
    resumeCleaning(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.app_resume]: 0 } });
        return this.client.send(duid, request);
    }
    resumeRoomCleaning(duid) {
        return this.resumeCleaning(duid);
    }
    skipRoomCleaning(duid) {
        throw new Error(`skipRoomCleaning is not supported on ${this.dispatcherName}`);
    }
    stopCleaning(duid) {
        const request = new RequestMessage({ messageId: this.messageId, dps: { [Q10RequestCode.app_stop]: 0 } });
        return this.client.send(duid, request);
    }
    findMyRobot(duid) {
        // TODO: Verify the command for Q10
        const request = new RequestMessage({ messageId: this.messageId, method: 'find_me' });
        return this.client.send(duid, request);
    }
    sendCustomMessage(duid, def) {
        const request = new RequestMessage({ ...def, messageId: this.messageId });
        return this.client.send(duid, request);
    }
    async getCustomMessage(duid, def) {
        const request = new RequestMessage({ ...def, messageId: this.messageId });
        const result = await this.client.query(duid, request, (msg) => {
            if (!msg.body)
                return undefined;
            const data = msg.body.data;
            if (!data)
                return undefined;
            const values = Object.values(data);
            return values.length > 0 ? values[0] : undefined;
        });
        return result;
    }
    async getCleanModeData(duid) {
        return new CleanModeSetting(0, 0, 0, 0, CleanSequenceType.Persist); // TODO: Implement retrieval of clean mode data for Q10
    }
    async changeCleanMode(duid, setting) {
        const { suctionPower, waterFlow, distance_off, mopRoute } = setting;
        this.logger?.notice(`Change clean mode for ${duid} to suctionPower: ${suctionPower}, waterFlow: ${waterFlow}, mopRoute: ${mopRoute}, distance_off: ${distance_off}`);
        await this.setCleanMode(duid, suctionPower, waterFlow);
        if (suctionPower !== 0) {
            await this.setVacuumMode(duid, suctionPower);
        }
        if (waterFlow !== 0) {
            await this.setWaterMode(duid, waterFlow);
        }
    }
    // #endregion Cleaning Commands
    // #region Private Helpers
    setCleanMode(duid, suctionPower, waterFlow) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: {
                [Q10RequestMethod.change_clean_mode]: B01VacuumModeResolver.resolveQ10CleanMode(suctionPower, waterFlow),
            },
        });
        return this.client.send(duid, request);
    }
    setVacuumMode(duid, mode) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: {
                [Q10RequestMethod.change_vacuum_mode]: B01VacuumModeResolver.resolveQ10VacuumMode(mode),
            },
        });
        return this.client.send(duid, request);
    }
    setWaterMode(duid, mode) {
        const request = new RequestMessage({
            messageId: this.messageId,
            dps: {
                [Q10RequestMethod.change_mop_mode]: B01VacuumModeResolver.resolveMopMode(mode),
            },
        });
        return this.client.send(duid, request);
    }
}
//# sourceMappingURL=Q10MessageDispatcher.js.map