homebridge-tydom 0.22.1 → 0.23.0

package/README.md

@@ -230,6 +230,18 @@ You can also use the following environment variables (base64 encoded values)
 | HOMEBRIDGE_TYDOM_PASSWORD | Tydom password  |
 | HOMEBRIDGE_TYDOM_PIN      | Tyxal+ pin      |
 
+### Help
+
+If you open a new issue, please provide a dump of your tydom configuration using node-tydom-client:
+
+```sh
+npx tydom-client request /configs/file /devices/data /devices/meta /devices/cmeta --file tydom_output.json --username 001A25XXXXXX --password XXXXXX
+```
+
+Will create the file `tydom_output.json` to upload, you can use [https://gist.github.com](gist.github.com).
+
+An homebridge log with [debug enabled](https://github.com/mgcrea/homebridge-tydom#debug) while using the tydom official app (to trace working requests) can also help a lot.
+
 ### Debug
 
 This library uses [debug](https://www.npmjs.com/package/debug) to provide high verbosity logs, just pass the following environment:

package/lib/accessories/basicGarageDoorOpener.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAccessory } from 'homebridge';
+import TydomController from '../controller';
+export declare const setupBasicGarageDoorOpener: (accessory: PlatformAccessory, controller: TydomController) => void;

package/lib/accessories/basicGarageDoorOpener.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBasicGarageDoorOpener = void 0;
+const hap_1 = require("../config/hap");
+const accessory_1 = require("../helpers/accessory");
+const debug_1 = require("../utils/debug");
+const setupBasicGarageDoorOpener = (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { deviceId, endpointId } = context;
+    (0, accessory_1.setupAccessoryInformationService)(accessory, controller);
+    (0, accessory_1.setupAccessoryIdentifyHandler)(accessory, controller);
+    // Add the actual accessory Service
+    const service = (0, accessory_1.addAccessoryService)(accessory, hap_1.Service.Switch, `${accessory.displayName}`, true);
+    // State
+    // const state = {
+    //   isOn: false
+    // };
+    service
+        .getCharacteristic(hap_1.Characteristic.On)
+        // .on(CharacteristicEventTypes.GET, async (callback: NodeCallback<CharacteristicValue>) => {
+        //   callback(null, state.isOn);
+        // })
+        .on("set" /* CharacteristicEventTypes.SET */, async (value, callback) => {
+        (0, debug_1.debugSet)(hap_1.Characteristic.On, service, value);
+        if (!value) {
+            callback();
+            return;
+        }
+        try {
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                {
+                    name: 'levelCmd',
+                    value: 'TOGGLE'
+                }
+            ]);
+            (0, debug_1.debugSetResult)(hap_1.Characteristic.On, service, value);
+            callback();
+            setTimeout(() => {
+                service.updateCharacteristic(hap_1.Characteristic.On, false);
+            }, 1000);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .updateValue(false);
+};
+exports.setupBasicGarageDoorOpener = setupBasicGarageDoorOpener;

package/lib/accessories/garageDoorOpener.d.ts

@@ -1,3 +1,5 @@
 import type { PlatformAccessory } from 'homebridge';
 import TydomController from '../controller';
+import { TydomAccessoryUpdateType } from '../helpers/accessory';
 export declare const setupGarageDoorOpener: (accessory: PlatformAccessory, controller: TydomController) => void;
+export declare const updateGarageDoorOpener: (accessory: PlatformAccessory, _controller: TydomController, updates: Record<string, unknown>[], type: TydomAccessoryUpdateType) => void;

package/lib/accessories/garageDoorOpener.js

@@ -1,49 +1,198 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupGarageDoorOpener = void 0;
+exports.updateGarageDoorOpener = exports.setupGarageDoorOpener = void 0;
 const hap_1 = require("../config/hap");
 const accessory_1 = require("../helpers/accessory");
+const basic_1 = require("../utils/basic");
+const chalk_1 = require("../utils/chalk");
 const debug_1 = require("../utils/debug");
 const setupGarageDoorOpener = (accessory, controller) => {
     const { context } = accessory;
     const { client } = controller;
-    const { deviceId, endpointId } = context;
+    const { CurrentDoorState, TargetDoorState } = hap_1.Characteristic;
+    const GARAGE_DOOR_DELAY = 15 * 1000;
+    const { deviceId, endpointId, state } = context;
+    const assignState = (update) => {
+        Object.assign(state, update);
+    };
+    const assignCurrentDoorState = (currentDoorState) => {
+        Object.assign(state, { currentDoorState });
+        service.updateCharacteristic(CurrentDoorState, currentDoorState);
+    };
+    const toggleGarageDoor = async () => await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+        {
+            name: 'levelCmd',
+            value: 'TOGGLE'
+        }
+    ]);
     (0, accessory_1.setupAccessoryInformationService)(accessory, controller);
     (0, accessory_1.setupAccessoryIdentifyHandler)(accessory, controller);
+    assignState({
+        currentDoorState: CurrentDoorState.CLOSED,
+        targetDoorState: TargetDoorState.CLOSED,
+        lastUpdatedAt: 0,
+        computedPosition: 0 // 0 <-> GARAGE_DOOR_DELAY
+    });
+    const getNextCurrentDoorState = (targetDoorState) => {
+        switch (state.currentDoorState) {
+            case CurrentDoorState.OPEN: {
+                switch (targetDoorState) {
+                    case TargetDoorState.CLOSED:
+                        return CurrentDoorState.OPENING;
+                    case TargetDoorState.OPEN:
+                        return CurrentDoorState.OPEN;
+                }
+                break;
+            }
+            case CurrentDoorState.CLOSED: {
+                switch (targetDoorState) {
+                    case TargetDoorState.CLOSED:
+                        return CurrentDoorState.CLOSED;
+                    case TargetDoorState.OPEN:
+                        return CurrentDoorState.CLOSING;
+                }
+                break;
+            }
+            case CurrentDoorState.CLOSING:
+            case CurrentDoorState.OPENING: {
+                return CurrentDoorState.STOPPED;
+            }
+            case CurrentDoorState.STOPPED: {
+                switch (targetDoorState) {
+                    case TargetDoorState.CLOSED:
+                        return CurrentDoorState.CLOSING;
+                    case TargetDoorState.OPEN:
+                        return CurrentDoorState.OPENING;
+                }
+                break;
+            }
+        }
+        return CurrentDoorState.CLOSED;
+    };
+    const computeCurrentPosition = () => {
+        const { lastUpdatedAt, computedPosition: lastComputedPosition, currentDoorState } = state;
+        const elapsed = lastUpdatedAt - Date.now();
+        switch (currentDoorState) {
+            case CurrentDoorState.STOPPED: {
+                return lastComputedPosition;
+            }
+            case CurrentDoorState.OPEN: {
+                return 100;
+            }
+            case CurrentDoorState.CLOSED: {
+                return 0;
+            }
+            case CurrentDoorState.OPENING: {
+                return Math.min(100, lastComputedPosition + elapsed / GARAGE_DOOR_DELAY);
+            }
+            case CurrentDoorState.CLOSING: {
+                return Math.max(0, lastComputedPosition - elapsed / GARAGE_DOOR_DELAY);
+            }
+        }
+        return 0;
+    };
     // Add the actual accessory Service
-    const service = (0, accessory_1.addAccessoryService)(accessory, hap_1.Service.Switch, `${accessory.displayName}`, true);
-    // State
-    // const state = {
-    //   isOn: false
-    // };
+    const service = (0, accessory_1.addAccessoryService)(accessory, hap_1.Service.GarageDoorOpener, `${accessory.displayName}`, true);
     service
-        .getCharacteristic(hap_1.Characteristic.On)
-        // .on(CharacteristicEventTypes.GET, async (callback: NodeCallback<CharacteristicValue>) => {
-        //   callback(null, state.isOn);
-        // })
+        .getCharacteristic(CurrentDoorState)
+        .on("get" /* CharacteristicEventTypes.GET */, async (callback) => {
+        (0, debug_1.debugGet)(CurrentDoorState, service);
+        try {
+            const nextValue = state.currentDoorState;
+            (0, debug_1.debugGetResult)(CurrentDoorState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(TargetDoorState)
+        .on("get" /* CharacteristicEventTypes.GET */, async (callback) => {
+        (0, debug_1.debugGet)(TargetDoorState, service);
+        try {
+            const nextValue = state.targetDoorState;
+            (0, debug_1.debugGetResult)(TargetDoorState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
         .on("set" /* CharacteristicEventTypes.SET */, async (value, callback) => {
-        (0, debug_1.debugSet)(hap_1.Characteristic.On, service, value);
+        (0, debug_1.debugSet)(TargetDoorState, service, value);
         if (!value) {
             callback();
             return;
         }
         try {
-            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
-                {
-                    name: 'levelCmd',
-                    value: 'TOGGLE'
-                }
-            ]);
-            (0, debug_1.debugSetResult)(hap_1.Characteristic.On, service, value);
+            (0, debug_1.debugSetResult)(TargetDoorState, service, value);
+            const targetDoorState = (0, basic_1.asNumber)(value);
+            assignState({
+                targetDoorState: targetDoorState,
+                lastUpdatedAt: Date.now(),
+                computedPosition: computeCurrentPosition()
+            });
+            let nextCurrentDoorState = getNextCurrentDoorState(targetDoorState);
+            if (nextCurrentDoorState === state.currentDoorState) {
+                (0, debug_1.debug)(`nextCurrentDoorState=${(0, chalk_1.chalkNumber)(nextCurrentDoorState)} === state.currentDoorState`);
+                callback();
+                return;
+            }
+            await toggleGarageDoor();
+            assignCurrentDoorState(nextCurrentDoorState);
             callback();
-            setTimeout(() => {
-                service.updateCharacteristic(hap_1.Characteristic.On, false);
-            }, 1000);
+            // Handle Stopped state, if we are stopped, wait one second and trigger again to reverse course
+            // eg. Stopped -> Closing if target is Closed
+            if (nextCurrentDoorState === CurrentDoorState.STOPPED) {
+                await (0, basic_1.waitFor)(1000);
+                assignState({
+                    targetDoorState: targetDoorState,
+                    lastUpdatedAt: Date.now(),
+                    computedPosition: computeCurrentPosition()
+                });
+                nextCurrentDoorState = getNextCurrentDoorState(targetDoorState);
+                await toggleGarageDoor();
+                assignCurrentDoorState(nextCurrentDoorState);
+            }
+            // Finally update pending states
+            switch (nextCurrentDoorState) {
+                case CurrentDoorState.OPENING:
+                    await (0, basic_1.waitFor)((100 - state.computedPosition) * GARAGE_DOOR_DELAY);
+                    assignCurrentDoorState(CurrentDoorState.OPEN);
+                    break;
+                case CurrentDoorState.CLOSING:
+                    await (0, basic_1.waitFor)(state.computedPosition * GARAGE_DOOR_DELAY);
+                    assignCurrentDoorState(CurrentDoorState.CLOSED);
+                    break;
+            }
         }
         catch (err) {
             callback(err);
         }
     })
-        .updateValue(false);
+        .getValue();
 };
 exports.setupGarageDoorOpener = setupGarageDoorOpener;
+const updateGarageDoorOpener = (accessory, _controller, updates, type) => {
+    const { context } = accessory;
+    // const {state} = context as TydomAccessoryContext<State>;
+    // Process command updates
+    if (type === 'cdata') {
+        updates.forEach((update) => {
+            const { values } = update;
+            const { event } = values;
+            (0, debug_1.debug)(`New ${(0, chalk_1.chalkKeyword)('GarageDoorOpener')} event=${(0, chalk_1.chalkJson)(event)}`);
+        });
+        return;
+    }
+    updates.forEach((update) => {
+        const { name, value } = update;
+        switch (name) {
+            default:
+                return;
+        }
+    });
+};
+exports.updateGarageDoorOpener = updateGarageDoorOpener;

package/lib/utils/basic.d.ts

@@ -1,3 +1,4 @@
 export declare const stringIncludes: (array: unknown[], value: string | number) => boolean;
 export declare const sameArrays: (source: unknown[], array: unknown[]) => boolean;
 export declare const asNumber: (maybeNumber: unknown) => number;
+export declare const waitFor: (ms: number) => Promise<void>;

package/lib/utils/basic.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asNumber = exports.sameArrays = exports.stringIncludes = void 0;
+exports.waitFor = exports.asNumber = exports.sameArrays = exports.stringIncludes = void 0;
 const lodash_1 = require("lodash");
 const stringIncludes = (array, value) => array.includes(value) || array.includes(`${value}`);
 exports.stringIncludes = stringIncludes;
@@ -8,3 +8,5 @@ const sameArrays = (source, array) => source.length === array.length && (0, loda
 exports.sameArrays = sameArrays;
 const asNumber = (maybeNumber) => parseInt(`${maybeNumber}`, 10);
 exports.asNumber = asNumber;
+const waitFor = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.waitFor = waitFor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tydom",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Homebridge plugin to manage Tydom devices by Delta Dore",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",