homebridge-tuya-plus 3.1.2

package/lib/CustomMultiOutletAccessory.js

@@ -0,0 +1,111 @@
+const BaseAccessory = require('./BaseAccessory');
+const async = require('async');
+
+class CustomMultiOutletAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.OUTLET;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        this._verifyCachedPlatformAccessory();
+        this._justRegistered = true;
+
+        super._registerPlatformAccessory();
+    }
+
+    _verifyCachedPlatformAccessory() {
+        if (this._justRegistered) return;
+
+        const {Service} = this.hap;
+
+        if (!Array.isArray(this.device.context.outlets)) {
+            throw new Error('The outlets definition is missing or is malformed: ' + this.device.context.outlets);
+        }
+        const _validServices = [];
+        this.device.context.outlets.forEach((outlet, i) => {
+            if (!outlet || !outlet.hasOwnProperty('name') || !outlet.hasOwnProperty('dp') || !isFinite(outlet.dp))
+                throw new Error('The outlet definition #${i} is missing or is malformed: ' + outlet);
+
+            const name = ((outlet.name || '').trim() || 'Unnamed') + ' - ' + this.device.context.name;
+            let service = this.accessory.getServiceByUUIDAndSubType(Service.Outlet, 'outlet ' + outlet.dp);
+            if (service) this._checkServiceName(service, name);
+            else service = this.accessory.addService(Service.Outlet, name, 'outlet ' + outlet.dp);
+
+            _validServices.push(service);
+        });
+
+        this.accessory.services
+            .filter(service => service.UUID === Service.Outlet.UUID && !_validServices.includes(service))
+            .forEach(service => {
+                this.accessory.removeService(service);
+            });
+    }
+
+    _registerCharacteristics(dps) {
+        this._verifyCachedPlatformAccessory();
+
+        const {Service, Characteristic} = this.hap;
+
+        const characteristics = {};
+        this.accessory.services.forEach(service => {
+            if (service.UUID !== Service.Outlet.UUID || !service.subtype) return false;
+
+            let match;
+            if ((match = service.subtype.match(/^outlet (\d+)$/)) === null) return;
+
+            characteristics[match[1]] = service.getCharacteristic(Characteristic.On)
+                .updateValue(dps[match[1]])
+                .on('get', this.getPower.bind(this, match[1]))
+                .on('set', this.setPower.bind(this, match[1]));
+        });
+
+        this.device.on('change', (changes, state) => {
+            Object.keys(changes).forEach(key => {
+                if (characteristics[key] && characteristics[key].value !== changes[key]) characteristics[key].updateValue(changes[key]);
+            });
+        });
+    }
+
+    getPower(dp, callback) {
+        callback(null, this.device.state[dp]);
+    }
+
+    setPower(dp, value, callback) {
+        if (!this._pendingPower) {
+            this._pendingPower = {props: {}, callbacks: []};
+        }
+
+        if (dp) {
+            if (this._pendingPower.timer) clearTimeout(this._pendingPower.timer);
+
+            this._pendingPower.props = {...this._pendingPower.props, ...{[dp]: value}};
+            this._pendingPower.callbacks.push(callback);
+
+            this._pendingPower.timer = setTimeout(() => {
+                this.setPower();
+            }, 500);
+            return;
+        }
+
+        const callbacks = this._pendingPower.callbacks;
+        const callEachBack = err => {
+            async.eachSeries(callbacks, (callback, next) => {
+                try {
+                    callback(err);
+                } catch (ex) {}
+                next();
+            });
+        };
+
+        const newValue = this._pendingPower.props;
+        this._pendingPower = null;
+
+        this.setMultiState(newValue, callEachBack);
+    }
+}
+
+module.exports = CustomMultiOutletAccessory;

package/lib/DehumidifierAccessory.js

@@ -0,0 +1,301 @@
+const BaseAccessory = require('./BaseAccessory');
+
+const STATE_OTHER = 9;
+
+class DehumidifierAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.DEHUMIDIFIER;
+    }
+
+    constructor(...props) {
+        super(...props);
+
+        this.cmdDehumidify = '0';
+        this.cmdContinual = '1';
+        this.cmdAuto = '2';
+        this.cmdLaundry = '3';
+
+        this.defaultDps = {
+            'Active':     1,
+            'Mode':       2, // 0 - normal, 1 - continual, 2 - automatic, 3 - laundry
+            'Humidity':   4,
+            'Cleaning':   5,
+            'FanSpeed':   6, // 1 - slow, 3 - fast
+            'ChildLock':  7,
+            'TankState': 11, // 0 - not full, 8 - removed, ... - ?
+            // 12, 101, 105 - ?
+            'Sleep':    102,
+            'CurrentTemperature': 103,
+            'CurrentHumidity':    104,
+        }
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.TemperatureSensor, this.device.context.name);
+        this.accessory.addService(Service.HumiditySensor, this.device.context.name);
+        this.accessory.addService(Service.HumidifierDehumidifier, this.device.context.name);
+
+        if (!this.device.context.noChildLock) {
+            this.accessory.addService(Service.LockMechanism, this.device.context.name + ' - Child Lock');
+        }
+
+        if (!this.device.context.noSpeed) {
+            this.accessory.addService(Service.Fan, this.device.context.name);
+        }
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+
+        const infoService = this.accessory.getService(Service.AccessoryInformation);
+        infoService.getCharacteristic(Characteristic.Manufacturer).updateValue(this.device.context.manufacturer);
+        infoService.getCharacteristic(Characteristic.Model).updateValue(this.device.context.model);
+
+        const characteristicTemperature = this.accessory.getService(Service.TemperatureSensor)
+            .getCharacteristic(Characteristic.CurrentTemperature)
+            .updateValue(this._getCurrentTemperature(dps[this.getDp('CurrentTemperature')]))
+            .on('get', this.getCurrentTemperature.bind(this));
+
+
+        const characteristicCurrentHumidity = this.accessory.getService(Service.HumiditySensor)
+            .getCharacteristic(Characteristic.CurrentRelativeHumidity)
+            .updateValue(this._getCurrentHumidity(dps[this.getDp('CurrentHumidity')]))
+            .on('get', this.getCurrentHumidity.bind(this));
+
+        const service = this.accessory.getService(Service.HumidifierDehumidifier);
+        this._checkServiceName(service, this.device.context.name);
+
+        let characteristicSpeed;
+        if (!this.device.context.noSpeed) {
+            let fanService = this.accessory.getService(Service.Fan);
+            characteristicSpeed = fanService.getCharacteristic(Characteristic.RotationSpeed)
+                .setProps({
+                    minValue: this.device.context.minSpeed || 1,
+                    maxValue: this.device.context.maxSpeed || 2,
+                    minStep: this.device.context.speedSteps || 1,
+                })
+                .updateValue(this._getRotationSpeed(dps))
+                .on('get', this.getRotationSpeed.bind(this))
+                .on('set', this.setRotationSpeed.bind(this));
+        }
+
+        this._removeCharacteristic(service, Characteristic.SwingMode);
+        service.getCharacteristic(Characteristic.CurrentHumidifierDehumidifierState)
+            .updateValue(Characteristic.CurrentHumidifierDehumidifierState.DEHUMIDIFYING);
+        service.getCharacteristic(Characteristic.TargetHumidifierDehumidifierState)
+            .updateValue(Characteristic.TargetHumidifierDehumidifierState.DEHUMIDIFIER);
+
+        const characteristicCurrentHumidity2 = service.getCharacteristic(Characteristic.CurrentRelativeHumidity)
+            .updateValue(this._getCurrentHumidity(dps[this.getDp('CurrentHumidity')]))
+            .on('get', this.getCurrentHumidity.bind(this));
+
+        const characteristicActive = service.getCharacteristic(Characteristic.Active)
+            .updateValue(this._getActive(dps[this.getDp('Active')]))
+            .on('get', this.getActive.bind(this))
+            .on('set', this.setActive.bind(this));
+
+        const characteristicWaterTank = service.getCharacteristic(Characteristic.WaterLevel)
+            .updateValue(dps[this.getDp('TankState')])
+            .on('get', this.getTankState.bind(this))
+
+        let characteristicChildLock;
+
+        if (!this.device.context.noChildLock) {
+            let lockService = this.accessory.getService(Service.LockMechanism);
+            characteristicChildLock = lockService.getCharacteristic(Characteristic.LockCurrentState)
+                .updateValue(this._getLockTargetState(dps[this.getDp('ChildLock')]))
+                .on('get', this.getLockTargetState.bind(this));
+            characteristicChildLock = lockService.getCharacteristic(Characteristic.LockTargetState)
+                .updateValue(this._getLockTargetState(dps[this.getDp('ChildLock')]))
+                .on('get', this.getLockTargetState.bind(this))
+                .on('set', this.setLockTargetState.bind(this));
+        } else this._removeCharacteristic(service, Characteristic.LockTargetState);
+
+        this.characteristicHumidity = service.getCharacteristic(Characteristic.RelativeHumidityDehumidifierThreshold);
+        this.characteristicHumidity.setProps({
+                minStep: this.device.context.humiditySteps || 5,
+            })
+            .updateValue(dps[this.getDp('Humidity')])
+            .on('get', this.getState.bind(this, this.getDp('Humidity')))
+            .on('set', this.setTargetHumidity.bind(this));
+
+
+        this.device.on('change', (changes, state) => {
+            if (changes.hasOwnProperty(this.getDp('Active'))) {
+                const newActive = this._getActive(changes[this.getDp('Active')]);
+                if (characteristicActive.value !== newActive) {
+                    characteristicActive.updateValue(newActive);
+
+                    if (!changes.hasOwnProperty(this.getDp('FanSpeed'))) {
+                        characteristicSpeed.updateValue(this._getRotationSpeed(state));
+                    }
+                }
+            }
+
+            if (changes.hasOwnProperty('Humidity') && this.characteristicHumidity.value !== changes[this.getDp('Humidity')]) this.characteristicHumidity.updateValue(changes[this.getDp('Humidity')]);
+
+            if (characteristicChildLock && changes.hasOwnProperty(this.getDp('ChildLock'))) {
+                const newChildLock = this._getLockTargetState(changes[this.getDp('ChildLock')]);
+                if (characteristicChildLock.value !== newChildLock) characteristicChildLock.updateValue(newChildLock);
+            }
+
+            if (changes.hasOwnProperty(this.getDp('FanSpeed'))) {
+                const newSpeed = this._getRotationSpeed(state);
+                if (characteristicSpeed.value !== newSpeed) characteristicSpeed.updateValue(newSpeed);
+            }
+        });
+    }
+
+    getActive(callback) {
+        this.getState(this.getDp('Active'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getActive(dp));
+        });
+    }
+
+    _getActive(dp) {
+        const {Characteristic} = this.hap;
+
+        return dp ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
+    }
+
+    setActive(value, callback) {
+        const {Characteristic} = this.hap;
+
+        switch (value) {
+            case Characteristic.Active.ACTIVE:
+                return this.setState(this.getDp('Active'), true, callback);
+
+            case Characteristic.Active.INACTIVE:
+                return this.setState(this.getDp('Active'), false, callback);
+        }
+
+        callback();
+    }
+
+    getTankState(callback) {
+        this.getState(this.getDp('TankState'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getTankState(dp));
+        });
+    }
+
+    _getTankState(dp) {
+        const {Characteristic} = this.hap;
+
+        return dp ? 100 : 50;
+    }
+
+    getLockTargetState(callback) {
+        this.getState(this.getDp('ChildLock'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getLockTargetState(dp));
+        });
+    }
+
+    _getLockTargetState(dp) {
+        const {Characteristic} = this.hap;
+
+        return dp ? Characteristic.LockTargetState.SECURED : Characteristic.LockTargetState.UNSECURED;
+    }
+
+    setLockTargetState(value, callback) {
+        if (this.device.context.noLock) return callback();
+
+        const {Characteristic} = this.hap;
+
+        switch (value) {
+            case Characteristic.LockTargetState.SECURED:
+                return this.setState(this.getDp('ChildLock'), true, callback);
+
+            case Characteristic.LockTargetState.UNSECURED:
+                return this.setState(this.getDp('ChildLock'), false, callback);
+        }
+
+        callback();
+    }
+
+    getRotationSpeed(callback) {
+        this.getState(this.getDp('FanSpeed'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getRotationSpeed(dp));
+        });
+    }
+
+    _getRotationSpeed(dp) {
+        const {Characteristic} = this.hap;
+
+        return dp > 1 ? dp-1 : dp;
+    }
+
+    setRotationSpeed(value, callback) {
+        if (this.device.context.noSpeed) return callback();
+        value > 1 ? value++ : null;
+        return this.setState(this.getDp('FanSpeed'), value.toString(), callback);
+    }
+
+    getCurrentHumidity(callback) {
+        this.getState(this.getDp('CurrentHumidity'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getCurrentHumidity(dp));
+        });
+    }
+
+    _getCurrentHumidity(dp) {
+        return dp;
+    }
+
+    getCurrentTemperature(callback) {
+        this.getState(this.getDp('CurrentTemperature'), (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getCurrentTemperature(dp));
+        });
+    }
+
+    _getCurrentTemperature(dp) {
+        return dp;
+    }
+
+    getTargetHumidity(callback) {
+        this.getState([this.getDp('Active'), this.getDp('Humidity')], (err, dps) => {
+            if (err) return callback(err);
+
+            callback(null, this._getTargetHumidity(dps));
+        });
+    }
+
+    _getTargetHumidity(dps) {
+        if (!dps[this.getDp('Active')]) return 0;
+
+        return dps[this.getDp('Humidity')];
+    }
+
+    setTargetHumidity(value, callback) {
+        const {Characteristic} = this.hap;
+
+        let origValue = value;
+        value = Math.max(value, this.device.context.minHumidity || 40);
+        value = Math.min(value, this.device.context.maxHumidity || 80);
+        if (origValue != value) {
+            this.characteristicHumidity.updateValue(value);
+        }
+
+        this.setMultiState({[this.getDp('Active')]: true, [this.getDp('Humidity')]: value}, callback);
+    }
+
+    getDp(name) {
+        return this.device.context['dps' + name] ? this.device.context['dps' + name] : this.defaultDps[name];
+    }
+}
+
+module.exports = DehumidifierAccessory;

package/lib/DoorbellAccessory.js

@@ -0,0 +1,208 @@
+const BaseAccessory = require('./BaseAccessory');
+const async = require('async');
+const https = require('https');
+const url = require('url');
+
+const DP_DOORBELL = '154'; // provides base64-encoded URL of static image
+const DP_DOOR = '148'; // provides boolean of whether the switch is toggled
+const DP_GATE = '232'; // provides boolean of whether the switch is toggled 
+
+const LOCK_TIMEOUT = 5000;
+
+class DoorbellDelegate /*extends CameraStreamingDelegate*/ {
+
+    constructor() {
+        this.cameraImage = undefined;
+    }
+
+    setCameraImage(image) {
+      this.cameraImage = image;
+    }
+
+    storeImage(urlString, callback) {
+        const urlObject = url.parse(urlString);
+        const me = this;
+        https.get(urlObject, 
+            function(res) {
+                var body=Buffer.alloc(0);
+
+                if (res.statusCode!==200) {
+                    return console.error('HTTP '+res.statusCode);
+                }
+
+                res.on('data', function(chunk) {
+                    body=Buffer.concat([body, chunk]);
+                });
+
+                res.on('end', function() {
+                    me.setCameraImage(body);
+                    console.log("Image stored");
+                    callback();
+                    console.log("Callback after image store complete");
+                });
+
+                res.on('error', function(err) {
+                    console.error(err);
+                });
+            }
+        );
+    }
+
+    /* SnapshotRequest, SnapshotRequestCallback (function taking error or HAPStatus and Buffer), returns void */
+    handleSnapshotRequest(request, callback) {
+        //TODO honour the image size in the request (SnapshotRequest).
+        callback(undefined, this.cameraImage);
+    }
+
+    
+    /* PrepareStreamRequest, PrepareStreamCallback (function taking optional error and PrepareStreamResponse), returns void */
+    prepareStream(request, callback) {
+
+    }
+
+    /* StreamingRequest, StreamRequestCallback (function taking optional Error), returns void */
+    handleStreamRequest(request, callback) {
+
+    }
+}
+
+class DoorbellAccessory extends BaseAccessory {
+    
+    static getCategory(Categories) {
+        return Categories.CAMERA;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service, Characteristic} = this.hap;
+
+        const doorbellService = this.accessory.getService(Service.Doorbell) || this.accessory.addService(Service.Doorbell);
+        this._checkServiceName(doorbellService, this.device.context.name);
+
+        doorbellService.setPrimaryService(true);
+        super._registerPlatformAccessory();
+    }
+
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+
+        this.configureCamera();
+
+        const service = this.accessory.getService(Service.Doorbell);
+
+
+        this.device.on('change', (changes, state) => {
+            //console.log(`Changes: ${JSON.stringify(changes)}, State: ${JSON.stringify(state)}`);
+
+            if (changes.hasOwnProperty(DP_DOORBELL)) {
+                const urlBase64 = changes[DP_DOORBELL];
+                const strUrl = Buffer.from(urlBase64, 'base64');
+                //console.log(`Image URL: ${strUrl}`);
+
+                this.streamingDelegate.storeImage(strUrl.toString(), () => {
+                  service.updateCharacteristic(Characteristic.ProgrammableSwitchEvent, Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
+                  });
+            }
+
+            if (changes.hasOwnProperty(DP_DOOR)) {
+                console.log("Door button pressed");
+            }
+
+            if (changes.hasOwnProperty(DP_GATE)) {
+                console.log("Gate button pressed");
+            }
+        });
+    }
+
+    configureCamera() {
+        this.streamingDelegate = new DoorbellDelegate();
+        console.log("created streaming delegate");
+        const options = {
+          cameraStreamCount: 1, 
+          delegate: this.streamingDelegate,
+          streamingOptions: {
+            supportedCryptoSuites: [this.hap.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80],
+            video: {
+              resolutions: [
+                [320, 180, 30],
+                [320, 240, 15], // Apple Watch requires this configuration
+                [320, 240, 30],
+                [480, 270, 30],
+                [480, 360, 30],
+                [640, 360, 30],
+                [640, 480, 30],
+                [1280, 720, 30],
+                [1280, 960, 30],
+                [1920, 1080, 30],
+                [1600, 1200, 30],
+              ],
+              codec: {
+                profiles: [this.hap.H264Profile.BASELINE, this.hap.H264Profile.MAIN, this.hap.H264Profile.HIGH],
+                levels: [this.hap.H264Level.LEVEL3_1, this.hap.H264Level.LEVEL3_2, this.hap.H264Level.LEVEL4_0],
+              },
+            },
+            audio: {
+              twoWayAudio: true,
+              codecs: [
+                {
+                  type: this.hap.AudioStreamingCodecType.AAC_ELD,
+                  samplerate: this.hap.AudioStreamingSamplerate.KHZ_16,
+                },
+              ],
+            },
+          },
+        };
+    
+        //console.log("created options");
+        const cameraController = new this.hap.CameraController(options);
+        //console.log("created controller");
+    
+        this.accessory.configureController(cameraController);
+        //console.log("configured controller with accessory");
+    }
+
+    pushDoor(callback) {
+        this.device.update({[DP_DOOR.toString()] : !this.device.state[DP_DOOR]});
+    }
+
+    pushGate(callback) {
+        this.setState(DP_GATE, !this.device.state[DP_GATE]);
+    }
+
+
+    handleLockCurrentStateGet() {
+        return this.doorState;
+      }
+    
+      handleLockTargetStateGet() {
+        return this.doorState;
+      }
+    
+      async handleLockTargetStateSet(value) {
+        const {Service, Characteristic} = this.hap;
+        const service = this.accessory.getService(Service.LockMechanism);
+
+        try {
+          this.pushDoor();
+    
+          service.getCharacteristic(Characteristic.LockCurrentState).updateValue(value);
+          service.getCharacteristic(Characteristic.LockTargetState).updateValue(value);
+          this.doorState = value;
+    
+          setTimeout(() => {
+            service.getCharacteristic(Characteristic.LockCurrentState).updateValue(Characteristic.LockCurrentState.SECURED);
+            service.getCharacteristic(Characteristic.LockTargetState).updateValue(Characteristic.LockTargetState.SECURED);
+            this.doorState = Characteristic.LockTargetState.SECURED;
+          }, LOCK_TIMEOUT);
+        } catch (error) {
+          this.log.error('Unlock failed', error);
+        }
+      }
+
+}
+
+module.exports = DoorbellAccessory;

package/lib/EnergyCharacteristics.js

@@ -0,0 +1,86 @@
+// Thanks to homebridge-tplink-smarthome
+
+module.exports = function(Characteristic) {
+    class EnergyCharacteristic extends Characteristic {
+        constructor(displayName, UUID, props) {
+            super(displayName, UUID);
+            this.setProps(Object.assign({
+                format: Characteristic.Formats.FLOAT,
+                minValue: 0,
+                maxValue: 65535,
+                perms: [Characteristic.Perms.READ, Characteristic.Perms.NOTIFY]
+            }, props));
+            this.value = this.getDefaultValue();
+        }
+    }
+
+    class Amperes extends EnergyCharacteristic {
+        constructor() {
+            super('Amperes', Amperes.UUID, {
+                unit: 'A',
+                minStep: 0.001
+            });
+        }
+    }
+
+    Amperes.UUID = 'E863F126-079E-48FF-8F27-9C2605A29F52';
+
+    class KilowattHours extends EnergyCharacteristic {
+        constructor() {
+            super('Total Consumption', KilowattHours.UUID, {
+                unit: 'kWh',
+                minStep: 0.001
+            });
+        }
+    }
+
+    KilowattHours.UUID = 'E863F10C-079E-48FF-8F27-9C2605A29F52';
+
+    class KilowattVoltAmpereHour extends EnergyCharacteristic {
+        constructor() {
+            super('Apparent Energy', KilowattVoltAmpereHour.UUID, {
+                format: Characteristic.Formats.UINT32,
+                unit: 'kVAh',
+                minStep: 1
+            });
+        }
+    }
+
+    KilowattVoltAmpereHour.UUID = 'E863F127-079E-48FF-8F27-9C2605A29F52';
+
+    class VoltAmperes extends EnergyCharacteristic {
+        constructor() {
+            super('Apparent Power', VoltAmperes.UUID, {
+                format: Characteristic.Formats.UINT16,
+                unit: 'VA',
+                minStep: 1
+            });
+        }
+    }
+
+    VoltAmperes.UUID = 'E863F110-079E-48FF-8F27-9C2605A29F52';
+
+    class Volts extends EnergyCharacteristic {
+        constructor() {
+            super('Volts', Volts.UUID, {
+                unit: 'V',
+                minStep: 0.1
+            });
+        }
+    }
+
+    Volts.UUID = 'E863F10A-079E-48FF-8F27-9C2605A29F52';
+
+    class Watts extends EnergyCharacteristic {
+        constructor() {
+            super('Consumption', Watts.UUID, {
+                unit: 'W',
+                minStep: 0.1
+            });
+        }
+    }
+
+    Watts.UUID = 'E863F10D-079E-48FF-8F27-9C2605A29F52';
+
+    return {Amperes, KilowattHours, KilowattVoltAmpereHour, VoltAmperes, Volts, Watts};
+};