homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.52

package/lib/TuyaCloudMessaging.js

@@ -6,36 +6,27 @@ const crypto = require('crypto');
 /*
  * TuyaCloudMessaging
  * ------------------
- * Optional realtime updates for cloud-backed devices, over Tuya's MQTT message
- * service. ONE instance is shared by every cloud device on the same Tuya
- * project (one broker connection delivers status for all of them); messages are
- * fanned out to the right device by its `devId`.
+ * Realtime updates for cloud-backed devices, over Tuya's MQTT message service.
+ * ONE instance is shared by every cloud device on the same Tuya project (one
+ * broker connection delivers status for all of them); messages are fanned out
+ * to the right device by its `devId`.
  *
- * This is intentionally a best-effort accelerator layered on top of polling:
- * if the optional `mqtt` package is missing, or the broker can't be reached, or
- * a message can't be decrypted, nothing breaks — the devices simply keep
- * polling. When it IS working, changes (including physical button presses and
- * the rain sensor) show up in HomeKit within a second or two.
+ * Cloud updates (including physical button presses and the rain sensor) arrive
+ * over this stream rather than by polling, so they show up in HomeKit within a
+ * second or two. `mqtt` is a required dependency; if the broker can't be
+ * reached or a message can't be decrypted nothing crashes — the stream simply
+ * reconnects and the cloud REST reads still cover initial state.
  *
  * The connection + AES-GCM message decryption are faithful to the
  * actively-maintained `0x5e/homebridge-tuya-platform` (`src/core/TuyaOpenMQ.ts`),
  * re-implemented here with Node's built-in `crypto`.
  */
 
+const mqtt = require('mqtt');
+
 const GCM_TAG_LENGTH = 16;
 const PROTOCOL_DEVICE_STATUS = 4;
 
-// `mqtt` is an OPTIONAL dependency: realtime is a bonus, polling is the
-// guarantee. Loading it lazily keeps the plugin LAN-first and lets it run in
-// environments where mqtt isn't (or can't be) installed.
-let mqtt = null;
-let mqttLoadError = null;
-try {
-    mqtt = require('mqtt');
-} catch (ex) {
-    mqttLoadError = ex;
-}
-
 class TuyaCloudMessaging extends EventEmitter {
     constructor({api, log} = {}) {
         super();
@@ -56,10 +47,6 @@ class TuyaCloudMessaging extends EventEmitter {
         this.setMaxListeners(0);
     }
 
-    static isAvailable() {
-        return !!mqtt;
-    }
-
     // Register a device's status handler and lazily start the shared connection.
     subscribeDevice(devId, handler) {
         const id = '' + devId;
@@ -72,13 +59,8 @@ class TuyaCloudMessaging extends EventEmitter {
         if (this._stopped || this._started) return;
         this._started = true;
 
-        if (!mqtt) {
-            this.log.warn(`Tuya Cloud realtime disabled: the optional "mqtt" package is not installed${mqttLoadError ? ` (${mqttLoadError.message})` : ''}. Devices will poll instead. Install it with "npm install mqtt" in the plugin folder to enable instant updates.`);
-            return;
-        }
-
         this._connect().catch(ex => {
-            this.log.warn(`Tuya Cloud realtime could not start (${ex.message}); devices will poll instead.`);
+            this.log.warn(`Tuya Cloud realtime could not start (${ex.message}); it will keep retrying.`);
             this._scheduleRenew(60);
         });
     }
@@ -145,12 +127,12 @@ class TuyaCloudMessaging extends EventEmitter {
             envelope = JSON.parse(payload.toString());
         } catch (_) { return; }
 
-        const {protocol, data, t} = envelope;
+        const {protocol, data} = envelope;
         if (!data) return;
 
         let plaintext;
         try {
-            plaintext = this._decrypt(data, this.config && this.config.password, t);
+            plaintext = this._decrypt(data, this.config && this.config.password);
         } catch (ex) {
             this.log.debug(`Tuya Cloud realtime decrypt failed: ${ex.message}`);
             return;
@@ -170,6 +152,12 @@ class TuyaCloudMessaging extends EventEmitter {
         if (!devId || !Array.isArray(status)) return;
 
         const handlers = this._handlers.get('' + devId);
+        // Trace what the realtime stream actually delivers (debug only). A device
+        // whose status never arrives here — while it clearly changed in the cloud —
+        // is the signature of the message service not pushing that device's reports.
+        try {
+            this.log.debug(`Tuya Cloud realtime update for ${devId}${handlers && handlers.length ? '' : ' (no subscriber)'}: ${JSON.stringify(status)}`);
+        } catch (_) { /* logging must never throw */ }
         if (!handlers || !handlers.length) return;
         handlers.forEach(fn => {
             try { fn(status); } catch (ex) { this.log.debug(`Tuya Cloud realtime handler error: ${ex.message}`); }
@@ -179,26 +167,31 @@ class TuyaCloudMessaging extends EventEmitter {
     // Decrypt the MQTT `data` field. msg_encrypted_version 2.0 → AES-128-GCM,
     // 1.0 → AES-128-ECB. The AES key is the middle 16 chars of the broker
     // password (NOT the project Access Secret).
-    _decrypt(data, password, t) {
+    //
+    // The GCM auth tag is intentionally NOT verified: Tuya's real status frames
+    // do not carry a tag that verifies against the documented AAD, so calling
+    // `decipher.final()` would throw on every genuine message and silently drop
+    // all realtime updates. AES-GCM is a stream cipher, so `update()` alone
+    // recovers the plaintext correctly regardless of the tag; a wrong key just
+    // yields garbage that the subsequent JSON.parse rejects. Both the official
+    // `tuya/tuya-homebridge` and `0x5e/homebridge-tuya-platform` decrypt with
+    // `update()` only, for exactly this reason — `final()` here was the bug that
+    // stopped external changes (physical buttons, the Tuya app) from showing up.
+    _decrypt(data, password) {
         const key = Buffer.from(('' + (password || '')).substring(8, 24), 'utf8');
         const buf = Buffer.from(data, 'base64');
 
         // GCM (v2.0) layout: [ivLen(4) BE][iv(ivLen)][ciphertext][tag(16)].
-        // Try it first; if the header doesn't look like a sane IV length, or
-        // auth fails, fall back to ECB (v1.0).
+        // Try it first; if the header doesn't look like a sane IV length, fall
+        // back to ECB (v1.0).
         if (buf.length > 4 + GCM_TAG_LENGTH) {
             const ivLen = buf.readUIntBE(0, 4);
             if (ivLen >= 12 && ivLen <= 16 && (4 + ivLen + GCM_TAG_LENGTH) <= buf.length) {
                 try {
                     const iv = buf.slice(4, 4 + ivLen);
                     const ciphertext = buf.slice(4 + ivLen, buf.length - GCM_TAG_LENGTH);
-                    const tag = buf.slice(buf.length - GCM_TAG_LENGTH);
                     const decipher = crypto.createDecipheriv('aes-128-gcm', key, iv);
-                    decipher.setAuthTag(tag);
-                    const aad = Buffer.allocUnsafe(6);
-                    aad.writeUIntBE(Number(t) || 0, 0, 6);
-                    decipher.setAAD(aad);
-                    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+                    return decipher.update(ciphertext).toString('utf8');
                 } catch (gcmEx) {
                     // fall through to ECB
                 }

package/lib/TuyaDevice.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const EventEmitter = require('events');
+const TuyaAccessory = require('./TuyaAccessory');
+const TuyaCloudDevice = require('./TuyaCloudDevice');
+
+/*
+ * TuyaDevice
+ * ----------
+ * The single `device` object every accessory now talks to. It presents the exact
+ * same minimal contract the accessories already rely on —
+ *
+ *   - `context`            device config (name, id, type, …)
+ *   - `state`              current data-points
+ *   - `connected`          boolean
+ *   - `_connect()`         start talking to the device
+ *   - `update(dps)`        write data-points
+ *   - 'connect' / 'change' events  (change → (changes, state))
+ *
+ * — but underneath it transparently spans BOTH transports:
+ *
+ *   - a LAN backend  (TuyaAccessory)   — the fast, private, local path
+ *   - a cloud backend (TuyaCloudDevice)— Tuya's internet path, used as a fallback
+ *
+ * Behaviour mirrors the official Tuya app: control goes over the LAN whenever the
+ * device is reachable there; if the LAN is down (or the device never appears on it
+ * — e.g. battery-powered "sleepy" units) it falls back to the cloud. Only when
+ * BOTH are unreachable does the device report disconnected, so the accessory shows
+ * "No Response". Accessories don't know or care which path is live.
+ *
+ * The one thing that differs between the transports is how a data-point is
+ * addressed: the LAN speaks numeric ids (1, 2, …), the cloud speaks string codes
+ * (switch_led, …). The cloud backend learns the id<->code map from the device's
+ * thing-shadow and keeps `state` keyed BOTH ways, so a configuration written for
+ * either transport resolves over the other. Writes are translated to whatever the
+ * live backend needs. The net effect: existing LAN configs gain a cloud fallback,
+ * and existing cloud configs gain LAN, with no config change.
+ */
+
+// When a LAN-primary device's cloud backend connects first but can't offer the
+// numeric data-point map (the device-shadow API isn't available), give the LAN a
+// short head start before letting the cloud drive the one-time characteristic
+// registration — so a numeric-DP config still registers against numeric keys.
+const LAN_REGISTRATION_GRACE_MS = 15000;
+
+class TuyaDevice extends EventEmitter {
+    constructor(props = {}) {
+        super();
+        // Several accessories attach their own 'change' listener on top of the one
+        // BaseAccessory uses; keep the default-listener guard from ever warning.
+        this.setMaxListeners(0);
+
+        this.log = props.log || console;
+
+        // A plain config object on `context`, mirroring the transport classes but
+        // without the live helper objects we were handed.
+        this.context = {...props};
+        delete this.context.log;
+        delete this.context.cloudApi;
+        delete this.context.messaging;
+
+        this.state = {};
+        this._stopped = false;
+        this._registered = false;       // has the first 'change' (registration) gone out?
+        this._connectEmitted = false;
+        this._lanGraceElapsed = false;
+
+        // LAN backend — created later, once an IP is known (see attachLan). A
+        // device with no local key can't speak the LAN protocol at all, so it is
+        // cloud-only and this stays null.
+        this.lan = null;
+
+        // Cloud backend — present whenever the platform handed us a shared cloud
+        // session and this device isn't opted out of it.
+        this.cloud = null;
+        if (props.cloudApi) {
+            this.cloud = new TuyaCloudDevice({
+                ...props,
+                cloudApi: props.cloudApi,
+                messaging: props.messaging,
+                log: this.log,
+                // Let the cloud backend tell a harmless fallback failure (the device
+                // is reachable over the LAN) apart from one that matters (it isn't).
+                isLanConnected: () => !!(this.lan && this.lan.connected),
+                connect: false
+            });
+        }
+
+        if (props.connect !== false) this._connect();
+    }
+
+    // Reachable over either transport.
+    get connected() {
+        return !!((this.lan && this.lan.connected) || (this.cloud && this.cloud.connected));
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Lifecycle
+     * ------------------------------------------------------------------ */
+
+    _connect() {
+        if (this.cloud) {
+            this._wire(this.cloud, 'cloud');
+            this.cloud._connect();
+
+            // Safety net for the LAN-without-map registration guard above.
+            if (this.context.key) {
+                setTimeout(() => {
+                    this._lanGraceElapsed = true;
+                    if (!this._registered) this._onBackendChange();
+                }, LAN_REGISTRATION_GRACE_MS).unref?.();
+            }
+        }
+        // The LAN backend is attached by the platform via attachLan() once the
+        // device's IP is known (from discovery, or a configured `ip`), preserving
+        // the existing discovery timing.
+    }
+
+    // Bring up (or update) the LAN transport for a device whose IP is now known.
+    // `target` carries the {ip, version} learned from discovery; a configured
+    // version/forceVersion still take precedence as they always have.
+    attachLan(target = {}) {
+        if (this._stopped || this.lan) return;
+        if (!this.context.key) {
+            this.log.debug(`${this.context.name}: no local key; staying on the cloud only.`);
+            return;
+        }
+        if (!target.ip && !this.context.ip) return;
+
+        let version = this.context.version;
+        if (target.version) version = target.version;          // the device's broadcast wins…
+        if (this.context.forceVersion) version = this.context.forceVersion; // …but forceVersion wins all
+
+        this.lan = new TuyaAccessory({
+            ...this.context,
+            ip: target.ip || this.context.ip,
+            version,
+            log: this.log,
+            connect: false
+        });
+        this._wire(this.lan, 'lan');
+        this.lan._connect();
+    }
+
+    _wire(backend, which) {
+        backend.on('connect', () => this._onBackendConnect(which));
+        backend.on('change', () => this._onBackendChange(which));
+    }
+
+    _onBackendConnect(which) {
+        this.log.debug(`${this.context.name}: ${which} backend connected.`);
+        if (!this._connectEmitted) {
+            this._connectEmitted = true;
+            this.emit('connect');
+        }
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  State merge — LAN wins while it's up, cloud fills the rest / takes over
+     * ------------------------------------------------------------------ */
+
+    _merge() {
+        const merged = {};
+        if (this.cloud && this.cloud.connected) Object.assign(merged, this.cloud.state);
+        // LAN overlays the cloud while it's connected: it's the authoritative,
+        // freshest view for a device that's actually reachable locally.
+        if (this.lan && this.lan.connected) Object.assign(merged, this._lanStateDualKeyed());
+        return merged;
+    }
+
+    // LAN state is keyed by numeric dp id; mirror each value under its cloud code
+    // too (using the map the cloud backend learned), so a code-style config still
+    // resolves while the device is on the LAN.
+    _lanStateDualKeyed() {
+        const lanState = this.lan.state;
+        if (!this.cloud) return lanState;
+        const codeByDpId = this.cloud.codeByDpId;
+        const out = {...lanState};
+        for (const dp in lanState) {
+            const code = codeByDpId[dp];
+            if (code != null) out[code] = lanState[dp];
+        }
+        return out;
+    }
+
+    _onBackendChange(which) {
+        if (this._stopped) return;
+        if (!this._registered && !this._mayRegisterFrom(which)) return;
+
+        const merged = this._merge();
+        const changes = {};
+        Object.keys(merged).forEach(key => {
+            if (merged[key] !== this.state[key]) changes[key] = merged[key];
+        });
+
+        const first = !this._registered;
+        if (first || Object.keys(changes).length) {
+            this.state = {...this.state, ...merged};
+            this._registered = true;
+            // The first emit drives BaseAccessory's one-time characteristic
+            // registration; later emits carry only what actually changed.
+            this.emit('change', changes, this.state);
+        }
+    }
+
+    // Decide whether `which` backend may drive the one-time characteristic
+    // registration. LAN is always safe (numeric signature). The cloud is safe when
+    // the device is cloud-only (no local key), or once it has the numeric map (state
+    // is dual-keyed and so resolves a numeric-DP config), or once the LAN has been
+    // given its head start and didn't show up.
+    _mayRegisterFrom(which) {
+        if (which === 'lan') return true;
+        if (!this.context.key) return true;
+        if (this.cloud && Object.keys(this.cloud.codeByDpId).length) return true;
+        return this._lanGraceElapsed;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Writes — LAN first, cloud as a fallback
+     * ------------------------------------------------------------------ */
+
+    update(dps) {
+        // Pure LAN (no cloud configured): byte-for-byte the legacy behaviour — a
+        // synchronous boolean, so the sync write helpers keep detecting failures.
+        if (!this.cloud) {
+            return this.lan ? this.lan.update(this._toLanDps(dps)) : false;
+        }
+        return this._updateWithFallback(dps);
+    }
+
+    async _updateWithFallback(dps) {
+        // Prefer the LAN while it's connected.
+        if (this.lan && this.lan.connected) {
+            if (this.lan.update(this._toLanDps(dps)) !== false) return true;
+            this.log.debug(`${this.context.name}: LAN write didn't go through; trying the cloud.`);
+        }
+        if (this.cloud && this.cloud.connected) {
+            return (await this.cloud.update(dps)) !== false;
+        }
+        // Cloud is down too — a last LAN attempt (it may have just dropped, and a
+        // buffered write is better than a guaranteed failure).
+        if (this.lan) return this.lan.update(this._toLanDps(dps)) !== false;
+        return false;
+    }
+
+    // Translate a write keyed by codes and/or numeric ids into the numeric ids the
+    // LAN protocol needs. Numeric ids pass straight through; a code with a known id
+    // is translated; an unmapped code is left as-is (TuyaAccessory.update will then
+    // simply ignore it, which is the safe degradation when no map is available).
+    _toLanDps(dps) {
+        if (!this.cloud || !dps || typeof dps !== 'object') return dps;
+        const dpIdByCode = this.cloud.dpIdByCode;
+        const out = {};
+        for (const key in dps) out[dpIdByCode[key] || key] = dps[key];
+        return out;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Teardown (tidy; Homebridge doesn't strictly require it)
+     * ------------------------------------------------------------------ */
+
+    stop() {
+        this._stopped = true;
+        if (this.cloud && typeof this.cloud.stop === 'function') this.cloud.stop();
+        if (this.lan && typeof this.lan.stop === 'function') this.lan.stop();
+    }
+}
+
+module.exports = TuyaDevice;

package/lib/TuyaDiscovery.js

@@ -19,6 +19,7 @@ class TuyaDiscovery extends EventEmitter {
         this.limitedIds = [];
         this._servers = {};
         this._running = false;
+        this._portInUseWarned = {}; // ports already warned as in-use, so repeats stay at debug
     }
 
     start(props) {
@@ -85,7 +86,8 @@ class TuyaDiscovery extends EventEmitter {
         server.on('message', this._onDgramMessage.bind(this, port));
 
         server.bind(port, () => {
-            this.log.info(`Discovery - Discovery started on port ${port}.`);
+            this._portInUseWarned[port] = false; // a successful bind re-arms the in-use warning
+            this.log.debug(`Discovery started on port ${port}.`);
         });
     }
 
@@ -101,20 +103,30 @@ class TuyaDiscovery extends EventEmitter {
         this._stop(port);
 
         if (err && err.code === 'EADDRINUSE') {
-            this.log.warn(`Discovery - Port ${port} is in use. Will retry in 15 seconds.`);
+            // The retry runs every 15s for as long as the port stays taken (usually
+            // another Tuya plugin or a second instance). Warn once so it's
+            // actionable, then drop to debug so a persistent conflict doesn't flood
+            // the log; a later successful bind re-arms the warning.
+            const message = `Port ${port} is in use (is another Tuya plugin or instance running?). Will retry in 15 seconds.`;
+            if (this._portInUseWarned[port]) {
+                this.log.debug(`Discovery - ${message}`);
+            } else {
+                this.log.warn(`Discovery - ${message}`);
+                this._portInUseWarned[port] = true;
+            }
 
             setTimeout(() => {
                 this._start(port);
             }, 15000);
         } else {
-            this.log.error(`Discovery - Port ${port} failed:\n${err.stack}`);
+            this.log.error(`Discovery - Port ${port} failed:\n${err && err.stack || err}`);
         }
     }
 
     _onDgramClose(port) {
         this._stop(port);
 
-        this.log.info(`Discovery - Port ${port} closed.${this._running ? ' Restarting...' : ''}`);
+        this.log.debug(`Discovery - Port ${port} closed.${this._running ? ' Restarting...' : ''}`);
         if (this._running)
             setTimeout(() => {
                 this._start(port);
@@ -152,7 +164,7 @@ class TuyaDiscovery extends EventEmitter {
         const size = pkt.readUInt32BE(12);
 
         if (len - size < 8) {
-            this.log.error(`Discovery - UDP from ${info.address}:${port} size ${len - size}`);
+            this.log.debug(`Discovery - undersized UDP packet from ${info.address}:${port} (ignored).`);
             return;
         }
 
@@ -174,11 +186,14 @@ class TuyaDiscovery extends EventEmitter {
             if (result && result.gwId && result.ip) {
                 this._onDiscover(result);
             } else {
-                this.log.error(`Discovery - UDP from ${info.address}:${port} decrypted`, cleanMsg.toString('hex'));
+                this.log.debug(`Discovery - unrecognised UDP payload from ${info.address}:${port} (ignored):`, cleanMsg.toString('hex'));
             }
         } catch (ex) {
-            this.log.error(`Discovery - Failed to parse discovery response on port ${port}: ${decryptedMsg}`);
-            this.log.error(`Discovery - Failed to parse discovery raw message on port ${port}: ${pkt.toString('hex')}`);
+            // Not every Tuya-framed packet on these ports is a discovery reply we
+            // can parse (other broadcast types, foreign accounts, partial packets);
+            // none of it is an error worth surfacing.
+            this.log.debug(`Discovery - could not parse discovery response on port ${port}: ${decryptedMsg}`);
+            this.log.debug(`Discovery - raw unparsed message on port ${port}: ${pkt.toString('hex')}`);
         }
     }
 
@@ -230,7 +245,8 @@ class TuyaDiscovery extends EventEmitter {
                 this._onDiscover(payload);
             }
         } catch (ex) {
-            this.log.error(
+            // Foreign or partial packets on the v3.5 reply port are expected noise.
+            this.log.debug(
                 `Discovery v3.5 – failed to decrypt packet from ${info.address}:${srcPort}:`,
                 ex.message
             );

package/lib/ValveAccessory.js

@@ -49,13 +49,13 @@ class ValveAccessory extends BaseAccessory {
             .onSet(value => this.setStateAsync(this.dpPower, value));
 
         const characteristicInUse = service.getCharacteristic(Characteristic.InUse)
-            .onGet(() => characteristicActive.value);
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return characteristicActive.value; });
 
         if (!this.noTimer) {
             service.getCharacteristic(Characteristic.SetDuration)
-                .onGet(() => this.setDuration)
+                .onGet(() => { if (!this.device.connected) throw this._commError(); return this.setDuration; })
                 .on('change', (data) => {
-                    this.log.info('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
+                    this.log.debug('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
                     this.setDuration = data.newValue;
 
                     if (service.getCharacteristic(Characteristic.InUse).value) {
@@ -65,8 +65,9 @@ class ValveAccessory extends BaseAccessory {
 
                         clearTimeout(this.timer);
                         this.timer = setTimeout(() => {
-                            this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                            service.getCharacteristic(Characteristic.Active).setValue(0);
+                            this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                            this.setStateInBackground(this.dpPower, 0);
+                            service.getCharacteristic(Characteristic.Active).updateValue(0);
                             service.getCharacteristic(Characteristic.InUse).updateValue(0);
                             this.lastActivationTime = null;
                         }, (data.newValue * 1000));
@@ -75,6 +76,7 @@ class ValveAccessory extends BaseAccessory {
 
             service.getCharacteristic(Characteristic.RemainingDuration)
                 .onGet(() => {
+                    if (!this.device.connected) throw this._commError();
                     let remainingTime = this.setDuration - Math.floor(((new Date()).getTime() - this.lastActivationTime) / 1000);
                     return (remainingTime && remainingTime > 0) ? remainingTime : 0;
                 });
@@ -87,17 +89,18 @@ class ValveAccessory extends BaseAccessory {
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(0);
                             service.getCharacteristic(Characteristic.Active).updateValue(0);
                             clearTimeout(this.timer);
-                            this.log.info('Water Valve is OFF!');
+                            this.log.debug('Water Valve is OFF!');
                             break;
                         case 1:
                             this.lastActivationTime = (new Date()).getTime();
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                             service.getCharacteristic(Characteristic.Active).updateValue(1);
-                            this.log.info('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
+                            this.log.debug('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
                             clearTimeout(this.timer);
                             this.timer = setTimeout(() => {
-                                this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                                service.getCharacteristic(Characteristic.Active).setValue(0);
+                                this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                                this.setStateInBackground(this.dpPower, 0);
+                                service.getCharacteristic(Characteristic.Active).updateValue(0);
                                 service.getCharacteristic(Characteristic.InUse).updateValue(0);
                                 this.lastActivationTime = null;
                             }, (this.setDuration * 1000));
@@ -110,11 +113,12 @@ class ValveAccessory extends BaseAccessory {
                 service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                 service.getCharacteristic(Characteristic.Active).updateValue(1);
                 service.getCharacteristic(Characteristic.InUse).updateValue(1);
-                this.log.info('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
+                this.log.debug('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
                 clearTimeout(this.timer);
                 this.timer = setTimeout(() => {
-                    this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                    service.getCharacteristic(Characteristic.Active).setValue(0);
+                    this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                    this.setStateInBackground(this.dpPower, 0);
+                    service.getCharacteristic(Characteristic.Active).updateValue(0);
                     this.lastActivationTime = null;
                 }, (this.setDuration * 1000));
             }