homebridge-winix-purifiers 2.1.7 → 2.2.1

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)
@@ -32,7 +31,7 @@
   HomeKit.
 - **Filter Management**: Exposes the remaining filter life and provides an alert when it's time to change the filter,
   configurable to trigger at a specified percentage of remaining filter life.
-- **Efficiency**: Features Winix API response caching to minimize requests and avoid rate limiting.
+- **Efficiency**: Polls the Winix API in the background on a configurable interval to minimize requests and keep state fresh.
 - **Reliability**: Automatically refreshes device list on a configurable interval to ensure devices are always
   up-to-date.
 - **Seamless Authentication**: Automatically refreshes your Winix authentication token in the background, so you no
@@ -79,7 +78,8 @@ Simply provide your Winix account credentials for automatic device discovery and
 
 <img src="./assets/link-account.gif" alt="Link Account" />
 
-### Manual Configuration
+<details>
+<summary><h3>Manual Configuration</h3></summary>
 
 While not recommended, if manual setup is required, add the following to the `platforms` section of your `config.json`:
 
@@ -93,7 +93,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 +130,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. |
@@ -145,7 +145,10 @@ While not recommended, if manual setup is required, add the following to the `pl
 | `deviceOverrides[].nameSleepSwitch`        | `"Sleep"`          | The display name of the Sleep switch. Optional.                                                                          |
 | `platform`                                 | `"WinixPurifiers"` | Must always be `"WinixPurifiers"` in order for the plugin to load this config.                                           |
 
-### Encrypting Your Password (For Manual Setup and HOOBS Users)
+</details>
+
+<details>
+<summary><h3>Encrypting Your Password (For Manual Setup and HOOBS Users)</h3></summary>
 
 If you're configuring the plugin manually or using HOOBS, you need to store your Winix password securely in the
 configuration file. To do this, you must first encrypt your password using the provided `encrypt-password` script.
@@ -154,7 +157,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
@@ -190,16 +193,12 @@ The script will output your encrypted password. Copy the result and paste it int
 
 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)?
+</details>
 
-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).
+## FAQ
 
-### Using HOOBS?
+<details>
+<summary><h3>Using HOOBS?</h3></summary>
 
 If you're using [HOOBS](https://hoobs.org), you can install the plugin directly from the HOOBS interface. You will not
 be able to use the custom configuration UI, since it is not supported in HOOBS. You will need to use the manual
@@ -209,13 +208,7 @@ 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)).
+</details>
 
 ### Missing “Auto/Manual” switch in Home app?
 

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.1",
   "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"
+    "winix-api": "1.8.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",