homebridge-winix-purifiers 2.1.7 → 2.2.0

package/README.md

@@ -18,7 +18,6 @@
         * [Properties](#properties)
         * [Encrypting Your Password](#encrypting-your-password-for-manual-setup-and-hoobs-users)
 * [FAQ](#faq)
-    * [Upgrading from the old plugin architecture (v1.x.x) to the new one (v2.x.x)?](#upgrading-from-the-old-plugin-architecture-v1xx-to-the-new-one-v2xx)
     * [Using HOOBS?](#using-hoobs)
     * [Missing “Auto/Manual” switch in Home app?](#missing-automanual-switch-in-home-app)
     * [Having issues moving your purifier to a room in the Home app with the same name?](#having-issues-moving-your-purifier-to-a-room-in-the-home-app-with-the-same-name)
@@ -93,7 +92,7 @@ While not recommended, if manual setup is required, add the following to the `pl
       "exposeAutoSwitch": false,
       "exposeSleepSwitch": false,
       "filterReplacementIndicatorPercentage": 10,
-      "cacheIntervalSeconds": 300,
+      "pollIntervalSeconds": 30,
       "deviceRefreshIntervalMinutes": 60,
       "auth": {
         "username": "your-email@domain.com",
@@ -130,7 +129,7 @@ While not recommended, if manual setup is required, add the following to the `pl
 | `exposeAutoSwitch`                         | `false`            | Whether to expose switches for Auto mode on/off.                                                                         |
 | `exposeSleepSwitch`                        | `false`            | Whether to expose switches for Sleep mode on/off.                                                                        |
 | `filterReplacementIndicatorPercentage`     | `10`               | Percentage of filter life remaining to trigger a filter replacement alert.                                               |
-| `cacheIntervalSeconds`                     | `60`               | Time, in seconds, for how long to reuse cached responses from Winix.                                                     |
+| `pollIntervalSeconds`                      | `30`               | Time, in seconds, for how often to poll the Winix API for device state updates. Minimum 15.                              |
 | `deviceRefreshIntervalMinutes`             | `60`               | Time, in minutes, for how often to poll Winix to refresh the device list.                                                |
 | `auth.username`                            | `""`               | Your Winix account username (email). This field is meant to be read-only in the UI.                                      |
 | `auth.password`                            | `""`               | Your Winix account password (encrypted). This field is meant to be read-only in the UI. See below for manual generation. |
@@ -154,7 +153,7 @@ configuration file. To do this, you must first encrypt your password using the p
 
 1. **Clone the repository**:
 
-You’ll need to clone this plugin's repository locally to run the encryption script. Make sure you have **Node.js 20+**
+You’ll need to clone this plugin's repository locally to run the encryption script. Make sure you have **Node.js 22+**
 installed on your machine.
 
 ```bash
@@ -192,13 +191,6 @@ This ensures that your password is securely stored within the configuration file
 
 ## FAQ
 
-### Upgrading from the old plugin architecture (v1.x.x) to the new one (v2.x.x)?
-
-Unfortunately, there's no way to directly migrate from the old plugin architecture to the new one.
-Please follow the Migration Guide in the Wiki:
-
-[Migrating from v1.x.x to v2.x.x](https://github.com/regaw-leinad/homebridge-winix-purifiers/wiki/Migrating-from-v1.x.x-to-v2.x.x).
-
 ### Using HOOBS?
 
 If you're using [HOOBS](https://hoobs.org), you can install the plugin directly from the HOOBS interface. You will not
@@ -209,14 +201,6 @@ details on obtaining the required `auth` values. See
 [Encrypting Your Password](#encrypting-your-password-for-manual-setup-and-hoobs-users) for instructions on encrypting
 your Winix password.
 
-### Auth Error?
-
-Getting `error generating winix account from existing auth: NotAuthorizedException: Refresh Token has expired`? Winix
-refresh tokens expire after 30 days. For now, you will need to generate a new refresh token by re-authenticating with
-Winix. Find the `Reauthenticate with Winix` button in the plugin config settings in the Homebridge UI, and sign in with
-your email and password. Work has started on a new feature to automate this process
-([branch](https://github.com/regaw-leinad/homebridge-winix-purifiers/tree/password-auth)).
-
 ### Missing “Auto/Manual” switch in Home app?
 
 Please see [this issue](https://github.com/regaw-leinad/homebridge-winix-purifiers/issues/1) for more details.

package/config.schema.json

@@ -46,12 +46,12 @@
         "maximum": 100,
         "required": true
       },
-      "cacheIntervalSeconds": {
-        "title": "Winix Response Cache Interval (seconds)",
-        "description": "Time, in seconds, for how long to reuse cached responses from Winix",
+      "pollIntervalSeconds": {
+        "title": "Poll Interval (seconds)",
+        "description": "How often to poll the Winix API for device state updates",
         "type": "integer",
-        "default": 60,
-        "minimum": 0,
+        "default": 30,
+        "minimum": 15,
         "required": true
       },
       "deviceRefreshIntervalMinutes": {
@@ -166,7 +166,7 @@
         "exposeAutoSwitch",
         "exposeSleepSwitch",
         "filterReplacementIndicatorPercentage",
-        "cacheIntervalSeconds",
+        "pollIntervalSeconds",
         "deviceRefreshIntervalMinutes"
       ]
     },

package/dist/accessory.js

@@ -10,7 +10,8 @@ const device_1 = require("./device");
  */
 const MAX_FILTER_HOURS = 6480;
 const DEFAULT_FILTER_LIFE_REPLACEMENT_PERCENTAGE = 10;
-const DEFAULT_CACHE_INTERVAL_SECONDS = 60;
+const DEFAULT_POLL_INTERVAL_SECONDS = 30;
+const MIN_POLL_INTERVAL_SECONDS = 15;
 const MIN_AMBIENT_LIGHT = 0.0001;
 class WinixPurifierAccessory {
     constructor(platform, config, accessory, override, log) {
@@ -22,8 +23,9 @@ class WinixPurifierAccessory {
         this.ServiceType = this.platform.Service;
         this.Characteristic = this.platform.Characteristic;
         const { deviceId, deviceAlias } = accessory.context.device;
-        const cacheIntervalMs = (config.cacheIntervalSeconds ?? DEFAULT_CACHE_INTERVAL_SECONDS) * 1000;
-        this.device = new device_1.Device(deviceId, cacheIntervalMs, this.log);
+        const configuredSeconds = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
+        const pollIntervalMs = Math.max(configuredSeconds, MIN_POLL_INTERVAL_SECONDS) * 1000;
+        this.device = new device_1.Device(deviceId, pollIntervalMs, this.log);
         this.servicesInUse = new Set();
         const deviceSerial = override?.serialNumber ?? 'WNXAI00000000';
         const deviceName = override?.nameDevice ?? deviceAlias;
@@ -114,6 +116,11 @@ class WinixPurifierAccessory {
         }
         this.pruneUnusedServices();
     }
+    async initialize() {
+        await this.device.initialFetch();
+        this.sendHomekitUpdate();
+        this.device.startPolling(() => this.sendHomekitUpdate());
+    }
     /**
      * Prune any services that are no longer in use.
      * A service would be pruned if one is initially added,
@@ -128,67 +135,56 @@ class WinixPurifierAccessory {
             this.accessory.removeService(service);
         });
     }
-    /**
-     * Get the active state of the purifier.
-     * This maps to the Power attribute of the Winix device.
-     */
-    async getActiveState() {
-        const power = await this.device.getPower();
+    // Get handlers - all synchronous, return from in-memory state
+    // If the device has never been reachable, throw so HomeKit shows "No Response"
+    ensureReachable() {
+        if (!this.device.isReachable()) {
+            throw new this.platform.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    getActiveState() {
+        this.ensureReachable();
+        const power = this.device.getPower();
         this.log.debug('accessory:getActiveState()', power);
         return this.toActiveState(power);
     }
-    /**
-     * Set the active state of the purifier.
-     * This maps to the Power attribute of the Winix device.
-     */
     async setActiveState(state) {
         const power = state === this.Characteristic.Active.ACTIVE ? winix_api_1.Power.On : winix_api_1.Power.Off;
         this.log.debug(`accessory:setActiveState(${state})`, power);
         await this.device.setPower(power);
-        await this.sendHomekitUpdate();
+        this.sendHomekitUpdate();
+        this.device.resetPollTimer();
     }
-    /**
-     * Get the current state of the purifier. Either purifying air or inactive.
-     * Same as power for this implementation.
-     */
-    async getCurrentState() {
-        const power = await this.device.getPower();
+    getCurrentState() {
+        this.ensureReachable();
+        const power = this.device.getPower();
         this.log.debug('accessory:getCurrentState()', power);
         return this.toCurrentState(power);
     }
-    /**
-     * Get the target state of the purifier. Either auto or manual mode.
-     */
-    async getTargetState() {
-        const mode = await this.device.getMode();
+    getTargetState() {
+        this.ensureReachable();
+        const mode = this.device.getMode();
         this.log.debug('accessory:getTargetState()', mode);
         return this.toTargetState(mode);
     }
-    /**
-     * Set the target state of the purifier. Either auto or manual mode.
-     */
     async setTargetState(state) {
         const newMode = state === this.Characteristic.TargetAirPurifierState.AUTO ? winix_api_1.Mode.Auto : winix_api_1.Mode.Manual;
         this.log.debug(`accessory:setTargetState(${state})`, newMode);
         await this.device.setMode(newMode);
-        if (newMode === winix_api_1.Mode.Manual) {
-            return;
-        }
-        // If we're switching back to auto, the airflow speed will most likely change on the Winix device itself.
-        // Pause, get the latest airflow speed, then send the update to Homekit
-        this.scheduleHomekitUpdate();
+        this.sendHomekitUpdate();
+        this.device.resetPollTimer();
     }
-    /**
-     * Get the rotation speed of the purifier.
-     */
-    async getRotationSpeed() {
-        const airflow = await this.device.getAirflow();
+    getRotationSpeed() {
+        this.ensureReachable();
+        const power = this.device.getPower();
+        if (power === winix_api_1.Power.Off) {
+            this.log.debug('accessory:getRotationSpeed()', 'off');
+            return 0;
+        }
+        const airflow = this.device.getAirflow();
         this.log.debug('accessory:getRotationSpeed()', airflow);
         return this.toRotationSpeed(airflow);
     }
-    /**
-     * Set the rotation speed of the purifier.
-     */
     async setRotationSpeed(state) {
         const airflow = this.toAirflow(state);
         this.log.debug(`accessory:setRotationSpeed(${state}):`, airflow);
@@ -197,87 +193,76 @@ class WinixPurifierAccessory {
             return;
         }
         await this.device.setAirflow(airflow);
-        await this.sendHomekitUpdate();
+        this.sendHomekitUpdate();
+        this.device.resetPollTimer();
     }
-    /**
-     * Get the air quality of the purifier.
-     */
-    async getAirQuality() {
-        const airQuality = await this.device.getAirQuality();
+    getAirQuality() {
+        this.ensureReachable();
+        const airQuality = this.device.getAirQuality();
         this.log.debug('accessory:getAirQuality():', airQuality);
         return this.toAirQuality(airQuality);
     }
-    /**
-     * Get the plasmawave state of the purifier.
-     */
-    async getPlasmawave() {
-        const plasmawave = await this.device.getPlasmawave();
+    getPlasmawave() {
+        this.ensureReachable();
+        const plasmawave = this.device.getPlasmawave();
         this.log.debug('accessory:getPlasmawave():', plasmawave);
         return this.toSwitch(plasmawave);
     }
-    /**
-     * Set the plasmawave state of the purifier.
-     */
     async setPlasmawave(state) {
         const plasmawave = this.toPlasmawave(state);
         this.log.debug(`accessory:setPlasmawave(${state}):`, plasmawave);
         await this.device.setPlasmawave(plasmawave);
-        await this.sendHomekitUpdate();
+        this.sendHomekitUpdate();
+        this.device.resetPollTimer();
     }
-    /**
-     * Get the ambient light level of the purifier.
-     */
-    async getAmbientLight() {
-        const ambientLight = await this.device.getAmbientLight();
-        // Fix ambient light value under 0.0001 warning
+    getAmbientLight() {
+        this.ensureReachable();
+        const ambientLight = this.device.getAmbientLight();
         const fixedAmbientLight = this.toAmbientLight(ambientLight);
         this.log.debug('accessory:getAmbientLight():', 'measured:', ambientLight, 'fixed:', fixedAmbientLight);
         return fixedAmbientLight;
     }
-    /**
-     * Get the auto switch state of the purifier.
-     */
-    async getAutoSwitchState() {
-        const targetState = await this.getTargetState();
-        // Translate target state (auto/manual mode) to auto switch state
+    getAutoSwitchState() {
+        this.ensureReachable();
+        const power = this.device.getPower();
+        if (power === winix_api_1.Power.Off) {
+            this.log.debug('accessory:getAutoSwitchState()', 'off');
+            return false;
+        }
+        const targetState = this.getTargetState();
         const result = targetState === this.Characteristic.TargetAirPurifierState.AUTO;
         this.log.debug('accessory:getAutoSwitchState()', 'target', targetState, 'result', result);
         return result;
     }
-    /**
-     * Set the auto switch state of the purifier.
-     */
     async setAutoSwitchState(state) {
-        // Translate auto switch state to target state (auto/manual mode)
         const proxyState = state ?
             this.Characteristic.TargetAirPurifierState.AUTO :
             this.Characteristic.TargetAirPurifierState.MANUAL;
         this.log.debug(`accessory:setAutoSwitchState(${state})`, proxyState);
         return await this.setTargetState(proxyState);
     }
-    /**
-     * Get the sleep switch state of the purifier.
-     */
-    async getSleepSwitchState() {
-        const airflow = await this.device.getAirflow();
+    getSleepSwitchState() {
+        this.ensureReachable();
+        const power = this.device.getPower();
+        if (power === winix_api_1.Power.Off) {
+            this.log.debug('accessory:getSleepSwitchState()', 'off');
+            return false;
+        }
+        const airflow = this.device.getAirflow();
         const isInSleep = airflow === winix_api_1.Airflow.Sleep;
         this.log.debug('accessory:getSleepSwitchState()', isInSleep);
         return isInSleep;
     }
-    /**
-     * Set the sleep switch state of the purifier.
-     */
     async setSleepSwitchState(state) {
         const airflow = state ? winix_api_1.Airflow.Sleep : winix_api_1.Airflow.Low;
         this.log.debug(`accessory:setSleepSwitchState(${state})`, airflow);
         await this.device.setAirflow(airflow);
-        this.scheduleHomekitUpdate();
+        this.sendHomekitUpdate();
+        this.device.resetPollTimer();
     }
-    /**
-     * Get the filter life level of the purifier.
-     */
-    async getFilterLifeLevel() {
-        const currentFilterHours = await this.device.getFilterHours();
+    getFilterLifeLevel() {
+        this.ensureReachable();
+        const currentFilterHours = this.device.getFilterHours();
         if (currentFilterHours <= 0) {
             this.log.debug('accessory:getFilterLifeLevel(): currentFilterHours is not a positive number:', currentFilterHours);
             return 100;
@@ -287,11 +272,9 @@ class WinixPurifierAccessory {
         this.log.debug('accessory:getFilterLifeLevel()', remainingPercentage);
         return remainingPercentage;
     }
-    /**
-     * Get the filter change indication of the purifier.
-     */
-    async getFilterChangeIndication() {
-        const filterLife = await this.getFilterLifeLevel();
+    getFilterChangeIndication() {
+        this.ensureReachable();
+        const filterLife = this.getFilterLifeLevel();
         const replacementPercentage = this.config.filterReplacementIndicatorPercentage ?? DEFAULT_FILTER_LIFE_REPLACEMENT_PERCENTAGE;
         const shouldReplaceFilter = filterLife <= replacementPercentage ?
             this.Characteristic.FilterChangeIndication.CHANGE_FILTER :
@@ -299,27 +282,20 @@ class WinixPurifierAccessory {
         this.log.debug('accessory:getFilterChangeIndication() filterLife:', filterLife, 'replacementPercentage:', replacementPercentage, 'shouldReplaceFilter:', shouldReplaceFilter);
         return shouldReplaceFilter;
     }
-    scheduleHomekitUpdate() {
-        this.log.debug('scheduling homekit update');
-        setTimeout(async () => {
-            await this.device.update();
-            await this.sendHomekitUpdate();
-        }, 1000);
-    }
     /**
      * Send an update to Homekit with the latest device status.
      */
-    async sendHomekitUpdate() {
+    sendHomekitUpdate() {
         this.log.debug('accessory:sendHomekitUpdate()');
-        if (!this.device.hasData()) {
-            this.log.debug('accessory:sendHomekitUpdate(): skipping update, no status');
+        if (!this.device.isReachable()) {
+            this.log.debug('accessory:sendHomekitUpdate(): skipping, device not reachable');
             return;
         }
-        const { power, mode, airflow, airQuality, plasmawave, ambientLight, } = await this.device.getState();
+        const { power, mode, airflow, airQuality, plasmawave, ambientLight, } = this.device.getState();
         this.purifier.updateCharacteristic(this.Characteristic.Active, this.toActiveState(power));
         this.purifier.updateCharacteristic(this.Characteristic.CurrentAirPurifierState, this.toCurrentState(power));
         this.purifier.updateCharacteristic(this.Characteristic.TargetAirPurifierState, this.toTargetState(mode));
-        this.purifier.updateCharacteristic(this.Characteristic.RotationSpeed, this.toRotationSpeed(airflow));
+        this.purifier.updateCharacteristic(this.Characteristic.RotationSpeed, power === winix_api_1.Power.Off ? 0 : this.toRotationSpeed(airflow));
         if (this.airQuality !== undefined) {
             this.airQuality?.updateCharacteristic(this.Characteristic.AirQuality, this.toAirQuality(airQuality));
         }
@@ -330,10 +306,10 @@ class WinixPurifierAccessory {
             this.ambientLight?.updateCharacteristic(this.Characteristic.CurrentAmbientLightLevel, this.toAmbientLight(ambientLight));
         }
         if (this.autoSwitch !== undefined) {
-            this.autoSwitch?.updateCharacteristic(this.Characteristic.On, this.toTargetState(mode) === this.Characteristic.TargetAirPurifierState.AUTO);
+            this.autoSwitch?.updateCharacteristic(this.Characteristic.On, power === winix_api_1.Power.On && this.toTargetState(mode) === this.Characteristic.TargetAirPurifierState.AUTO);
         }
         if (this.sleepSwitch !== undefined) {
-            this.sleepSwitch?.updateCharacteristic(this.Characteristic.On, airflow === winix_api_1.Airflow.Sleep);
+            this.sleepSwitch?.updateCharacteristic(this.Characteristic.On, power === winix_api_1.Power.On && airflow === winix_api_1.Airflow.Sleep);
         }
     }
     toActiveState(power) {

package/dist/device.js

@@ -1,18 +1,19 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
 const winix_api_1 = require("winix-api");
-const async_lock_1 = __importDefault(require("async-lock"));
+const MAX_BACKOFF_MS = 5 * 60 * 1000;
+const COMMAND_DELAY_MS = 1500;
+const UNREACHABLE_THRESHOLD = 3;
 class Device {
-    constructor(deviceId, cacheIntervalMs, log) {
+    constructor(deviceId, pollIntervalMs, log) {
         this.deviceId = deviceId;
-        this.cacheIntervalMs = cacheIntervalMs;
+        this.pollIntervalMs = pollIntervalMs;
         this.log = log;
-        this.lastWinixPoll = -1;
-        this.lock = new async_lock_1.default({ timeout: 3000 });
+        this.hasReceivedData = false;
+        this.pollTimer = null;
+        this.consecutiveFailures = 0;
+        this.onUpdate = null;
         this.state = {
             power: winix_api_1.Power.Off,
             mode: winix_api_1.Mode.Auto,
@@ -24,38 +25,68 @@ class Device {
         };
     }
     hasData() {
-        return this.lastWinixPoll > -1;
+        return this.hasReceivedData;
+    }
+    isReachable() {
+        return this.hasReceivedData && this.consecutiveFailures < UNREACHABLE_THRESHOLD;
+    }
+    async initialFetch() {
+        try {
+            this.log.debug('device:initialFetch()');
+            const newState = await winix_api_1.WinixAPI.getDeviceStatus(this.deviceId);
+            Object.assign(this.state, newState);
+            this.hasReceivedData = true;
+            this.consecutiveFailures = 0;
+            this.log.debug('device:initialFetch()', JSON.stringify(this.state));
+        }
+        catch (e) {
+            this.log.warn('device:initialFetch() failed, using defaults:', e.message);
+        }
+    }
+    startPolling(onUpdate) {
+        this.onUpdate = onUpdate;
+        // Stagger the first poll with a random delay to avoid all devices
+        // hitting the API at the same time
+        const jitter = Math.floor(Math.random() * this.pollIntervalMs);
+        this.schedulePoll(jitter);
+    }
+    resetPollTimer(delayMs = 3000) {
+        this.schedulePoll(delayMs);
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
     }
-    async getPower() {
-        await this.ensureUpdated();
+    // Getters - all synchronous, return from in-memory state
+    getPower() {
         return this.state.power;
     }
-    async getMode() {
-        await this.ensureUpdated();
+    getMode() {
         return this.state.mode;
     }
-    async getAirflow() {
-        await this.ensureUpdated();
+    getAirflow() {
         return this.state.airflow;
     }
-    async getAirQuality() {
-        await this.ensureUpdated();
+    getAirQuality() {
         return this.state.airQuality;
     }
-    async getPlasmawave() {
-        await this.ensureUpdated();
+    getPlasmawave() {
         return this.state.plasmawave;
     }
-    async getAmbientLight() {
-        await this.ensureUpdated();
+    getAmbientLight() {
         return this.state.ambientLight;
     }
-    async getFilterHours() {
-        await this.ensureUpdated();
+    getFilterHours() {
         return this.state.filterHours;
     }
+    getState() {
+        return { ...this.state };
+    }
+    // Setters - async, send commands to Winix API and update state optimistically
     async setPower(value) {
-        const initialPower = await this.getPower();
+        const initialPower = this.getPower();
         if (initialPower === value) {
             this.log.debug('device:setPower(%s)', value, '(no change)');
             return;
@@ -63,32 +94,45 @@ class Device {
         this.log.debug('device:setPower()', initialPower, value);
         await winix_api_1.WinixAPI.setPower(this.deviceId, value);
         this.state.power = value;
-        // default to auto mode when turning on from off
-        if (initialPower === winix_api_1.Power.Off && value === winix_api_1.Power.On) {
+        // Side effects observed from device testing
+        if (value === winix_api_1.Power.Off) {
             this.state.mode = winix_api_1.Mode.Auto;
+            this.state.plasmawave = winix_api_1.Plasmawave.Off;
+        }
+        if (value === winix_api_1.Power.On) {
+            this.state.plasmawave = winix_api_1.Plasmawave.On;
         }
     }
     async setMode(value) {
         const turnedOn = await this.ensureOn();
-        // Don't try to set the mode if it's already set to the same value
-        // Fixes issues with this being set right around the time of power on
-        if (!turnedOn && value === await this.getMode()) {
+        if (!turnedOn && value === this.getMode()) {
             this.log.debug('device:setMode(%s)', value, '(no change)');
             return;
         }
         this.log.debug('device:setMode(%s)', value);
         await winix_api_1.WinixAPI.setMode(this.deviceId, value);
         this.state.mode = value;
-        // default to low airflow when switching modes
-        this.state.airflow = winix_api_1.Airflow.Low;
+        // Side effects observed from device testing
+        if (value === winix_api_1.Mode.Auto) {
+            this.state.airflow = winix_api_1.Airflow.Low;
+        }
     }
     async setAirflow(value) {
         this.log.debug('device:setAirflow(%s)', value);
-        // Device must be on and in manual mode to set airflow
         await this.ensureOn();
-        await this.setMode(winix_api_1.Mode.Manual);
+        // Device auto-switches to manual when setting airflow, but we need
+        // a delay between mode change and airflow command or the airflow
+        // command gets dropped by the device
+        if (this.state.mode !== winix_api_1.Mode.Manual) {
+            await this.setMode(winix_api_1.Mode.Manual);
+            await new Promise(r => setTimeout(r, COMMAND_DELAY_MS));
+        }
         await winix_api_1.WinixAPI.setAirflow(this.deviceId, value);
         this.state.airflow = value;
+        // Side effects observed from device testing
+        if (value === winix_api_1.Airflow.Sleep) {
+            this.state.plasmawave = winix_api_1.Plasmawave.Off;
+        }
     }
     async setPlasmawave(value) {
         this.log.debug('device:setPlasmawave()', value);
@@ -96,37 +140,34 @@ class Device {
         await winix_api_1.WinixAPI.setPlasmawave(this.deviceId, value);
         this.state.plasmawave = value;
     }
-    async getState() {
-        await this.ensureUpdated();
-        return {
-            power: this.state.power,
-            mode: this.state.mode,
-            airflow: this.state.airflow,
-            airQuality: this.state.airQuality,
-            plasmawave: this.state.plasmawave,
-            ambientLight: this.state.ambientLight,
-            filterHours: this.state.filterHours,
-        };
-    }
-    async update() {
-        this.log.debug('device:update()');
-        this.state = await winix_api_1.WinixAPI.getDeviceStatus(this.deviceId);
-        this.log.debug('device:update()', JSON.stringify(this.state));
-        this.lastWinixPoll = Date.now();
-    }
-    async ensureUpdated() {
-        // Use a lock to ensure only one update is running at a time
-        await this.lock.acquire('update', async () => {
-            if (this.shouldUpdate()) {
-                await this.update();
-            }
-        });
-    }
-    shouldUpdate() {
-        return Date.now() - this.lastWinixPoll > this.cacheIntervalMs;
+    // Private methods
+    schedulePoll(delayMs) {
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+        }
+        this.pollTimer = setTimeout(() => this.poll(), delayMs);
+    }
+    async poll() {
+        try {
+            this.log.debug('device:poll()');
+            const newState = await winix_api_1.WinixAPI.getDeviceStatus(this.deviceId);
+            Object.assign(this.state, newState);
+            this.hasReceivedData = true;
+            this.consecutiveFailures = 0;
+            this.log.debug('device:poll()', JSON.stringify(this.state));
+            this.onUpdate?.();
+        }
+        catch (e) {
+            this.consecutiveFailures++;
+            const backoffMs = Math.min(this.pollIntervalMs * Math.pow(2, this.consecutiveFailures), MAX_BACKOFF_MS);
+            this.log.error(`device:poll() error: ${e.message} (retry in ${Math.round(backoffMs / 1000)}s)`);
+            this.schedulePoll(backoffMs);
+            return;
+        }
+        this.schedulePoll(this.pollIntervalMs);
     }
     async ensureOn() {
-        if (await this.getPower() === winix_api_1.Power.On) {
+        if (this.state.power === winix_api_1.Power.On) {
             this.log.debug('device:ensureOn()', 'already on');
             return false;
         }

package/dist/platform.js

@@ -81,14 +81,14 @@ class WinixPurifierPlatform {
             this.log.debug('Found', accessory ? 'existing' : 'new', 'accessory:', this.logName(device));
             if (accessory) {
                 accessory.context.device = device;
-                const handler = this.createNewAccessoryHandler(accessory);
+                const handler = await this.createNewAccessoryHandler(accessory);
                 this.handlers.set(uuid, handler);
                 this.api.updatePlatformAccessories([accessory]);
             }
             else {
                 accessory = new this.api.platformAccessory(device.deviceAlias, uuid, 19 /* Categories.AIR_PURIFIER */);
                 accessory.context.device = device;
-                const handler = this.createNewAccessoryHandler(accessory);
+                const handler = await this.createNewAccessoryHandler(accessory);
                 this.accessories.set(uuid, accessory);
                 this.handlers.set(uuid, handler);
                 accessoriesToAdd.push(accessory);
@@ -100,13 +100,14 @@ class WinixPurifierPlatform {
         }
         this.removeOldDevices(discoveredUUIDs);
     }
-    createNewAccessoryHandler(accessory) {
+    async createNewAccessoryHandler(accessory) {
         // 🫣 suppress warning message about adding characteristics which aren't required / optional, since it isn't accurate
         this.suppressCharacteristicWarnings(accessory);
         const deviceOverride = this.deviceOverrides.get(accessory.context.device.deviceId);
         const log = new logger_1.DeviceLogger(this.log, accessory.context.device);
         const handler = new accessory_1.WinixPurifierAccessory(this, this.config, accessory, deviceOverride, log);
         this.unsuppressCharacteristicWarnings(accessory);
+        await handler.initialize();
         return handler;
     }
     removeOldDevices(discoveredUUIDs) {
@@ -116,6 +117,7 @@ class WinixPurifierPlatform {
                 return;
             }
             this.log.debug('Removing old accessory:', this.logName(accessory.context.device));
+            this.handlers.get(accessory.UUID)?.device.stopPolling();
             this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
             this.accessories.delete(accessory.UUID);
             this.handlers.delete(accessory.UUID);

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Winix Air Purifiers",
   "name": "homebridge-winix-purifiers",
-  "version": "2.1.7",
+  "version": "2.2.0",
   "description": "Homebridge plugin for Winix air purifiers",
   "license": "Apache-2.0",
   "repository": {
@@ -63,11 +63,9 @@
   ],
   "dependencies": {
     "@homebridge/plugin-ui-utils": "1.0.3",
-    "async-lock": "1.4.1",
     "winix-api": "1.7.0"
   },
   "devDependencies": {
-    "@types/async-lock": "1.4.2",
     "@types/node": "20.11.0",
     "@typescript-eslint/eslint-plugin": "6.18.1",
     "@typescript-eslint/parser": "6.18.1",