@homebridge-plugins/homebridge-sharkiq 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/devices/RoboticVacuumAccessory.js

@@ -0,0 +1,649 @@
+/* global NodeJS */
+import { ERROR_MESSAGES, OperatingModes, PowerModes, Properties } from '../sharkiq-js/properties.js';
+import { BaseMatterAccessory } from './BaseMatterAccessory.js';
+export class RoboticVacuumAccessory extends BaseMatterAccessory {
+    activeTimers = [];
+    sharkDevice;
+    pollInterval;
+    constructor(api, log, sharkDevice, pollIntervalMs) {
+        const serialNumber = (sharkDevice && (sharkDevice.serial_number || sharkDevice._dsn)) || 'VACUUM-001';
+        const displayName = (sharkDevice && (sharkDevice.name || sharkDevice._name)) || 'Robot Vacuum';
+        const manufacturer = sharkDevice ? 'Shark' : 'Homebridge Matter';
+        const model = (sharkDevice && (sharkDevice.vac_model_number || sharkDevice._vac_model_number)) || 'HB-MATTER-VACUUM-ROBOTIC';
+        const firmwareRevision = (sharkDevice && (sharkDevice._firmware_version || 'unknown')) || '2.0.0';
+        // Build serviceArea cluster from device rooms (local helper so we don't use `this` before super)
+        const serviceAreaCluster = (() => {
+            if (!sharkDevice || typeof sharkDevice.get_room_list !== 'function') {
+                return {
+                    supportedMaps: [],
+                    supportedAreas: [],
+                    selectedAreas: [],
+                };
+            }
+            try {
+                const rooms = sharkDevice.get_room_list() || [];
+                const supportedAreas = rooms.map((roomName, idx) => ({
+                    areaId: idx,
+                    mapId: null,
+                    areaInfo: {
+                        locationInfo: {
+                            locationName: roomName,
+                            floorNumber: 0,
+                            areaType: 0,
+                        },
+                        landmarkInfo: null,
+                    },
+                }));
+                return {
+                    supportedMaps: [],
+                    supportedAreas,
+                    selectedAreas: supportedAreas.map(a => a.areaId),
+                };
+            }
+            catch {
+                return {
+                    supportedMaps: [],
+                    supportedAreas: [],
+                    selectedAreas: [],
+                };
+            }
+        })();
+        super(api, log, {
+            uuid: api.matter.uuid.generate(serialNumber),
+            displayName,
+            deviceType: api.matter.deviceTypes.RoboticVacuumCleaner,
+            serialNumber,
+            manufacturer,
+            model,
+            firmwareRevision,
+            hardwareRevision: '1.0.0',
+            // Persist useful metadata in accessory.context so cached accessories retain DSN/model/etc.
+            context: {
+                serialNumber,
+                name: displayName,
+                vacModel: model,
+                vacSerial: (sharkDevice && (sharkDevice.vac_serial_number || sharkDevice._vac_serial_number)) || null,
+                oemModel: (sharkDevice && (sharkDevice.oem_model_number || sharkDevice._oem_model_number)) || null,
+                pollIntervalMs: typeof pollIntervalMs === 'number' ? pollIntervalMs : null,
+            },
+            clusters: {
+                // Run Mode: Controls what the vacuum is doing (Idle, Cleaning, Mapping)
+                rvcRunMode: {
+                    supportedModes: [
+                        { label: 'Idle', mode: 0, modeTags: [{ value: 16384 }] }, // RvcRunMode.ModeTag.Idle
+                        { label: 'Cleaning', mode: 1, modeTags: [{ value: 16385 }] }, // RvcRunMode.ModeTag.Cleaning
+                        { label: 'Mapping', mode: 2, modeTags: [{ value: 16386 }] }, // RvcRunMode.ModeTag.Mapping
+                    ],
+                    currentMode: 0,
+                },
+                // Clean Mode: Controls HOW the vacuum cleans
+                // You can combine semantic tags (0-9) with functional tags (16384-16386)
+                // Available semantic tags: Auto, Quick, Quiet, LowNoise, LowEnergy, Vacation, Min, Max, Night, Day
+                // Available functional tags: DeepClean, Vacuum, Mop
+                rvcCleanMode: {
+                    supportedModes: [
+                        // Basic functional modes
+                        { label: 'Vacuum', mode: 0, modeTags: [{ value: 16385 }] }, // Vacuum
+                        { label: 'Mop', mode: 1, modeTags: [{ value: 16386 }] }, // Mop
+                        { label: 'Vacuum & Mop', mode: 2, modeTags: [{ value: 16385 }, { value: 16386 }] }, // Both
+                        // Deep clean modes
+                        { label: 'Deep Clean', mode: 3, modeTags: [{ value: 16384 }] }, // DeepClean
+                        { label: 'Deep Vacuum', mode: 4, modeTags: [{ value: 16384 }, { value: 16385 }] }, // DeepClean + Vacuum
+                        { label: 'Deep Mop', mode: 5, modeTags: [{ value: 16384 }, { value: 16386 }] }, // DeepClean + Mop
+                        // Intensity modes
+                        { label: 'Quick Clean', mode: 6, modeTags: [{ value: 1 }, { value: 16385 }] }, // Quick + Vacuum
+                        { label: 'Max Clean', mode: 7, modeTags: [{ value: 7 }, { value: 16385 }] }, // Max + Vacuum
+                        { label: 'Min Clean', mode: 8, modeTags: [{ value: 6 }, { value: 16385 }] }, // Min + Vacuum
+                        // Quiet modes
+                        { label: 'Quiet Vacuum', mode: 9, modeTags: [{ value: 2 }, { value: 16385 }] }, // Quiet + Vacuum
+                        { label: 'Quiet Mop', mode: 10, modeTags: [{ value: 2 }, { value: 16386 }] }, // Quiet + Mop
+                        { label: 'Night Mode', mode: 11, modeTags: [{ value: 8 }, { value: 16385 }] }, // Night + Vacuum
+                        // Energy efficient
+                        { label: 'Eco Vacuum', mode: 12, modeTags: [{ value: 4 }, { value: 16385 }] }, // LowEnergy + Vacuum
+                        { label: 'Eco Mop', mode: 13, modeTags: [{ value: 4 }, { value: 16386 }] }, // LowEnergy + Mop
+                        // Auto mode
+                        { label: 'Auto', mode: 14, modeTags: [{ value: 0 }, { value: 16385 }] }, // Auto + Vacuum
+                    ],
+                    currentMode: 0, // start with basic Vacuum
+                },
+                // Operational State: Current state (Stopped, Running, Paused, Error, etc.)
+                rvcOperationalState: {
+                    operationalStateList: [
+                        { operationalStateId: 0 }, // stopped (standard label from Matter spec)
+                        { operationalStateId: 1 }, // running
+                        { operationalStateId: 2 }, // paused
+                        { operationalStateId: 3 }, // error
+                        { operationalStateId: 64 }, // seeking charger
+                        { operationalStateId: 65 }, // charging
+                        { operationalStateId: 66 }, // docked
+                    ],
+                    operationalState: 66, // start docked
+                },
+                // Service Area: Room/zone selection for targeted cleaning
+                serviceArea: serviceAreaCluster,
+            },
+            handlers: {
+                rvcRunMode: {
+                    changeToMode: async (request) => this.handleChangeRunMode(request),
+                },
+                rvcCleanMode: {
+                    changeToMode: async (request) => this.handleChangeCleanMode(request),
+                },
+                rvcOperationalState: {
+                    pause: async () => this.handlePause(),
+                    stop: async () => this.handleStop(),
+                    start: async () => this.handleStart(),
+                    resume: async () => this.handleResume(),
+                    goHome: async () => this.handleGoHome(),
+                },
+                serviceArea: {
+                    selectAreas: async (request) => this.handleSelectAreas(request),
+                    skipArea: async (request) => this.handleSkipArea(request),
+                },
+                // Power / Battery information
+                power: {
+                    batteryLevel: 100,
+                    charging: false,
+                },
+                // Diagnostics / Error reporting
+                diagnostics: {
+                    errorCode: 0,
+                    errorText: '',
+                },
+            },
+        });
+        this.sharkDevice = sharkDevice;
+        // Start polling device state if we have a Shark device and polling is enabled
+        if (this.sharkDevice && typeof pollIntervalMs === 'number' && pollIntervalMs > 0) {
+            this.startPolling(pollIntervalMs);
+        }
+        else if (this.sharkDevice && (typeof pollIntervalMs !== 'number' || pollIntervalMs <= 0)) {
+            // If pollIntervalMs is omitted, default to 30s
+            if (typeof pollIntervalMs !== 'number') {
+                this.startPolling();
+            }
+        }
+        this.logInfo('initialized and ready.');
+    }
+    startPolling(intervalMs = 30000) {
+        if (this.pollInterval) {
+            return;
+        }
+        this.pollInterval = setInterval(async () => {
+            try {
+                // Request a full update
+                await this.sharkDevice.update([]);
+                // Update run/operating mode
+                const opMode = this.sharkDevice.operating_mode?.() ?? null;
+                const powerMode = this.sharkDevice.power_mode?.() ?? null;
+                const docked = this.sharkDevice.docked_status?.() ?? null;
+                // Map operating mode to Matter run/operational state
+                if (docked !== null && docked === 1) {
+                    // Docked
+                    this.updateOperationalState(66);
+                    this.updateRunMode(0);
+                }
+                else if (opMode !== null) {
+                    if (opMode === OperatingModes.START) {
+                        this.updateRunMode(1);
+                        this.updateOperationalState(1);
+                    }
+                    else if (opMode === OperatingModes.PAUSE) {
+                        this.updateOperationalState(2);
+                        this.updateRunMode(1);
+                    }
+                    else if (opMode === OperatingModes.RETURN) {
+                        this.updateOperationalState(64);
+                        this.updateRunMode(0);
+                    }
+                    else if (opMode === OperatingModes.STOP) {
+                        this.updateOperationalState(0);
+                        this.updateRunMode(0);
+                    }
+                }
+                // Map power mode to clean mode (best-effort mapping)
+                if (powerMode !== null) {
+                    let cleanMode = 0; // Vacuum
+                    if (powerMode === PowerModes.ECO) {
+                        cleanMode = 12; // Eco Vacuum
+                    }
+                    else if (powerMode === PowerModes.MAX) {
+                        cleanMode = 7; // Max Clean
+                    }
+                    else {
+                        cleanMode = 0;
+                    }
+                    this.updateCleanMode(cleanMode);
+                }
+                // Update service areas selection from device room list
+                if (typeof this.sharkDevice.get_room_list === 'function') {
+                    const rooms = this.sharkDevice.get_room_list() || [];
+                    const ids = rooms.map((_, idx) => idx);
+                    this.updateSelectedAreas(ids);
+                }
+                // Update battery level, charging and diagnostics using upstream helpers when available
+                try {
+                    // Prefer convenience properties if present on the wrapper
+                    let batteryVal = null;
+                    let chargingVal = null;
+                    let errVal = null;
+                    let errText = null;
+                    if (this.sharkDevice.battery_capacity && typeof this.sharkDevice.battery_capacity === 'function') {
+                        batteryVal = this.sharkDevice.battery_capacity();
+                    }
+                    else if (typeof this.sharkDevice.get_property_value === 'function') {
+                        batteryVal = this.sharkDevice.get_property_value(Properties.BATTERY_CAPACITY);
+                    }
+                    if (this.sharkDevice.charging_status && typeof this.sharkDevice.charging_status === 'function') {
+                        chargingVal = this.sharkDevice.charging_status();
+                    }
+                    else if (typeof this.sharkDevice.get_property_value === 'function') {
+                        chargingVal = this.sharkDevice.get_property_value(Properties.CHARGING_STATUS);
+                    }
+                    // Error code / text
+                    if (this.sharkDevice.error_code !== undefined && typeof this.sharkDevice.error_code === 'function') {
+                        errVal = this.sharkDevice.error_code();
+                        if (this.sharkDevice.error_text && typeof this.sharkDevice.error_text === 'function') {
+                            errText = this.sharkDevice.error_text();
+                        }
+                    }
+                    else if (typeof this.sharkDevice.get_property_value === 'function') {
+                        errVal = this.sharkDevice.get_property_value(Properties.ERROR_CODE);
+                    }
+                    if (batteryVal !== null && typeof batteryVal !== 'undefined') {
+                        const pct = Number(batteryVal) || 0;
+                        // chargingVal may be boolean-like or numeric
+                        const isCharging = chargingVal === 1 || chargingVal === true;
+                        await this.updateState('power', { batteryLevel: Math.max(0, Math.min(100, pct)), charging: isCharging });
+                        this.logInfo(`battery updated: ${pct}% (charging: ${isCharging})`);
+                    }
+                    // RSSI (signal strength) mapping if available
+                    try {
+                        const rssi = this.sharkDevice.get_property_value
+                            ? this.sharkDevice.get_property_value(Properties.RSSI)
+                            : null;
+                        if (rssi !== null && typeof rssi !== 'undefined') {
+                            await this.updateState('diagnostics', { ...null, rssi: Number(rssi) });
+                            this.logInfo(`rssi updated: ${rssi}`);
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                    if (errVal && Number(errVal) > 0) {
+                        const errCode = Number(errVal);
+                        // Prefer human friendly text from device wrapper if provided
+                        const text = errText || ERROR_MESSAGES[errCode] || `Error ${errCode}`;
+                        // Map severity: treat these as actionable errors (set operational state to Error)
+                        await this.updateState('diagnostics', { errorCode: errCode, errorText: text, severity: 'critical' });
+                        this.updateOperationalState(3); // Error
+                        this.logWarn(`device error: ${errCode} - ${text}`);
+                    }
+                    else if (errVal === 0 || errVal === null || typeof errVal === 'undefined') {
+                        await this.updateState('diagnostics', { errorCode: 0, errorText: '', severity: 'ok' });
+                    }
+                    // Clean complete mapping - if device reports a clean complete flag, reflect it
+                    try {
+                        const cleanComplete = this.sharkDevice.get_property_value
+                            ? this.sharkDevice.get_property_value(Properties.CLEAN_COMPLETE)
+                            : null;
+                        if (cleanComplete === 1 || cleanComplete === true) {
+                            // When cleaning completes, set run mode to Idle and operational to Stopped
+                            this.updateRunMode(0);
+                            this.updateOperationalState(0);
+                            this.logInfo('clean complete reported by device - updating state to Idle/Stopped');
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }
+                catch (e) {
+                    this.logDebug('Error updating battery/diagnostics:', e);
+                }
+            }
+            catch (e) {
+                this.logError('Polling error for Shark device:', e);
+            }
+        }, intervalMs);
+    }
+    stopPolling() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = undefined;
+        }
+    }
+    // Helper to build serviceArea cluster from Shark device rooms
+    buildServiceAreaCluster(sharkDevice) {
+        if (!sharkDevice || typeof sharkDevice.get_room_list !== 'function') {
+            return {
+                supportedMaps: [],
+                supportedAreas: [],
+                selectedAreas: [],
+            };
+        }
+        try {
+            const rooms = sharkDevice.get_room_list() || [];
+            const supportedAreas = rooms.map((roomName, idx) => ({
+                areaId: idx,
+                mapId: null,
+                areaInfo: {
+                    locationInfo: {
+                        locationName: roomName,
+                        floorNumber: 0,
+                        areaType: 0,
+                    },
+                    landmarkInfo: null,
+                },
+            }));
+            return {
+                supportedMaps: [],
+                supportedAreas,
+                selectedAreas: supportedAreas.map(a => a.areaId),
+            };
+        }
+        catch (e) {
+            return {
+                supportedMaps: [],
+                supportedAreas: [],
+                selectedAreas: [],
+            };
+        }
+    }
+    async handleChangeRunMode(request) {
+        this.logInfo(`ChangeToMode (run) request received: ${JSON.stringify(request)}`);
+        const { newMode } = request;
+        const modeStr = ['Idle', 'Cleaning', 'Mapping'][newMode] || `Unknown (mode=${newMode})`;
+        this.logInfo(`changing run mode to: ${modeStr}`);
+        if (this.sharkDevice) {
+            try {
+                if (newMode === 1) {
+                    await this.sharkDevice.set_operating_mode(OperatingModes.START);
+                }
+                else if (newMode === 0) {
+                    await this.sharkDevice.set_operating_mode(OperatingModes.STOP);
+                }
+                else if (newMode === 2) {
+                    // Mapping - treat as start for now
+                    await this.sharkDevice.set_operating_mode(OperatingModes.START);
+                }
+            }
+            catch (e) {
+                this.logError('Error setting run mode on Shark device:', e);
+            }
+        }
+        // Clear any existing timers
+        this.clearTimers();
+        if (newMode === 1) {
+            // Switching to Cleaning mode - start the vacuum
+            this.updateOperationalState(1); // Running
+            // Simulate cleaning completion after 15 seconds
+            const completionTimer = setTimeout(() => {
+                this.logInfo('cleaning completed, returning to dock.');
+                this.updateRunMode(0); // Set to Idle - cleaning session ending
+                this.returnToDock();
+            }, 15000);
+            this.activeTimers.push(completionTimer);
+        }
+        else if (newMode === 0) {
+            // Switching to Idle mode - return to dock
+            this.returnToDock();
+        }
+        else if (newMode === 2) {
+            // Switching to Mapping mode - start mapping
+            this.updateOperationalState(1); // Running
+            // Simulate mapping completion after 20 seconds
+            const completionTimer = setTimeout(() => {
+                this.logInfo('mapping completed, returning to dock.');
+                this.returnToDock();
+            }, 20000);
+            this.activeTimers.push(completionTimer);
+        }
+    }
+    async handleChangeCleanMode(request) {
+        this.logInfo(`ChangeToMode (clean) request received: ${JSON.stringify(request)}`);
+        const { newMode } = request;
+        const modes = [
+            'Vacuum',
+            'Mop',
+            'Vacuum & Mop',
+            'Deep Clean',
+            'Deep Vacuum',
+            'Deep Mop',
+            'Quick Clean',
+            'Max Clean',
+            'Min Clean',
+            'Quiet Vacuum',
+            'Quiet Mop',
+            'Night Mode',
+            'Eco Vacuum',
+            'Eco Mop',
+            'Auto',
+        ];
+        const modeStr = modes[newMode] || `Unknown (mode=${newMode})`;
+        this.logInfo(`changing clean mode to: ${modeStr}`);
+        if (this.sharkDevice) {
+            // Shark API doesn't expose a direct clean-mode setter here; keep local state and log.
+            this.logInfo('Clean mode change requested for Shark device (not implemented in API wrapper).');
+        }
+    }
+    async handlePause() {
+        this.logInfo('pausing.');
+        if (this.sharkDevice) {
+            try {
+                await this.sharkDevice.set_operating_mode(OperatingModes.PAUSE);
+            }
+            catch (e) {
+                this.logError('Error pausing Shark device:', e);
+            }
+        }
+        this.clearTimers(); // Clear cleaning completion timer
+        this.updateOperationalState(2); // Paused
+    }
+    async handleStop() {
+        this.logInfo('stopping.');
+        if (this.sharkDevice) {
+            try {
+                await this.sharkDevice.set_operating_mode(OperatingModes.STOP);
+            }
+            catch (e) {
+                this.logError('Error stopping Shark device:', e);
+            }
+        }
+        this.clearTimers();
+        this.updateRunMode(0); // Reset to Idle
+        this.updateOperationalState(0); // Stopped
+    }
+    async handleStart() {
+        this.logInfo('starting (via start command).');
+        if (this.sharkDevice) {
+            try {
+                await this.sharkDevice.set_operating_mode(OperatingModes.START);
+            }
+            catch (e) {
+                this.logError('Error starting Shark device:', e);
+            }
+        }
+        // Clear any existing timers
+        this.clearTimers();
+        this.updateRunMode(1); // Set to Cleaning mode - this will trigger the run mode handler logic
+        this.updateOperationalState(1); // Running
+        // Simulate cleaning completion after 15 seconds
+        const completionTimer = setTimeout(() => {
+            this.logInfo('cleaning completed, returning to dock.');
+            this.updateRunMode(0); // Set to Idle - cleaning session ending
+            this.returnToDock();
+        }, 15000);
+        this.activeTimers.push(completionTimer);
+    }
+    async handleResume() {
+        this.logInfo('resuming.');
+        if (this.sharkDevice) {
+            try {
+                await this.sharkDevice.set_operating_mode(OperatingModes.START);
+            }
+            catch (e) {
+                this.logError('Error resuming Shark device:', e);
+            }
+        }
+        // Clear any existing timers
+        this.clearTimers();
+        this.updateRunMode(1); // Set to Cleaning mode
+        this.updateOperationalState(1); // Running
+        // Simulate cleaning completion after 10 seconds (shorter since resuming)
+        const completionTimer = setTimeout(() => {
+            this.logInfo('cleaning completed, returning to dock.');
+            this.updateRunMode(0); // Set to Idle - cleaning session ending
+            this.returnToDock();
+        }, 10000);
+        this.activeTimers.push(completionTimer);
+    }
+    async handleGoHome() {
+        this.logInfo('goHome command received.');
+        if (this.sharkDevice) {
+            try {
+                await this.sharkDevice.set_operating_mode(OperatingModes.RETURN);
+            }
+            catch (e) {
+                this.logError('Error sending Shark device home:', e);
+            }
+        }
+        // Clear any existing timers
+        this.clearTimers();
+        // Defer state updates to ensure handler completes first
+        setImmediate(() => {
+            // Set to Idle mode since we're ending the cleaning session
+            this.updateRunMode(0);
+            // Initiate return to dock sequence
+            this.returnToDock();
+        });
+    }
+    async handleSelectAreas(request) {
+        this.logInfo(`SelectAreas request received: ${JSON.stringify(request)}`);
+        const { newAreas } = request;
+        if (this.sharkDevice && typeof this.sharkDevice.get_room_list === 'function') {
+            try {
+                const rooms = this.sharkDevice.get_room_list() || [];
+                const selected = newAreas.map((id) => rooms[id]).filter(Boolean);
+                this.logInfo(`selecting areas: ${selected.join(', ')}`);
+                if (selected.length > 0) {
+                    await this.sharkDevice.clean_rooms(selected);
+                }
+            }
+            catch (e) {
+                this.logError('Error selecting areas on Shark device:', e);
+            }
+        }
+        else {
+            const areaNames = newAreas.map((id) => ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][id] || `Area ${id}`);
+            this.logInfo(`selecting areas: ${areaNames.join(', ')}`);
+        }
+    }
+    async handleSkipArea(request) {
+        this.logInfo(`SkipArea request received: ${JSON.stringify(request)}`);
+        const { skippedArea } = request;
+        const areaName = ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][skippedArea] || `Area ${skippedArea}`;
+        this.logInfo(`skipping area: ${areaName}`);
+        // Shark API does not provide skipArea; best-effort: log and leave running session intact.
+    }
+    /**
+     * Helper method to clear all active timers
+     */
+    clearTimers() {
+        this.activeTimers.forEach(timer => clearTimeout(timer));
+        this.activeTimers = [];
+    }
+    /**
+     * Helper method to initiate return to dock sequence
+     * Can be called synchronously from other handlers
+     */
+    returnToDock() {
+        this.logInfo('initiating return to dock sequence.');
+        // Defer ALL state updates to ensure handler completes first
+        setImmediate(() => {
+            // Start seeking charger directly (skip intermediate Stopped state)
+            this.updateOperationalState(64); // Seeking Charger
+            // After 5 seconds, start charging
+            const chargingTimer = setTimeout(() => {
+                this.logInfo('reached dock, now charging.');
+                this.updateOperationalState(65); // Charging
+                // After 3 more seconds, fully docked
+                const dockedTimer = setTimeout(() => {
+                    this.logInfo('fully charged and docked.');
+                    this.updateOperationalState(66); // Docked
+                }, 3000);
+                this.activeTimers.push(dockedTimer);
+            }, 5000);
+            this.activeTimers.push(chargingTimer);
+        });
+    }
+    /**
+     * Update Methods - Use these to update the vacuum state from your API/device
+     *
+     * Since this is a platform accessory, state updates work immediately after registration.
+     */
+    updateOperationalState(state) {
+        this.updateState('rvcOperationalState', { operationalState: state });
+        const states = [
+            'Stopped',
+            'Running',
+            'Paused',
+            'Error',
+            null,
+            null,
+            null,
+            null,
+            ...Array.from({ length: 56 }).fill(null),
+            'Seeking Charger',
+            'Charging',
+            'Docked',
+        ];
+        this.logInfo(`operational state updated to: ${states[state] || `Unknown (${state})`}`);
+    }
+    updateRunMode(mode) {
+        this.updateState('rvcRunMode', { currentMode: mode });
+        const modes = ['Idle', 'Cleaning', 'Mapping'];
+        this.logInfo(`run mode updated to: ${modes[mode] || `Unknown (${mode})`}`);
+    }
+    updateCleanMode(mode) {
+        this.updateState('rvcCleanMode', { currentMode: mode });
+        const modes = [
+            'Vacuum',
+            'Mop',
+            'Vacuum & Mop',
+            'Deep Clean',
+            'Deep Vacuum',
+            'Deep Mop',
+            'Quick Clean',
+            'Max Clean',
+            'Min Clean',
+            'Quiet Vacuum',
+            'Quiet Mop',
+            'Night Mode',
+            'Eco Vacuum',
+            'Eco Mop',
+            'Auto',
+        ];
+        this.logInfo(`clean mode updated to: ${modes[mode] || `Unknown (${mode})`}`);
+    }
+    updateSelectedAreas(areaIds) {
+        this.updateState('serviceArea', { selectedAreas: areaIds });
+        const areaNames = areaIds.map(id => ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][id] || `Area ${id}`);
+        this.logInfo(`selected areas updated to: ${areaNames.join(', ') || 'All Areas'}`);
+    }
+    updateCurrentArea(areaId) {
+        this.updateState('serviceArea', { currentArea: areaId });
+        if (areaId !== null) {
+            const areaName = ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][areaId] || `Area ${areaId}`;
+            this.logInfo(`current area updated to: ${areaName}`);
+        }
+        else {
+            this.logInfo('current area cleared');
+        }
+    }
+    updateProgress(progress) {
+        this.updateState('serviceArea', { progress });
+        this.logInfo(`progress updated: ${progress.length} areas`);
+    }
+}
+//# sourceMappingURL=RoboticVacuumAccessory.js.map