@homebridge-plugins/homebridge-sharkiq 2.0.0-beta.12 → 2.0.0-beta.13

package/dist/devices/RoboticVacuumAccessory.js

@@ -1,86 +1,125 @@
-import { TIMEOUTS } from '../constants.js';
-import { OperatingModes, PowerModes, Properties } from '../sharkiq-js/sharkiq.js';
-const MatterAccessoryEventTypes = globalThis.MatterAccessoryEventTypes || {};
-// Simplified RoboticVacuumAccessory implementation based on the template
-export class RoboticVacuumAccessory {
-    api;
-    log;
-    device;
-    isReady = false;
-    publishedAccessory = null;
-    pollIntervalId = null;
-    dockedDelay = 0;
-    dockedUpdateInterval = TIMEOUTS.DEFAULT_DOCKED_UPDATE_INTERVAL;
-    constructor(api, log, device) {
-        this.api = api;
-        this.log = log;
-        this.device = device;
-    }
-    // Simple retry helper with exponential backoff
-    async retry(fn, attempts = 3, initialDelay = 500) {
-        let lastError;
-        let delay = initialDelay;
-        for (let i = 0; i < attempts; i++) {
-            try {
-                return await fn();
-            }
-            catch (e) {
-                lastError = e;
-                this.log.debug(`Retry ${i + 1}/${attempts} failed:`, e);
-                if (i < attempts - 1) {
-                    await new Promise(res => setTimeout(res, delay));
-                    delay *= 2;
-                }
-            }
-        }
-        throw lastError;
-    }
-    toAccessory() {
-        const serialNumber = this.device._dsn && this.device._dsn.toString ? this.device._dsn.toString() : String(this.device._dsn);
-        const uuid = this.api.matter.uuid.generate(serialNumber);
-        const deviceType = this.api.matter.deviceTypes.RoboticVacuumCleaner;
-        const acc = {
-            uuid,
-            displayName: this.device._name || `Robot Vacuum ${serialNumber}`,
-            deviceType,
+/* global NodeJS */
+import { BaseMatterAccessory } from './BaseMatterAccessory.js';
+export class RoboticVacuumAccessory extends BaseMatterAccessory {
+    activeTimers = [];
+    constructor(api, log) {
+        const serialNumber = 'VACUUM-001';
+        super(api, log, {
+            uuid: api.matter.uuid.generate(serialNumber),
+            displayName: 'Robot Vacuum',
+            deviceType: api.matter.deviceTypes.RoboticVacuumCleaner,
             serialNumber,
-            manufacturer: 'Shark',
-            model: this.device._vac_model_number || 'SharkIQ',
-            firmwareRevision: this.device._firmware_version || '1.0.0',
+            manufacturer: 'Homebridge Matter',
+            model: 'HB-MATTER-VACUUM-ROBOTIC',
+            firmwareRevision: '2.0.0',
             hardwareRevision: '1.0.0',
             clusters: {
+                // Run Mode: Controls what the vacuum is doing (Idle, Cleaning, Mapping)
                 rvcRunMode: {
                     supportedModes: [
-                        { label: 'Idle', mode: 0 },
-                        { label: 'Cleaning', mode: 1 },
-                        { label: 'Mapping', mode: 2 },
+                        { 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: [
-                        { label: 'Vacuum', mode: 0 },
-                        { label: 'Mop', mode: 1 },
-                        { label: 'Vacuum & Mop', mode: 2 },
+                        // 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,
+                    currentMode: 0, // start with basic Vacuum
                 },
+                // Operational State: Current state (Stopped, Running, Paused, Error, etc.)
                 rvcOperationalState: {
                     operationalStateList: [
-                        { operationalStateId: 0, operationalStateLabel: 'Stopped' },
-                        { operationalStateId: 1, operationalStateLabel: 'Running' },
-                        { operationalStateId: 2, operationalStateLabel: 'Paused' },
-                        { operationalStateId: 64, operationalStateLabel: 'Seeking Charger' },
-                        { operationalStateId: 65, operationalStateLabel: 'Charging' },
-                        { operationalStateId: 66, operationalStateLabel: 'Docked' },
+                        { 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: 0,
+                    operationalState: 66, // start docked
                 },
+                // Service Area: Room/zone selection for targeted cleaning
                 serviceArea: {
-                    supportedMaps: [],
-                    supportedAreas: [],
-                    selectedAreas: [],
-                    currentArea: null,
+                    supportedMaps: [], // empty array - we don't use map features
+                    supportedAreas: [
+                        {
+                            areaId: 0,
+                            mapId: null, // required: must be null when supportedMaps is empty
+                            areaInfo: {
+                                locationInfo: {
+                                    locationName: 'Living Room',
+                                    floorNumber: 0,
+                                    areaType: 7, // AreaNamespaceTag.LivingRoom
+                                },
+                                landmarkInfo: null,
+                            },
+                        },
+                        {
+                            areaId: 1,
+                            mapId: null,
+                            areaInfo: {
+                                locationInfo: {
+                                    locationName: 'Kitchen',
+                                    floorNumber: 0,
+                                    areaType: 10, // AreaNamespaceTag.Kitchen
+                                },
+                                landmarkInfo: null,
+                            },
+                        },
+                        {
+                            areaId: 2,
+                            mapId: null,
+                            areaInfo: {
+                                locationInfo: {
+                                    locationName: 'Bedroom',
+                                    floorNumber: 0,
+                                    areaType: 2, // AreaNamespaceTag.Bedroom
+                                },
+                                landmarkInfo: null,
+                            },
+                        },
+                        {
+                            areaId: 3,
+                            mapId: null,
+                            areaInfo: {
+                                locationInfo: {
+                                    locationName: 'Bathroom',
+                                    floorNumber: 0,
+                                    areaType: 6, // AreaNamespaceTag.Bathroom
+                                },
+                                landmarkInfo: null,
+                            },
+                        },
+                    ],
+                    selectedAreas: [0, 1, 2, 3], // all areas selected by default
                 },
             },
             handlers: {
@@ -91,9 +130,9 @@ export class RoboticVacuumAccessory {
                     changeToMode: async (request) => this.handleChangeCleanMode(request),
                 },
                 rvcOperationalState: {
-                    start: async () => this.handleStart(),
-                    stop: async () => this.handleStop(),
                     pause: async () => this.handlePause(),
+                    stop: async () => this.handleStop(),
+                    start: async () => this.handleStart(),
                     resume: async () => this.handleResume(),
                     goHome: async () => this.handleGoHome(),
                 },
@@ -102,266 +141,235 @@ export class RoboticVacuumAccessory {
                     skipArea: async (request) => this.handleSkipArea(request),
                 },
             },
-        };
-        return acc;
+        });
+        this.logInfo('initialized and ready.');
     }
-    // Attach event listeners to the exact published Matter accessory object
-    attachToPublishedAccessory(accessory) {
-        // Keep a reference to the exact published accessory object so we can update clusters later
-        this.publishedAccessory = accessory;
-        try {
-            accessory._eventEmitter?.on(MatterAccessoryEventTypes.READY, async (port) => {
-                this.isReady = true;
-                this.log.info(`Matter accessory ready on port ${port} for ${accessory.displayName}`);
-                // When ready, perform an initial sync to populate state
-                try {
-                    await this.performInitialSync();
-                    // Start periodic polling after initial sync
-                    this.startPolling();
-                }
-                catch (e) {
-                    this.log.debug('performInitialSync error', e);
-                }
-            });
-            accessory._eventEmitter?.on(MatterAccessoryEventTypes.COMMISSIONED, () => {
-                this.log.info(`Matter accessory commissioned: ${accessory.displayName}`);
-            });
-            accessory._eventEmitter?.on(MatterAccessoryEventTypes.DECOMMISSIONED, () => {
-                this.log.warn(`Matter accessory decommissioned: ${accessory.displayName}`);
-            });
-        }
-        catch (e) {
-            this.log.debug('attachToPublishedAccessory error', e);
+    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}`);
+        // TODO: await myVacuumAPI.setRunMode(newMode)
+        // 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);
         }
     }
-    // Perform initial device sync once the Matter accessory is ready
-    async performInitialSync() {
-        try {
-            this.log.debug('Performing initial device sync for Matter accessory', this.device._dsn);
-            if (typeof this.device.update === 'function') {
-                await this.retry(() => this.device.update());
-            }
-            // Update Matter clusters with current device state (power mode, docked status, etc.)
-            await this.updateOperationalState();
-            await this.updateRunMode();
-            await this.updateCleanMode();
-            await this.updateSelectedAreas();
-            await this.updateProgress();
-        }
-        catch (e) {
-            this.log.debug('performInitialSync error', e);
-        }
+    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}`);
+        // TODO: await myVacuumAPI.setCleanMode(newMode)
     }
-    // Start periodic polling for device state
-    startPolling() {
-        if (this.pollIntervalId) {
-            return;
-        }
-        const interval = this.dockedUpdateInterval || TIMEOUTS.DEFAULT_DOCKED_UPDATE_INTERVAL;
-        this.pollIntervalId = setInterval(async () => {
-            try {
-                const maybeDelay = await this.retry(() => this.device.update([Properties.DOCKED_STATUS, Properties.OPERATING_MODE, Properties.POWER_MODE]));
-                if (typeof maybeDelay === 'number') {
-                    this.dockedDelay = maybeDelay;
-                }
-                await this.updateOperationalState();
-                await this.updateRunMode();
-                await this.updateCleanMode();
-                await this.updateSelectedAreas();
-                await this.updateProgress();
-            }
-            catch (e) {
-                this.log.debug('Polling update error', e);
-            }
-        }, interval + this.dockedDelay);
+    async handlePause() {
+        this.logInfo('pausing.');
+        // TODO: await myVacuumAPI.pause()
+        this.clearTimers(); // Clear cleaning completion timer
+        this.updateOperationalState(2); // Paused
     }
-    // Stop periodic polling
-    stopPolling() {
-        if (this.pollIntervalId) {
-            clearInterval(this.pollIntervalId);
-            this.pollIntervalId = null;
-        }
+    async handleStop() {
+        this.logInfo('stopping.');
+        // TODO: await myVacuumAPI.stop()
+        this.clearTimers();
+        this.updateRunMode(0); // Reset to Idle
+        this.updateOperationalState(0); // Stopped
     }
-    // Helper to set cluster values defensively on the published accessory object
-    setClusterValue(clusterName, prop, value) {
-        try {
-            if (!this.publishedAccessory) {
-                return;
-            }
-            // If accessory exposes an update method, prefer it
-            if (typeof this.publishedAccessory.updateCluster === 'function') {
-                this.publishedAccessory.updateCluster(clusterName, { [prop]: value });
-                return;
-            }
-            // Otherwise, update the clusters object directly
-            if (this.publishedAccessory.clusters && this.publishedAccessory.clusters[clusterName]) {
-                this.publishedAccessory.clusters[clusterName][prop] = value;
-            }
-        }
-        catch (e) {
-            this.log.debug('setClusterValue error', e);
-        }
+    async handleStart() {
+        this.logInfo('starting (via start command).');
+        // TODO: await myVacuumAPI.start()
+        // 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);
     }
-    // Update operational state cluster from device state
-    async updateOperationalState() {
-        try {
-            await this.device.update();
-            const mode = this.device.operating_mode();
-            // Map operating modes to RVC operationalState values
-            // 0: Stopped, 1: Running, 2: Paused, 64: Seeking Charger, 65: Charging, 66: Docked
-            let opState = 0;
-            if (mode === OperatingModes.START) {
-                opState = 1;
-            }
-            else if (mode === OperatingModes.STOP) {
-                opState = 2;
-            }
-            // Docked status overrides when docked
-            const docked = this.device.docked_status && this.device.docked_status() === 1;
-            if (docked) {
-                opState = 66;
-            }
-            this.setClusterValue('rvcOperationalState', 'operationalState', opState);
-        }
-        catch (e) {
-            this.log.debug('updateOperationalState error', e);
-        }
+    async handleResume() {
+        this.logInfo('resuming.');
+        // TODO: await myVacuumAPI.resume()
+        // 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);
     }
-    // Update run mode cluster (Idle / Cleaning / Mapping)
-    async updateRunMode() {
-        try {
-            await this.device.update();
-            const mode = this.device.operating_mode();
-            let runMode = 0;
-            if (mode === OperatingModes.START) {
-                runMode = 1;
-            }
-            this.setClusterValue('rvcRunMode', 'currentMode', runMode);
-        }
-        catch (e) {
-            this.log.debug('updateRunMode error', e);
-        }
+    async handleGoHome() {
+        this.logInfo('goHome command received.');
+        // TODO: await myVacuumAPI.goHome()
+        // 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();
+        });
     }
-    // Update clean mode cluster (Vacuum / Mop / Vacuum & Mop)
-    async updateCleanMode() {
-        try {
-            await this.device.update();
-            const power = this.device.power_mode && this.device.power_mode();
-            // Best-effort mapping: treat power mode as clean mode placeholder
-            let cleanMode = 0;
-            if (power === PowerModes.MAX) {
-                cleanMode = 0;
-            }
-            this.setClusterValue('rvcCleanMode', 'currentMode', cleanMode);
-        }
-        catch (e) {
-            this.log.debug('updateCleanMode error', e);
-        }
+    async handleSelectAreas(request) {
+        this.logInfo(`SelectAreas request received: ${JSON.stringify(request)}`);
+        const { newAreas } = request;
+        const areaNames = newAreas.map((id) => ['Living Room', 'Kitchen', 'Bedroom', 'Bathroom'][id] || `Area ${id}`);
+        this.logInfo(`selecting areas: ${areaNames.join(', ')}`);
+        // TODO: await myVacuumAPI.selectAreas(newAreas)
     }
-    // Update selected areas / supported areas cluster
-    async updateSelectedAreas() {
-        try {
-            // If device exposes map/area info, use it. Otherwise leave defaults.
-            const maps = this.device.maps || [];
-            const areas = this.device.areas || [];
-            this.setClusterValue('serviceArea', 'supportedMaps', maps);
-            this.setClusterValue('serviceArea', 'supportedAreas', areas);
-            // No selectedAreas by default
-        }
-        catch (e) {
-            this.log.debug('updateSelectedAreas error', e);
-        }
+    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}`);
+        // TODO: await myVacuumAPI.skipArea(skippedArea)
     }
-    // Update progress / current area cluster
-    async updateProgress() {
-        try {
-            await this.device.update();
-            const currentArea = this.device.current_area || null;
-            this.setClusterValue('serviceArea', 'currentArea', currentArea);
-        }
-        catch (e) {
-            this.log.debug('updateProgress error', e);
-        }
+    /**
+     * Helper method to clear all active timers
+     */
+    clearTimers() {
+        this.activeTimers.forEach(timer => clearTimeout(timer));
+        this.activeTimers = [];
     }
-    // Handler implementations delegate to the underlying SharkIqVacuum device
-    async handleStart() {
-        this.log.info('Matter -> Start');
-        try {
-            await this.retry(() => this.device.clean_rooms([]));
-        }
-        catch (e) {
-            this.log.debug('handleStart error', e);
-        }
+    /**
+     * 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);
+        });
     }
-    async handleStop() {
-        this.log.info('Matter -> Stop');
-        try {
-            await this.retry(() => this.device.cancel_clean());
-        }
-        catch (e) {
-            this.log.debug('handleStop error', e);
-        }
+    /**
+     * 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})`}`);
     }
-    async handlePause() {
-        this.log.info('Matter -> Pause');
-        try {
-            await this.retry(() => this.device.set_operating_mode(this.device.OperatingModes?.STOP ?? 2));
-        }
-        catch (e) {
-            this.log.debug('handlePause error', e);
-        }
+    updateRunMode(mode) {
+        this.updateState('rvcRunMode', { currentMode: mode });
+        const modes = ['Idle', 'Cleaning', 'Mapping'];
+        this.logInfo(`run mode updated to: ${modes[mode] || `Unknown (${mode})`}`);
     }
-    async handleResume() {
-        this.log.info('Matter -> Resume');
-        try {
-            await this.retry(() => this.device.set_operating_mode(this.device.OperatingModes?.START ?? 1));
-        }
-        catch (e) {
-            this.log.debug('handleResume error', e);
-        }
+    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})`}`);
     }
-    async handleGoHome() {
-        this.log.info('Matter -> GoHome');
-        try {
-            await this.retry(() => this.device.cancel_clean());
-        }
-        catch (e) {
-            this.log.debug('handleGoHome error', e);
-        }
+    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'}`);
     }
-    async handleChangeRunMode(request) {
-        this.log.info('Matter -> Change Run Mode', request);
-        const newMode = request?.newMode;
-        try {
-            if (newMode === 1) {
-                await this.retry(() => this.device.clean_rooms([]));
-            }
-            else if (newMode === 0) {
-                await this.retry(() => this.device.cancel_clean());
-            }
+    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}`);
         }
-        catch (e) {
-            this.log.debug('handleChangeRunMode error', e);
+        else {
+            this.logInfo('current area cleared');
         }
     }
-    async handleChangeCleanMode(request) {
-        this.log.info('Matter -> Change Clean Mode', request);
-        // Best-effort: implement if device supports clean mode change
-    }
-    async handleSelectAreas(request) {
-        this.log.info('Matter -> Select Areas', request);
-        const areas = request?.newAreas;
-        if (Array.isArray(areas) && areas.length > 0) {
-            try {
-                await this.retry(() => this.device.clean_rooms(areas));
-            }
-            catch (e) {
-                this.log.debug('handleSelectAreas error', e);
-            }
-        }
-    }
-    async handleSkipArea(request) {
-        this.log.info('Matter -> Skip Area', request);
+    updateProgress(progress) {
+        this.updateState('serviceArea', { progress });
+        this.logInfo(`progress updated: ${progress.length} areas`);
     }
 }
 //# sourceMappingURL=RoboticVacuumAccessory.js.map