homebridge-tuya-plus 3.13.0 → 3.13.1-dev.1

package/lib/SimpleGarageDoorAccessory.js

@@ -1,27 +1,32 @@
 const BaseAccessory = require('./BaseAccessory');
 
-// Delay after the device echoes the stop DP back to false (signalling the
-// stop has finished) before sending the open/close command. Some controllers
-// drop the direction command when it arrives too soon after the stop, even
-// after the stop DP itself has been reset.
-const POST_RESET_DELAY_MS = 500;
-
-// Fallback if the device never echoes the stop DP back to false (e.g. when
-// the stop was a no-op because the gate was already idle, or the echo is
-// dropped). Picked to comfortably exceed the ~1s reset we observe in
-// practice.
-const STOP_RESET_TIMEOUT_MS = 3000;
-
-// Fallback for the direction DP echo when the device misses one.
-const DIRECTION_RESET_TIMEOUT_MS = 3000;
-
-// Debounce window for incoming HomeKit toggles. setTargetDoorState waits
-// this long after the most recent press before starting (or rescheduling) a
-// stop+direction cycle, so a rapid burst of taps coalesces into one cycle
-// on the final target instead of driving the gate back and forth.
-const SETTLE_MS = 1000;
-
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+// This controller reports its movement on a single status DP (default 105),
+// but only distinguishes three values:
+//
+//   11 -> stopped            (gate parked part-way, or fully open)
+//   12 -> opening OR open
+//   13 -> closing OR closed
+//
+// HomeKit's GarageDoorOpener only needs the two states it can act on, so we
+// collapse the three: 11/12 => OPEN, 13 => CLOSED. Both CurrentDoorState and
+// TargetDoorState are mirrored straight from this DP, which keeps HomeKit in
+// sync no matter how the gate was triggered (Home app, a physical remote, the
+// Tuya app, ...).
+//
+// Opening is symmetric and forgiving: the controller reverses on its own, so
+// an open command works directly even while the gate is closing — we just fire
+// it. Closing is asymmetric, though: the controller IGNORES a close command
+// while the gate is actively moving. The one exception is when the status DP
+// reads exactly 11 (stopped) — e.g. after a partial-open or an external stop —
+// where the gate is idle and accepts close immediately. So unless we can see
+// it's already stopped, a close is sent as stop -> wait -> close.
+const STATE_STOPPED = 11;
+const STATE_OPENING_OR_OPEN = 12;
+const STATE_CLOSING_OR_CLOSED = 13;
+
+// How long to wait between the stop and the close in the stop-before-close
+// path. Overridable per-device via the `stopBeforeCloseMs` config option.
+const DEFAULT_STOP_BEFORE_CLOSE_MS = 1500;
 
 class SimpleGarageDoorAccessory extends BaseAccessory {
     static getCategory(Categories) {
@@ -69,39 +74,46 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         }
     }
 
-    _registerCharacteristics() {
+    _registerCharacteristics(dps) {
         this._reconcileOptionalServices();
 
         const {Service, Characteristic} = this.hap;
         const service = this.accessory.getService(Service.GarageDoorOpener);
         this._checkServiceName(service, this.device.context.name);
 
-        this.dpOpen = this._getCustomDP(this.device.context.dpOpen) || '1';
-        this.dpStop = this._getCustomDP(this.device.context.dpStop) || '2';
-        this.dpClose = this._getCustomDP(this.device.context.dpClose) || '3';
+        this.dpOpen = this._getCustomDP(this.device.context.dpOpen) || '101';
+        this.dpClose = this._getCustomDP(this.device.context.dpClose) || '102';
+        this.dpStop = this._getCustomDP(this.device.context.dpStop) || '103';
+        this.dpState = this._getCustomDP(this.device.context.dpState) || '105';
 
         const partialOpenMs = parseInt(this.device.context.partialOpenMs, 10);
         this.partialOpenMs = Number.isFinite(partialOpenMs) && partialOpenMs > 0 ? partialOpenMs : 0;
 
-        // The device exposes no status DPs, so the only "memory" of where the
-        // gate is comes from the last HomeKit-triggered change, persisted via
-        // the homebridge accessory context.
-        if (this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.OPEN &&
-            this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.CLOSED) {
-            this.accessory.context.cachedTargetDoorState = Characteristic.TargetDoorState.OPEN;
+        const stopBeforeCloseMs = parseInt(this.device.context.stopBeforeCloseMs, 10);
+        this.stopBeforeCloseMs = Number.isFinite(stopBeforeCloseMs) && stopBeforeCloseMs >= 0
+            ? stopBeforeCloseMs
+            : DEFAULT_STOP_BEFORE_CLOSE_MS;
+
+        // Pending side effects we may need to cancel: the partial-open auto-stop
+        // and the close that trails a stop in the stop-before-close path.
+        this.partialStopTimer = null;
+        this.pendingCloseTimer = null;
+
+        // Seed the initial state from whatever the device has already reported.
+        // If it hasn't reported yet, fall back to the persisted target, then to
+        // CLOSED (the safer assumption for a gate). The real state DP almost
+        // always arrives within a second of connecting and corrects this.
+        let isOpen = this._mapDpState(dps[this.dpState]);
+        if (isOpen === null) {
+            isOpen = this.accessory.context.cachedTargetDoorState === Characteristic.TargetDoorState.OPEN;
         }
-        const initialTarget = this.accessory.context.cachedTargetDoorState;
-        this.currentDoorState = initialTarget === Characteristic.TargetDoorState.OPEN
+        this.currentDoorState = isOpen
             ? Characteristic.CurrentDoorState.OPEN
             : Characteristic.CurrentDoorState.CLOSED;
-        this.desiredTarget = initialTarget;
-        this.worker = null;
-        this.scheduleTimer = null;
-        this.partialStopTimer = null;
-        this.partialOpenId = 0;
-        this._partialPending = false;
-        this._currentChangePending = null;
-        this._currentChangeResolve = null;
+        const initialTarget = isOpen
+            ? Characteristic.TargetDoorState.OPEN
+            : Characteristic.TargetDoorState.CLOSED;
+        this.accessory.context.cachedTargetDoorState = initialTarget;
 
         this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
             .updateValue(initialTarget)
@@ -112,22 +124,23 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             .updateValue(this.currentDoorState)
             .onGet(() => this.currentDoorState);
 
+        // The controller exposes limit switches (l_open/l_close) but they don't
+        // work in practice, and there's no obstruction sensor wired up, so this
+        // is always reported clear.
         service.getCharacteristic(Characteristic.ObstructionDetected)
             .updateValue(false)
             .onGet(() => false);
 
         const partialSwitch = this.accessory.getServiceById(Service.Switch, 'partialOpen');
         if (partialSwitch) {
-            const initialOn = this.currentDoorState === Characteristic.CurrentDoorState.OPEN;
             const onChar = partialSwitch.getCharacteristic(Characteristic.On)
-                .updateValue(initialOn)
+                .updateValue(isOpen)
                 .onGet(() => this.currentDoorState === Characteristic.CurrentDoorState.OPEN)
                 .onSet(value => {
-                    // Stateful: switch ON triggers a partial-open cycle,
-                    // switch OFF triggers a full close (queue stop+close).
-                    // The switch value itself mirrors CurrentDoorState (see
-                    // _setCurrentDoorState) so it sits at ON whenever the
-                    // gate is currently open in HomeKit's view.
+                    // Stateful: the switch mirrors CurrentDoorState (ON while
+                    // the gate is open in HomeKit's view — see
+                    // _applyReportedState). Tapping it ON triggers a
+                    // partial-open; tapping it OFF triggers a full close.
                     if (value) {
                         this._handlePartialOpen();
                     } else {
@@ -163,255 +176,158 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             this.characteristicForceClose = onChar;
         }
 
-        // CurrentDoorState follows the device's own pacing — it flips to OPEN
-        // when the open DP transitions back to false, and to CLOSED when the
-        // close DP transitions back to false. That reset echo is the closest
-        // thing to position feedback we have.
         this.device.on('change', changes => this._onDeviceChange(changes));
     }
 
+    // Maps a raw status DP value to open (true) / closed (false) / unknown
+    // (null). 11 (stopped) and 12 (opening or open) are both "open" as far as
+    // HomeKit is concerned; 13 (closing or closed) is "closed".
+    _mapDpState(raw) {
+        const value = typeof raw === 'string' ? parseInt(raw, 10) : raw;
+        if (value === STATE_STOPPED || value === STATE_OPENING_OR_OPEN) return true;
+        if (value === STATE_CLOSING_OR_CLOSED) return false;
+        return null;
+    }
+
     _onDeviceChange(changes) {
-        const {Characteristic} = this.hap;
-        if (!changes) return;
-        if (changes[this.dpOpen] === false) {
-            this._setCurrentDoorState(Characteristic.CurrentDoorState.OPEN);
-        } else if (changes[this.dpClose] === false) {
-            this._setCurrentDoorState(Characteristic.CurrentDoorState.CLOSED);
+        if (!changes || !changes.hasOwnProperty(this.dpState)) return;
+        // Mid stop-before-close: the stop we just issued can briefly report 11
+        // (=OPEN), which would fight the close we're about to send. Ignore
+        // status reports until the close has gone out.
+        if (this.pendingCloseTimer) return;
+        const isOpen = this._mapDpState(changes[this.dpState]);
+        if (isOpen === null) {
+            this.log.info(`[SimpleGarageDoor] ${this.device.context.name}: ignoring unknown state DP value ${JSON.stringify(changes[this.dpState])}`);
+            return;
         }
+        this._applyReportedState(isOpen);
     }
 
-    _setCurrentDoorState(state) {
-        if (this.currentDoorState === state) return;
-        this.currentDoorState = state;
-        this.characteristicCurrentDoorState.updateValue(state);
+    // Mirrors the device's reported state onto both door-state characteristics
+    // (and the partial-open switch). Driving TargetDoorState from the DP too —
+    // not just CurrentDoorState — is what keeps HomeKit honest when the gate is
+    // operated outside HomeKit.
+    _applyReportedState(isOpen) {
+        const {Characteristic} = this.hap;
+        const current = isOpen
+            ? Characteristic.CurrentDoorState.OPEN
+            : Characteristic.CurrentDoorState.CLOSED;
+        const target = isOpen
+            ? Characteristic.TargetDoorState.OPEN
+            : Characteristic.TargetDoorState.CLOSED;
+
+        if (this.currentDoorState !== current) {
+            this.currentDoorState = current;
+            this.characteristicCurrentDoorState.updateValue(current);
+        }
+        if (this.accessory.context.cachedTargetDoorState !== target) {
+            this.accessory.context.cachedTargetDoorState = target;
+            if (this.characteristicTargetDoorState) this.characteristicTargetDoorState.updateValue(target);
+        }
         if (this.characteristicPartialOpen) {
-            this.characteristicPartialOpen.updateValue(
-                state === this.hap.Characteristic.CurrentDoorState.OPEN
-            );
+            this.characteristicPartialOpen.updateValue(isOpen);
         }
-        this._wakeCurrentChangeWaiters();
     }
 
-    _waitForCurrentChange() {
-        if (!this._currentChangePending) {
-            this._currentChangePending = new Promise(resolve => {
-                this._currentChangeResolve = resolve;
-            });
-        }
-        return this._currentChangePending;
+    setTargetDoorState(value) {
+        // A direct open/close (the GarageDoorOpener target, a Force switch, or
+        // the partial switch tapped OFF) is manual control: cancel any pending
+        // partial-open auto-stop so it can't halt this movement part-way.
+        this._cancelPartialStop();
+        this._applyTarget(value);
     }
 
-    _wakeCurrentChangeWaiters() {
-        if (this._currentChangeResolve) {
-            const resolve = this._currentChangeResolve;
-            this._currentChangeResolve = null;
-            this._currentChangePending = null;
-            resolve();
-        }
+    // Optimistically reflects the requested target in HomeKit and fires the
+    // matching action on the device. CurrentDoorState is intentionally left to
+    // catch up from the status DP. The device echoes the action DP back to
+    // false on its own; we don't wait for it.
+    _applyTarget(value) {
+        const {Characteristic} = this.hap;
+        const open = value === Characteristic.TargetDoorState.OPEN;
+        this.accessory.context.cachedTargetDoorState = value;
+        if (this.characteristicTargetDoorState) this.characteristicTargetDoorState.updateValue(value);
+        if (open) this._sendOpen();
+        else this._sendClose();
     }
 
-    setTargetDoorState(value) {
+    // Open is always safe to fire directly — the controller reverses on its
+    // own, even mid-close. Abandon any pending stop-before-close.
+    _sendOpen() {
+        this._cancelPendingClose();
+        this.log.info(`[SimpleGarageDoor] ${this.device.context.name}: open (dp${this.dpOpen})`);
+        this.setMultiStateLegacyAsync({[this.dpOpen]: true});
+    }
+
+    // Close is ignored while the gate is actively moving, so fire it directly
+    // only when the status DP shows the gate is already stopped (11). Otherwise
+    // stop first, wait stopBeforeCloseMs, then close.
+    _sendClose() {
         const name = this.device.context.name;
-        // If a partial-open flow is in progress (waiting for OPEN or armed
-        // with a pending stop) and the incoming value matches the target
-        // the partial already set, treat this as a HomeKit/iOS resync (the
-        // accessory's TargetDoorState characteristic wasn't notified of
-        // the partial-induced target change, so iOS may write the value
-        // back to "confirm" the state it observed via CurrentDoorState).
-        // A no-op resync must not cancel the partial's auto-stop —
-        // otherwise the gate runs all the way open.
-        if ((this._partialPending || this.partialStopTimer)
-            && value === this.desiredTarget) {
-            this.log.info(`[SimpleGarageDoor] ${name}: setTargetDoorState(${value}) ignored as same-value resync during partial`);
+        if (this.pendingCloseTimer) {
+            // A stop-before-close is already running — don't restart it (and
+            // push the close out) on a duplicate or retransmitted request.
+            this.log.info(`[SimpleGarageDoor] ${name}: close ignored — a stop-before-close is already running`);
             return;
         }
-        this.log.info(`[SimpleGarageDoor] ${name}: setTargetDoorState(${value}); was desiredTarget=${this.desiredTarget}, partialStopTimer=${this.partialStopTimer ? 'armed' : 'null'}, _partialPending=${this._partialPending}`);
-        // Public path: a direct user toggle cancels any pending partial-stop
-        // timer and supersedes any in-flight partial-open wait — once the
-        // user takes manual control, the auto-stop shouldn't fire later, and
-        // the partial flow's open-wait should bail out rather than hanging
-        // forever in case currentDoorState never reaches OPEN.
-        if (this.partialStopTimer) {
-            clearTimeout(this.partialStopTimer);
-            this.partialStopTimer = null;
+        if (this._isStopped()) {
+            this.log.info(`[SimpleGarageDoor] ${name}: close (dp${this.dpClose}) — gate already stopped`);
+            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+            return;
         }
-        this._partialPending = false;
-        this.partialOpenId++;
-        this._wakeCurrentChangeWaiters();
-        this._setTarget(value);
+        this.log.info(`[SimpleGarageDoor] ${name}: stop-before-close — stop (dp${this.dpStop}) now, close (dp${this.dpClose}) in ${this.stopBeforeCloseMs}ms`);
+        this.setMultiStateLegacyAsync({[this.dpStop]: true});
+        this.pendingCloseTimer = setTimeout(() => {
+            this.pendingCloseTimer = null;
+            this.log.info(`[SimpleGarageDoor] ${name}: stop-before-close — firing close (dp${this.dpClose})`);
+            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+        }, this.stopBeforeCloseMs);
     }
 
-    _setTarget(value) {
-        this.accessory.context.cachedTargetDoorState = value;
-        this.desiredTarget = value;
-        // Mirror the target through the characteristic so HomeKit's view of
-        // TargetDoorState stays in sync with what we actually want — without
-        // this, HAP's internal value stays at whatever was last written by a
-        // client (e.g. CLOSED) and a hub may push a resync write trying to
-        // reconcile it with the new CurrentDoorState we just emitted.
-        if (this.characteristicTargetDoorState) {
-            this.characteristicTargetDoorState.updateValue(value);
+    // True only when the controller reports the gate is stopped (11) — the one
+    // state where it will accept a close without a stop first.
+    _isStopped() {
+        const raw = this.device.state ? this.device.state[this.dpState] : undefined;
+        const value = typeof raw === 'string' ? parseInt(raw, 10) : raw;
+        return value === STATE_STOPPED;
+    }
+
+    _cancelPendingClose() {
+        if (this.pendingCloseTimer) {
+            clearTimeout(this.pendingCloseTimer);
+            this.pendingCloseTimer = null;
         }
-        // If a worker is already running it will pick up the new target at
-        // its next decision point — no need to debounce again. Otherwise
-        // (re)start the debounce so a burst of taps coalesces into one
-        // cycle on the final target.
-        if (this.worker) return;
-        this._scheduleWorker();
     }
 
-    // Drives the partial-open flow: STOP+OPEN through the normal queue, wait
-    // until CurrentDoorState reaches OPEN (so the timer is anchored to the
-    // device actually receiving the open rather than to the button press —
-    // otherwise a short partialOpenMs would land mid-cycle and a stop fired
-    // then could land before the open even reaches the device), then after
-    // partialOpenMs send a raw STOP to halt the gate mid-opening so it ends
-    // up partially open.
-    //
-    // Idempotent against re-invocation while a flow is already in progress
-    // (waiting for OPEN or armed with a pending stop): HomeKit/iOS will
-    // retransmit a WRITE if the 204 response is delayed or dropped, and
-    // each retry firing through onSet would otherwise cancel the original
-    // stop timer and push it out by another partialOpenMs — eventually
-    // letting the gate run all the way open. A direct toggle on the main
-    // GarageDoorOpener target or a Force switch still supersedes this flow
-    // through setTargetDoorState.
-    async _handlePartialOpen() {
+    // Partial open: fire the open action, then after partialOpenMs fire a stop
+    // so the gate ends up parked part-way. Anchored to the button press (the
+    // controller starts moving and reports state within ~1s), which is all the
+    // user asked for.
+    _handlePartialOpen() {
         const {Characteristic} = this.hap;
         const name = this.device.context.name;
         if (!this.partialOpenMs) return;
-        if (this._partialPending || this.partialStopTimer) {
-            this.log.info(`[SimpleGarageDoor] ${name}: partial press ignored — flow already in progress (_partialPending=${this._partialPending}, partialStopTimer=${this.partialStopTimer ? 'armed' : 'null'})`);
+        if (this.partialStopTimer) {
+            // Re-entrant press while a partial is already armed (e.g. a
+            // HomeKit/iOS WRITE retransmit) — ignore so the stop isn't pushed
+            // out, which would let the gate run further than intended.
+            this.log.info(`[SimpleGarageDoor] ${name}: partial press ignored — a partial open is already running`);
             return;
         }
 
-        this._partialPending = true;
-        const myId = ++this.partialOpenId;
-        this.log.info(`[SimpleGarageDoor] ${name}: partial press accepted (myId=${myId}); driving target to OPEN`);
-
-        this._setTarget(Characteristic.TargetDoorState.OPEN);
-
-        try {
-            while (this.currentDoorState !== Characteristic.CurrentDoorState.OPEN) {
-                await this._waitForCurrentChange();
-                // A direct toggle (which clears _partialPending) supersedes
-                // this flow.
-                if (myId !== this.partialOpenId) {
-                    this.log.info(`[SimpleGarageDoor] ${name}: partial flow superseded mid-wait (myId=${myId} vs ${this.partialOpenId})`);
-                    return;
-                }
-            }
-        } finally {
-            this._partialPending = false;
-        }
-
-        this.log.info(`[SimpleGarageDoor] ${name}: CurrentDoorState reached OPEN; arming partial-stop in ${this.partialOpenMs}ms`);
+        this.log.info(`[SimpleGarageDoor] ${name}: partial open — opening, will stop in ${this.partialOpenMs}ms`);
+        this._applyTarget(Characteristic.TargetDoorState.OPEN);
         this.partialStopTimer = setTimeout(() => {
             this.partialStopTimer = null;
-            if (myId !== this.partialOpenId) {
-                this.log.info(`[SimpleGarageDoor] ${name}: partial-stop timer fired but flow superseded (myId=${myId} vs ${this.partialOpenId})`);
-                return;
-            }
-            // Send the raw stop several times spread over ~1s. The device's
-            // command queue can drop back-to-back writes, and brief WiFi
-            // dropouts silently lose individual writes — re-sending a few
-            // times defends against both. A stop on an already-stopped gate
-            // is a no-op on the device side.
-            this.log.info(`[SimpleGarageDoor] ${name}: firing partial-stop (dp${this.dpStop}=true) with retries`);
-            const send = (attempt) => {
-                if (myId !== this.partialOpenId) return;
-                this.log.info(`[SimpleGarageDoor] ${name}: partial-stop attempt ${attempt} (device.connected=${this.device.connected})`);
-                this.setMultiStateLegacyAsync({[this.dpStop]: true});
-            };
-            send(1);
-            setTimeout(() => send(2), 250);
-            setTimeout(() => send(3), 600);
-            setTimeout(() => send(4), 1200);
+            this.log.info(`[SimpleGarageDoor] ${name}: partial open — firing stop (dp${this.dpStop})`);
+            this.setMultiStateLegacyAsync({[this.dpStop]: true});
         }, this.partialOpenMs);
     }
 
-    _scheduleWorker() {
-        if (this.scheduleTimer) clearTimeout(this.scheduleTimer);
-        this.scheduleTimer = setTimeout(() => {
-            this.scheduleTimer = null;
-            this._spawnWorker();
-        }, SETTLE_MS);
-    }
-
-    _spawnWorker() {
-        if (this.worker) return;
-        if (this._currentMatchesTarget(this.desiredTarget)) return;
-        this.worker = this._runWorker().finally(() => {
-            this.worker = null;
-            // If the target shifted while the cycle was running and still
-            // differs from where we landed, debounce again before the next
-            // cycle so another spam burst coalesces.
-            if (!this._currentMatchesTarget(this.desiredTarget)) {
-                this._scheduleWorker();
-            }
-        });
-    }
-
-    // One stop + direction cycle. The worker re-reads this.desiredTarget at
-    // each decision point so a toggle that lands during the cycle is honoured;
-    // if the target has reverted to the current state, the direction is
-    // skipped and the worker exits.
-    async _runWorker() {
-        const {Characteristic} = this.hap;
-        if (this._currentMatchesTarget(this.desiredTarget)) return;
-
-        await this._sendAndAwaitReset(this.dpStop, STOP_RESET_TIMEOUT_MS);
-        await sleep(POST_RESET_DELAY_MS);
-
-        if (this._currentMatchesTarget(this.desiredTarget)) return;
-
-        const target = this.desiredTarget;
-        const directionDp = target === Characteristic.TargetDoorState.OPEN
-            ? this.dpOpen
-            : this.dpClose;
-        await this._sendAndAwaitReset(directionDp, DIRECTION_RESET_TIMEOUT_MS);
-        // Belt-and-braces: the persistent change listener will already have
-        // flipped this on the echo, but force-mirror in case the echo was
-        // missed so the next loop check exits cleanly.
-        this._setCurrentDoorState(target === Characteristic.TargetDoorState.OPEN
-            ? Characteristic.CurrentDoorState.OPEN
-            : Characteristic.CurrentDoorState.CLOSED);
-    }
-
-    _currentMatchesTarget(target) {
-        const {Characteristic} = this.hap;
-        if (target === Characteristic.TargetDoorState.OPEN) {
-            return this.currentDoorState === Characteristic.CurrentDoorState.OPEN;
+    _cancelPartialStop() {
+        if (this.partialStopTimer) {
+            clearTimeout(this.partialStopTimer);
+            this.partialStopTimer = null;
         }
-        return this.currentDoorState === Characteristic.CurrentDoorState.CLOSED;
-    }
-
-    // Writes the DP and resolves when the device echoes it back to false
-    // (signalling the action completed) or the timeout fires.
-    async _sendAndAwaitReset(dp, timeoutMs) {
-        const wait = this._waitForDpReset(dp, timeoutMs);
-        this.setMultiStateLegacyAsync({[dp]: true});
-        await wait;
-    }
-
-    _waitForDpReset(dp, timeoutMs) {
-        return new Promise(resolve => {
-            const cleanup = () => {
-                this.device.removeListener('change', onChange);
-                clearTimeout(timer);
-            };
-            const onChange = changes => {
-                if (changes && changes[dp] === false) {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const timer = setTimeout(() => {
-                cleanup();
-                resolve();
-            }, timeoutMs);
-            this.device.on('change', onChange);
-        });
     }
 }