homebridge-tuya-plus 3.1.2

package/lib/TuyaDiscovery.js

@@ -0,0 +1,165 @@
+const dgram = require('dgram');
+const crypto = require('crypto');
+const EventEmitter = require('events');
+
+const UDP_KEY = Buffer.from('6c1ec8e2bb9bb59ab50b0daf649b410a', 'hex');
+
+class TuyaDiscovery extends EventEmitter {
+    constructor() {
+        super();
+
+        this.discovered = new Map();
+        this.limitedIds = [];
+        this._servers = {};
+        this._running = false;
+    }
+
+    start(props) {
+        this.log = props.log;
+
+        const opts = props || {};
+
+        if (opts.clear) {
+            this.removeAllListeners();
+            this.discovered.clear();
+        }
+
+        this.limitedIds.splice(0);
+        if (Array.isArray(opts.ids)) [].push.apply(this.limitedIds, opts.ids);
+
+        this._running = true;
+        this._start(6666);
+        this._start(6667);
+
+        return this;
+    }
+
+    stop() {
+        this._running = false;
+        this._stop(6666);
+        this._stop(6667);
+
+        return this;
+    }
+
+    end() {
+        this.stop();
+        process.nextTick(() => {
+            this.removeAllListeners();
+            this.discovered.clear();
+            this.log.info('Discovery ended.');
+            this.emit('end');
+        });
+
+        return this;
+    }
+
+    _start(port) {
+        this._stop(port);
+
+        const server = this._servers[port] = dgram.createSocket({type: 'udp4', reuseAddr: true});
+        server.on('error', this._onDgramError.bind(this, port));
+        server.on('close', this._onDgramClose.bind(this, port));
+        server.on('message', this._onDgramMessage.bind(this, port));
+
+        server.bind(port, () => {
+            this.log.info(`Discovery - Discovery started on port ${port}.`);
+        });
+    }
+
+    _stop(port) {
+        if (this._servers[port]) {
+            this._servers[port].removeAllListeners();
+            this._servers[port].close();
+            this._servers[port] = null;
+        }
+    }
+
+    _onDgramError(port, err) {
+        this._stop(port);
+
+        if (err && err.code === 'EADDRINUSE') {
+            this.log.warn(`Discovery - Port ${port} is in use. Will retry in 15 seconds.`);
+
+            setTimeout(() => {
+                this._start(port);
+            }, 15000);
+        } else {
+            this.log.error(`Discovery - Port ${port} failed:\n${err.stack}`);
+        }
+    }
+
+    _onDgramClose(port) {
+        this._stop(port);
+
+        this.log.info(`Discovery - Port ${port} closed.${this._running ? ' Restarting...' : ''}`);
+        if (this._running)
+            setTimeout(() => {
+                this._start(port);
+            }, 1000);
+    }
+
+    _onDgramMessage(port, msg, info) {
+        const len = msg.length;
+      //  this.log.info(`Discovery - UDP from ${info.address}:${port} 0x${msg.readUInt32BE(0).toString(16).padStart(8, '0')}...0x${msg.readUInt32BE(len - 4).toString(16).padStart(8, '0')}`);
+        if (len < 16 ||
+            msg.readUInt32BE(0) !== 0x000055aa ||
+            msg.readUInt32BE(len - 4) !== 0x0000aa55
+        ) {
+            this.log.error(`Discovery - UDP from ${info.address}:${port}`, msg.toString('hex'));
+            return;
+        }
+
+        const size = msg.readUInt32BE(12);
+        if (len - size < 8) {
+            this.log.error(`Discovery - UDP from ${info.address}:${port} size ${len - size}`);
+            return;
+        }
+
+        //const result = {cmd: msg.readUInt32BE(8)};
+        const cleanMsg = msg.slice(len - size + 4, len - 8);
+
+        let decryptedMsg;
+        if (port === 6667) {
+            try {
+                const decipher = crypto.createDecipheriv('aes-128-ecb', UDP_KEY, '');
+                decryptedMsg = decipher.update(cleanMsg, 'utf8', 'utf8');
+                decryptedMsg += decipher.final('utf8');
+            } catch (ex) {}
+        }
+
+        if (!decryptedMsg) decryptedMsg = cleanMsg.toString('utf8');
+
+        try {
+            const result = JSON.parse(decryptedMsg);
+            if (result && result.gwId && result.ip) this._onDiscover(result);
+            else this.log.error(`Discovery - UDP from ${info.address}:${port} decrypted`, 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}: ${msg.toString('hex')}`);
+        }
+    }
+
+    _onDiscover(data) {
+        if (this.discovered.has(data.gwId)) return;
+
+        data.id = data.gwId;
+        delete data.gwId;
+
+        this.discovered.set(data.id, data.ip);
+
+        this.emit('discover', data);
+
+        if (this.limitedIds.length &&
+            this.limitedIds.includes(data.id) && // Just to avoid checking the rest unnecessarily
+            this.limitedIds.length <= this.discovered.size &&
+            this.limitedIds.every(id => this.discovered.has(id))
+        ) {
+            process.nextTick(() => {
+                this.end();
+            });
+        }
+    }
+}
+
+module.exports = new TuyaDiscovery();

package/lib/ValveAccessory.js

@@ -0,0 +1,150 @@
+const BaseAccessory = require('./BaseAccessory');
+
+class ValveAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.FAUCET;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.Valve, this.device.context.name);
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+        const service = this.accessory.getService(Service.Valve);
+        this._checkServiceName(service, this.device.context.name);
+        this.setDuration = this.device.context.defaultDuration || 600;
+        this.noTimer = this.device.context.noTimer;
+        this.lastActivationTime = null
+        this.timer = null;
+        
+        switch (this.device.context.valveType) {
+            case 'IRRIGATION':
+                service.getCharacteristic(Characteristic.ValveType).updateValue(1);
+                break;
+            case 'SHOWER_HEAD':
+                service.getCharacteristic(Characteristic.ValveType).updateValue(2);
+                break;
+            case 'WATER_FAUCET':
+                service.getCharacteristic(Characteristic.ValveType).updateValue(3);
+                break;
+            default:
+                service.getCharacteristic(Characteristic.ValveType).updateValue(0);
+                break;
+        }
+
+        this.dpPower = this._getCustomDP(this.device.context.dpPower) || '1';
+            
+        const characteristicActive = service.getCharacteristic(Characteristic.Active)
+            .updateValue(dps[this.dpPower])
+            .on('get', this.getState.bind(this, this.dpPower))
+            .on('set', this.setState.bind(this, this.dpPower));
+
+        const characteristicInUse = service.getCharacteristic(Characteristic.InUse)
+            .on('get', (next) => {
+                next(null, characteristicActive.value)
+            })
+
+
+        if (!this.noTimer) {
+            service.getCharacteristic(Characteristic.SetDuration)
+                .on('get', (next) => {
+                    next(null, this.setDuration)
+                })
+                .on('change', (data)=> {
+                    this.log.info("Water Valve Time Duration Set to: " + data.newValue/60 + " Minutes")
+                    this.setDuration = data.newValue
+
+                    if(service.getCharacteristic(Characteristic.InUse).value) {
+                        this.lastActivationTime = (new Date()).getTime();
+                        service.getCharacteristic(Characteristic.RemainingDuration)
+                            .updateValue(data.newValue);
+                            
+                        clearTimeout(this.timer); // clear any existing timer
+                        this.timer = setTimeout( ()=> {
+                            this.log.info("Water Valve Timer Expired. Shutting OFF Valve");
+                            service.getCharacteristic(Characteristic.Active).setValue(0); 
+                            service.getCharacteristic(Characteristic.InUse).updateValue(0); 
+                            this.lastActivationTime = null;
+                        }, (data.newValue *1000));	
+                    }
+                }); // end .on('change' ...
+
+            service.getCharacteristic(Characteristic.RemainingDuration)
+                .on('get', (next) => {
+                    var remainingTime = this.setDuration - Math.floor(((new Date()).getTime() - this.lastActivationTime) / 1000)
+                    if (!remainingTime || remainingTime < 0) 
+                        remainingTime = 0
+                    next(null, remainingTime)
+                })
+
+            service.getCharacteristic(Characteristic.InUse)
+                .on('change', (data) => {
+                        switch(data.newValue) {
+                            case 0:
+                                this.lastActivationTime = null
+                                service.getCharacteristic(Characteristic.RemainingDuration).updateValue(0);
+                                service.getCharacteristic(Characteristic.Active).updateValue(0);
+                                clearTimeout(this.timer); // clear the timer if it was used!
+                                this.log.info("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");
+                                clearTimeout(this.timer); // clear any existing timer
+                                this.timer = setTimeout(()=> {
+                                    this.log.info("Water Valve Timer Expired. Shutting OFF Valve");
+                                    // use 'setvalue' when the timer ends so it triggers the .on('set'...) event
+                                    service.getCharacteristic(Characteristic.Active).setValue(0);
+                                    service.getCharacteristic(Characteristic.InUse).updateValue(0); 
+                                    this.lastActivationTime = null;
+                                }, (this.setDuration *1000));
+                                break;
+                        }
+                    }); // end .on('change' ...
+                    
+            // If Homebridge crash when valve is on the timer reset
+            if (dps[this.dpPower]) {
+                this.lastActivationTime = (new Date()).getTime();                               
+                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");	
+                clearTimeout(this.timer); // clear any existing timer								
+                this.timer = setTimeout(()=> {
+                        this.log.info("Water Valve Timer Expired. Shutting OFF Valve");
+                        // use 'setvalue' when the timer ends so it triggers the .on('set'...) event
+                        service.getCharacteristic(Characteristic.Active).setValue(0); 
+                        this.lastActivationTime = null;
+                }, (this.setDuration *1000));
+            }
+
+        } // end if(!this.noTimer)
+
+
+        this.device.on('change', changes => {
+            if (changes.hasOwnProperty(this.dpPower) && characteristicActive.value !== changes[this.dpPower]) characteristicActive.updateValue(changes[this.dpPower]);
+            if (changes.hasOwnProperty(this.dpPower) && characteristicInUse.value !== changes[this.dpPower]) characteristicInUse.setValue(changes[this.dpPower]);
+            
+            if (!this.noTimer) {
+                if (changes.hasOwnProperty(this.dpPower) && !changes[this.dpPower]){
+                    this.lastActivationTime = null;
+                    service.getCharacteristic(Characteristic.RemainingDuration).updateValue(0);
+                    clearTimeout(this.timer);
+                }
+            }
+        });
+    }
+}
+
+module.exports = ValveAccessory;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "homebridge-tuya-plus",
+  "version": "3.1.2",
+  "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN. Includes new features, fixes, and updated device support.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "eslint index.js lib/**.js bin/**.js"
+  },
+  "bin": {
+    "tuya-lan": "./bin/cli.js",
+    "tuya-lan-find": "./bin/cli-find.js",
+    "tuya-lan-decode": "./bin/cli-decode.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adrianjagielak/homebridge-tuya-plus.git"
+  },
+  "author": "Rayan Khan",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/adrianjagielak/homebridge-tuya-plus/issues"
+  },
+  "homepage": "https://github.com/adrianjagielak/homebridge-tuya-plus#readme",
+  "dependencies": {
+    "async": "^3.2.2",
+    "commander": "^3.0.1",
+    "fs-extra": "^8.1.0",
+    "http-mitm-proxy": "^1.1.0",
+    "json5": "^2.2.0",
+    "qrcode": "^1.4.1",
+    "yaml": "^1.6.0"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "homebridge-tuya",
+    "tuya"
+  ],
+  "engines": {
+    "homebridge": ">=0.4.0",
+    "node": ">=8.6.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.30.1",
+    "eslint": "^9.30.1",
+    "globals": "^16.3.0"
+  }
+}