homebridge-tuya-plus 3.14.0-dev.46 → 3.14.0-dev.48

package/lib/SimpleGarageDoorAccessory.js

@@ -120,6 +120,11 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             ? Characteristic.TargetDoorState.OPEN
             : Characteristic.TargetDoorState.CLOSED;
         this.accessory.context.cachedTargetDoorState = initialTarget;
+        // The level-triggered dispatch baseline (see setTargetDoorState). Held
+        // separately from cachedTargetDoorState because that one mirrors every
+        // reported value for HomeKit's benefit — including the transient "stopped"
+        // our own stop-before-close produces — which must not move this baseline.
+        this._committedTarget = initialTarget;
 
         this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
             .updateValue(initialTarget)
@@ -201,11 +206,24 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         // (=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]);
+        const raw = typeof changes[this.dpState] === 'string' ? parseInt(changes[this.dpState], 10) : changes[this.dpState];
+        const isOpen = this._mapDpState(raw);
         if (isOpen === null) {
             this.log.debug(`[SimpleGarageDoor] ${this.device.context.name}: ignoring unknown state DP value ${JSON.stringify(changes[this.dpState])}`);
             return;
         }
+        // Keep the level-triggered dispatch baseline honest with the gate's real
+        // position, but only from a DEFINITIVE report — 12 (opening/open) or 13
+        // (closing/closed). A bare 11 (stopped) is skipped: it is exactly what our
+        // own stop-before-close pulse makes the controller report, and over the LAN
+        // that report can land just after the stop→close window. Letting it flip
+        // the committed target back to OPEN is what let HomeKit's repeat close fire
+        // a second stop-before-close into the already-closing gate. A genuine
+        // external open always passes through 12 first, so nothing is missed.
+        if (raw === STATE_OPENING_OR_OPEN || raw === STATE_CLOSING_OR_CLOSED) {
+            const {Characteristic} = this.hap;
+            this._committedTarget = isOpen ? Characteristic.TargetDoorState.OPEN : Characteristic.TargetDoorState.CLOSED;
+        }
         this._applyReportedState(isOpen);
     }
 
@@ -257,6 +275,22 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         // 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();
+
+        // The opener is level-triggered: act only when the requested target
+        // differs from the one we've already committed to. HomeKit re-sends the
+        // same target after a tap — a second controller echoing it, or its own
+        // retry a few seconds later — and acting on that repeat would fire another
+        // open/close. For a close that means a second stop-before-close into the
+        // already-closing gate, halting it mid-travel and restarting it (the
+        // reported stutter). A genuine request always flips the target (the Home
+        // app toggles to the opposite state). The committed target is reconciled
+        // with the gate's real position in _onDeviceChange so external operation
+        // still works — but only from a definitive report, never from the
+        // "stopped" transient our own stop produces, so the repeat stays caught.
+        if (value === this._committedTarget) {
+            this.log.debug(`[SimpleGarageDoor] ${this.device.context.name}: target unchanged — ignoring repeat request`);
+            return;
+        }
         this._applyTarget(value);
     }
 
@@ -267,6 +301,7 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
     _applyTarget(value) {
         const {Characteristic} = this.hap;
         const open = value === Characteristic.TargetDoorState.OPEN;
+        this._committedTarget = value;
         this.accessory.context.cachedTargetDoorState = value;
         if (this.characteristicTargetDoorState) this.characteristicTargetDoorState.updateValue(value);
         if (open) this._sendOpen();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.14.0-dev.46",
+  "version": "3.14.0-dev.48",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices in HomeKit. LAN-first, with an optional Tuya Cloud fallback for any device the LAN can't reach.",
   "main": "index.js",
   "scripts": {

package/test/SimpleGarageDoorAccessory.test.js

@@ -68,6 +68,7 @@ function makeSimpleGarage(initialContext = {}) {
         updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
     };
     accessory.context.cachedTargetDoorState = TDS.CLOSED;
+    instance._committedTarget = TDS.CLOSED;
 
     // Mirror the persistent change listener registered in production.
     device.on('change', changes => instance._onDeviceChange(changes));
@@ -226,9 +227,19 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
+    // A close is only ever issued from an open gate, so the committed target
+    // (cachedTargetDoorState) starts OPEN — the state HomeKit shows before the
+    // tap. Without it the very first close would match the helper's default
+    // committed target and be (correctly) treated as a redundant repeat.
+    function openGate(instance, device, state = STATE_OPENING_OR_OPEN) {
+        if (state !== undefined) device.state['105'] = state;
+        instance.accessory.context.cachedTargetDoorState = TDS.OPEN;
+        instance._committedTarget = TDS.OPEN;
+    }
+
     test('CLOSE fires immediately when the gate is already stopped (state 11)', () => {
         const { instance, device, accessory } = makeSimpleGarage();
-        device.state['105'] = STATE_STOPPED;
+        openGate(instance, device, STATE_STOPPED);
 
         instance.setTargetDoorState(TDS.CLOSED);
 
@@ -242,7 +253,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     test('CLOSE while opening (state 12) fires stop, then close after stopBeforeCloseMs', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
 
         instance.setTargetDoorState(TDS.CLOSED);
 
@@ -259,10 +270,10 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
         expect(instance.pendingCloseTimer).toBeNull();
     });
 
-    test('CLOSE while closing (state 13) also uses stop-before-close', () => {
+    test('CLOSE that reads state 13 still uses stop-before-close (13 is not "stopped")', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        device.state['105'] = STATE_CLOSING_OR_CLOSED;
+        openGate(instance, device, STATE_CLOSING_OR_CLOSED);
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
@@ -274,7 +285,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     test('CLOSE with no reported state yet uses stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        // device.state['105'] intentionally left undefined
+        openGate(instance, device, undefined); // device.state['105'] left undefined
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
@@ -286,7 +297,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     test('A duplicate CLOSE during the wait does not restart or double-fire', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenCalledTimes(1); // stop
@@ -300,10 +311,71 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
         expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
     });
 
+    test('A repeat close once committed is swallowed — no second stop-before-close into the moving gate', () => {
+        // HomeKit re-sends the same target seconds after a tap (a second
+        // controller echoing it, or its own retry). Acting on it fired another
+        // stop-before-close that halted the closing gate and restarted it — the
+        // reported stutter. Level-triggered dispatch makes the repeat a no-op.
+        const { instance, device } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
+
+        instance.setTargetDoorState(TDS.CLOSED);
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenCalledTimes(2); // stop + close
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
+
+        // The gate is now committed closed and still travelling (reports 13).
+        emitState(device, STATE_CLOSING_OR_CLOSED);
+        jest.advanceTimersByTime(3000);
+        instance.setTargetDoorState(TDS.CLOSED); // HomeKit's repeat close
+        expect(device.update).toHaveBeenCalledTimes(2); // swallowed — no second stop/close
+    });
+
+    test('A stopped (11) report after the close does not re-enable the repeat (LAN stutter)', () => {
+        // Over the LAN the stop pulse makes the controller report 11 (=OPEN) just
+        // after the close has gone out — outside the stop-before-close window. That
+        // 11 must NOT move the committed target back to OPEN, or HomeKit's repeat
+        // close would fire a second stop-before-close into the already-closing gate.
+        const { instance, device } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
+
+        instance.setTargetDoorState(TDS.CLOSED);
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenCalledTimes(2); // stop + close
+
+        emitState(device, STATE_STOPPED); // the stop's late 11 report
+        expect(instance._committedTarget).toBe(TDS.CLOSED); // not bounced to OPEN
+        instance.setTargetDoorState(TDS.CLOSED); // HomeKit's repeat
+        expect(device.update).toHaveBeenCalledTimes(2); // swallowed
+    });
+
+    test('A close runs again once the gate is reported open (committed target tracks reports)', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
+
+        instance.setTargetDoorState(TDS.CLOSED);
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenCalledTimes(2); // stop + close
+        emitState(device, STATE_CLOSING_OR_CLOSED); // committed = closed
+
+        instance.setTargetDoorState(TDS.CLOSED); // repeat — swallowed
+        expect(device.update).toHaveBeenCalledTimes(2);
+
+        // The gate is opened again (here, externally) — a close is a real
+        // transition once more and runs.
+        emitState(device, STATE_OPENING_OR_OPEN); // committed = open
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenCalledTimes(3);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '103': true });
+    });
+
     test('OPEN during the wait cancels the pending close and opens instead', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenNthCalledWith(1, { '103': true }); // stop
@@ -321,7 +393,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     test('Status reports are ignored during the stop-before-close window', () => {
         const { instance, device, accessory } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 1500;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
         instance.currentDoorState = CDS.OPEN;
         instance.characteristicCurrentDoorState.value = CDS.OPEN;
 
@@ -345,7 +417,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
     test('stopBeforeCloseMs is configurable', () => {
         const { instance, device } = makeSimpleGarage();
         instance.stopBeforeCloseMs = 300;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
@@ -361,7 +433,7 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
         instance.dpClose = '2';
         instance.dpStop = '4';
         instance.stopBeforeCloseMs = 1000;
-        device.state['105'] = STATE_OPENING_OR_OPEN;
+        openGate(instance, device, STATE_OPENING_OR_OPEN);
 
         instance.setTargetDoorState(TDS.CLOSED);
         expect(device.update).toHaveBeenNthCalledWith(1, { '4': true });
@@ -580,6 +652,7 @@ describe('SimpleGarageDoorAccessory — force switches', () => {
     test('Force Close fires the close action (immediately when already stopped)', () => {
         const { instance, device, accessory } = makeSimpleGarage();
         device.state['105'] = STATE_STOPPED;
+        instance._committedTarget = TDS.OPEN; // gate open → close is a real transition
 
         instance.setTargetDoorState(TDS.CLOSED);