homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/MotionSensorAccessory.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const MotionDetected_1 = require("./characteristic/MotionDetected");
+const SCHEMA_CODE = {
+    PIR: ['pir'],
+};
+class MotionSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.PIR];
+    }
+    configureServices() {
+        (0, MotionDetected_1.configureMotionDetected)(this, undefined, this.getSchema(...SCHEMA_CODE.PIR));
+    }
+}
+exports.default = MotionSensorAccessory;
+//# sourceMappingURL=MotionSensorAccessory.js.map

package/dist/shared/accessories/OutletAccessory.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OutletInUse_1 = require("./characteristic/OutletInUse");
+const SwitchAccessory_1 = __importDefault(require("./SwitchAccessory"));
+const SCHEMA_CODE = {
+    CURRENT: ['cur_current'],
+};
+class OutletAccessory extends SwitchAccessory_1.default {
+    mainService() {
+        return this.Service.Outlet;
+    }
+    configureSwitch(schema, name) {
+        super.configureSwitch(schema, name);
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.mainService(), name, schema.code);
+        (0, OutletInUse_1.configureOutletInUse)(this, service, this.getSchema(...SCHEMA_CODE.CURRENT));
+    }
+}
+exports.default = OutletAccessory;
+//# sourceMappingURL=OutletAccessory.js.map

package/dist/shared/accessories/PetFeederAccessory.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    LIGHT: ['light'],
+    QUICK_FEED: ['quick_feed'],
+    SLOW_FEED: ['slow_feed'],
+    MANUAL_FEED: ['manual_feed'],
+    MEAL_PLAN: ['meal_plan'],
+    BATTERY_PERCENTAGE: ['battery_percentage'],
+    FEED_REPORT: ['feed_report'],
+    FEED_STATE: ['feed_state'],
+};
+class PetFeederAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE];
+    }
+    configureServices() {
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureLight();
+        this.configureQuickFeed();
+        this.configureSlowFeed();
+        this.configureManualFeed();
+        this.configureMealPlan();
+        this.configureBatteryPercentage();
+        this.configureFeedReport();
+        this.configureFeedState();
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.Switch)
+            || this.accessory.addService(this.Service.Switch);
+    }
+    configureLight() {
+        const schema = this.getSchema(...SCHEMA_CODE.LIGHT);
+        if (!schema) {
+            this.log.warn('Light is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            await this.sendCommands([{ code: schema.code, value: value }]);
+        });
+    }
+    configureQuickFeed() {
+        const schema = this.getSchema(...SCHEMA_CODE.QUICK_FEED);
+        if (!schema) {
+            this.log.warn('Quick feed is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            if (value) {
+                await this.sendCommands([{ code: schema.code, value: true }]);
+            }
+        });
+    }
+    configureSlowFeed() {
+        const schema = this.getSchema(...SCHEMA_CODE.SLOW_FEED);
+        if (!schema) {
+            this.log.warn('Slow feed is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            if (value) {
+                await this.sendCommands([{ code: schema.code, value: true }]);
+            }
+        });
+    }
+    configureManualFeed() {
+        const schema = this.getSchema(...SCHEMA_CODE.MANUAL_FEED);
+        if (!schema) {
+            this.log.warn('Manual feed is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            if (value) {
+                await this.sendCommands([{ code: schema.code, value: 1 }]);
+            }
+        });
+    }
+    configureMealPlan() {
+        const schema = this.getSchema(...SCHEMA_CODE.MEAL_PLAN);
+        if (!schema) {
+            this.log.warn('Meal plan is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.On)
+            .onSet(async (value) => {
+            if (value) {
+                await this.sendCommands([{ code: schema.code, value: value }]);
+            }
+        });
+    }
+    configureBatteryPercentage() {
+        const schema = this.getSchema(...SCHEMA_CODE.BATTERY_PERCENTAGE);
+        if (!schema) {
+            this.log.warn('Battery percentage is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.BatteryLevel)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value;
+        });
+    }
+    configureFeedReport() {
+        const schema = this.getSchema(...SCHEMA_CODE.FEED_REPORT);
+        if (!schema) {
+            this.log.warn('Feed report is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.StatusActive)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value;
+        });
+    }
+    configureFeedState() {
+        const schema = this.getSchema(...SCHEMA_CODE.FEED_STATE);
+        if (!schema) {
+            this.log.warn('Feed state is not supported.');
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.StatusActive)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value === 'feeding';
+        });
+    }
+}
+exports.default = PetFeederAccessory;
+//# sourceMappingURL=PetFeederAccessory.js.map

package/dist/shared/accessories/SceneAccessory.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+class SceneAccessory extends BaseAccessory_1.default {
+    constructor(platform, accessory) {
+        super(platform, accessory);
+        const service = this.accessory.getService(this.Service.Switch)
+            || this.accessory.addService(this.Service.Switch);
+        service.getCharacteristic(this.Characteristic.On)
+            .onGet(() => false)
+            .onSet(async (value) => {
+            if (value === false) {
+                return;
+            }
+            const deviceManager = this.platform.deviceManager;
+            const res = await deviceManager.executeScene(this.device.owner_id, this.device.id);
+            setTimeout(() => {
+                service.getCharacteristic(this.Characteristic.On).updateValue(false);
+            }, 150);
+            if (res.success === false) {
+                this.log.warn('ExecuteScene failed. homeId = %s, code = %s, msg = %s', this.device.owner_id, res.code, res.msg);
+                const { HapStatusError, HAPStatus } = this.platform.api.hap;
+                throw new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+        });
+    }
+}
+exports.default = SceneAccessory;
+//# sourceMappingURL=SceneAccessory.js.map

package/dist/shared/accessories/SceneSwitchAccessory.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaDevice_1 = require("../../cloud/device/TuyaDevice");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Name_1 = require("./characteristic/Name");
+class SceneSwitchAccessory extends BaseAccessory_1.default {
+    configureServices() {
+        const schema = this.device.schema.filter((schema) => schema.code.startsWith('switch') && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Boolean);
+        for (const _schema of schema) {
+            const name = (schema.length === 1) ? this.device.name : _schema.code;
+            this.configureSwitch(_schema, name);
+        }
+    }
+    configureSwitch(schema, name) {
+        if (!schema) {
+            return;
+        }
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.Service.Switch, name, schema.code);
+        (0, Name_1.configureName)(this, service, name);
+        const suffix = schema.code.replace('switch', '');
+        const modeSchema = this.getSchema('mode' + suffix);
+        service.getCharacteristic(this.Characteristic.On)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value;
+        })
+            .onSet(async (value) => {
+            if (modeSchema) {
+                const mode = this.getStatus(modeSchema.code);
+                if (mode.value.startsWith('scene')) {
+                    await this.sendCommands([{ code: schema.code, value: false }]);
+                    return;
+                }
+            }
+            await this.sendCommands([{ code: schema.code, value: value }]);
+        });
+    }
+}
+exports.default = SceneSwitchAccessory;
+//# sourceMappingURL=SceneSwitchAccessory.js.map

package/dist/shared/accessories/SecuritySystemAccessory.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SecuritySystemState_1 = require("./characteristic/SecuritySystemState");
+const Name_1 = require("./characteristic/Name");
+const SCHEMA_CODE = {
+    MASTER_MODE: ['master_mode'],
+    SOS_STATE: ['sos_state'],
+};
+class SecuritySystemAccessory extends BaseAccessory_1.default {
+    constructor() {
+        super(...arguments);
+        this.isNightArm = false;
+    }
+    requiredSchema() {
+        return [SCHEMA_CODE.MASTER_MODE, SCHEMA_CODE.SOS_STATE];
+    }
+    configureServices() {
+        const service = this.accessory.getService(this.Service.SecuritySystem)
+            || this.accessory.addService(this.Service.SecuritySystem);
+        (0, Name_1.configureName)(this, service, this.device.name);
+        (0, SecuritySystemState_1.configureSecuritySystemCurrentState)(this, service, this.getSchema(...SCHEMA_CODE.MASTER_MODE), this.getSchema(...SCHEMA_CODE.SOS_STATE));
+        (0, SecuritySystemState_1.configureSecuritySystemTargetState)(this, service, this.getSchema(...SCHEMA_CODE.MASTER_MODE), this.getSchema(...SCHEMA_CODE.SOS_STATE));
+    }
+}
+exports.default = SecuritySystemAccessory;
+//# sourceMappingURL=SecuritySystemAccessory.js.map

package/dist/shared/accessories/SmokeSensorAccessory.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    SENSOR_STATUS: ['smoke_sensor_status', 'smoke_sensor_state'],
+};
+class SmokeSensor extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.SENSOR_STATUS];
+    }
+    configureServices() {
+        const schema = this.getSchema(...SCHEMA_CODE.SENSOR_STATUS);
+        if (!schema) {
+            return;
+        }
+        const { SMOKE_NOT_DETECTED, SMOKE_DETECTED } = this.Characteristic.SmokeDetected;
+        const service = this.accessory.getService(this.Service.SmokeSensor)
+            || this.accessory.addService(this.Service.SmokeSensor);
+        service.getCharacteristic(this.Characteristic.SmokeDetected)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            if ((status.value === 'alarm' || status.value === '1')) {
+                return SMOKE_DETECTED;
+            }
+            else {
+                return SMOKE_NOT_DETECTED;
+            }
+        });
+    }
+}
+exports.default = SmokeSensor;
+//# sourceMappingURL=SmokeSensorAccessory.js.map

package/dist/shared/accessories/SwitchAccessory.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaDevice_1 = require("../../cloud/device/TuyaDevice");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Name_1 = require("./characteristic/Name");
+const On_1 = require("./characteristic/On");
+const EnergyUsage_1 = require("./characteristic/EnergyUsage");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const CurrentRelativeHumidity_1 = require("./characteristic/CurrentRelativeHumidity");
+const SCHEMA_CODE = {
+    ON: ['switch', 'switch_1'], // switch_2, switch_3, switch_4, ..., switch_usb1, switch_usb2, switch_usb3, ..., switch_backlight
+    CURRENT: ['cur_current'],
+    POWER: ['cur_power'],
+    VOLTAGE: ['cur_voltage'],
+    TOTAL_POWER: ['add_ele'],
+    CURRENT_TEMP: ['va_temperature', 'temp_current'],
+    CURRENT_HUMIDITY: ['va_humidity', 'humidity_value'],
+    INCHING: ['switch_inching'],
+};
+class SwitchAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ON];
+    }
+    configureServices() {
+        const oldService = this.accessory.getService(this.mainService());
+        if (oldService && oldService?.subtype === undefined) {
+            this.platform.log.warn('Remove old service:', oldService.UUID);
+            this.accessory.removeService(oldService);
+        }
+        const schemata = this.device.schema.filter((schema) => schema.code.startsWith('switch') && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Boolean);
+        this.log.info(`[SwitchAccessory] Found ${schemata.length} switch schemas: ${schemata.map(s => s.code).join(', ')}`);
+        // Track which switch services should exist
+        const validSubtypes = new Set(schemata.map(s => s.code));
+        // Remove any old switch services that are no longer in the schema.
+        // Match both Switch and Outlet UUIDs since OutletAccessory uses Service.Outlet.
+        const switchOrOutletUUIDs = new Set([this.Service.Switch.UUID, this.Service.Outlet.UUID]);
+        const allSwitchServices = this.accessory.services.filter(s => switchOrOutletUUIDs.has(s.UUID) && s.subtype);
+        // Check early if we'll be keeping services due to auto-detect or config unchanged
+        const configChanged = this.device?.configChanged ?? true;
+        const isAutoDetecting = this.device?.isAutoDetecting ?? false;
+        const shouldRemoveExtras = configChanged && !isAutoDetecting;
+        if (allSwitchServices.length > schemata.length) {
+            if (shouldRemoveExtras) {
+                this.log.warn(`[SwitchAccessory] Found ${allSwitchServices.length} cached switch services but only ${schemata.length} in schema. Removing extras...`);
+            }
+            else {
+                this.log.info(`[SwitchAccessory] Found ${allSwitchServices.length} cached switch services but only ${schemata.length} in schema. ${isAutoDetecting ? 'Auto-detect in progress' : 'Config unchanged'} – keeping for now...`);
+            }
+        }
+        const keptCachedServices = new Map();
+        for (const oldService of allSwitchServices) {
+            if (!validSubtypes.has(oldService.subtype)) {
+                if (shouldRemoveExtras) {
+                    // Config changed and not in auto-detect, so enforce the new schema
+                    this.log.warn(`Removing old switch service: ${oldService.displayName} (subtype: ${oldService.subtype})`);
+                    this.accessory.removeService(oldService);
+                }
+                else {
+                    // Either config didn't change, or we're in auto-detect mode – keep cached services for now
+                    // Auto-detection will add new ones when complete
+                    this.log.debug(`${isAutoDetecting ? 'Auto-detect in progress' : 'Config unchanged'} for this device, keeping cached switch service: ` +
+                        `${oldService.displayName} (subtype: ${oldService.subtype})`);
+                    // Track the kept service to configure it
+                    keptCachedServices.set(oldService.subtype, oldService);
+                }
+            }
+        }
+        // Now configure the switches in the schema
+        schemata.forEach((schema, index) => {
+            // Use human-readable names instead of raw code names (which contain underscores)
+            let name;
+            if (schemata.length === 1) {
+                name = this.device.name;
+            }
+            else {
+                // For multiple switches, append "#1", "#2", etc. or use "Switch 1", "Switch 2"
+                const switchMatch = schema.code.match(/^switch_(\d+)$/);
+                const switchNum = switchMatch ? switchMatch[1] : (index + 1).toString();
+                name = `${this.device.name} ${switchNum}`;
+            }
+            this.configureSwitch(schema, name);
+        });
+        // Also configure cached services that aren't in schema (but weren't removed because config unchanged)
+        for (const [subtype, service] of keptCachedServices.entries()) {
+            const switchMatch = subtype.match(/^switch_(\d+)$/);
+            const switchNum = switchMatch ? switchMatch[1] : subtype;
+            const name = schemata.length === 1 ? this.device.name : `${this.device.name} ${switchNum}`;
+            // Extract schema info from the cached service's current state
+            // In this case we reuse the service without re-adding it
+            (0, Name_1.configureName)(this, service, name);
+        }
+        // Other
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, CurrentRelativeHumidity_1.configureCurrentRelativeHumidity)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY));
+        this.configureInching();
+    }
+    async onDeviceInfoUpdate(info) {
+        // Re-run service configuration so newly auto-detected switches get their handlers registered.
+        this.configureServices();
+        this.configureStatusActive();
+        await this.updateAllValues();
+    }
+    mainService() {
+        return this.Service.Switch;
+    }
+    configureSwitch(schema, name) {
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.mainService(), name, schema.code);
+        (0, Name_1.configureName)(this, service, name);
+        (0, On_1.configureOn)(this, service, schema);
+        if (schema.code === this.getSchema(...SCHEMA_CODE.ON)?.code) {
+            (0, EnergyUsage_1.configureEnergyUsage)(this.platform.api, this, service, this.getSchema(...SCHEMA_CODE.CURRENT), this.getSchema(...SCHEMA_CODE.POWER), this.getSchema(...SCHEMA_CODE.VOLTAGE), this.getSchema(...SCHEMA_CODE.TOTAL_POWER));
+        }
+    }
+    configureInching() {
+        const schema = this.getSchema(...SCHEMA_CODE.INCHING);
+        if (!schema || schema.type !== TuyaDevice_1.TuyaDeviceSchemaType.String) {
+            return;
+        }
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.Service.Switch, schema.code, schema.code);
+        (0, Name_1.configureName)(this, service, schema.code);
+        service.getCharacteristic(this.Characteristic.On)
+            .onGet(() => {
+            this.checkOnlineStatus();
+            const status = this.getStatus(schema.code);
+            const buffer = Buffer.from(status.value, 'base64');
+            return (buffer.length === 3) && (buffer[0] === 1);
+        })
+            .onSet(async (value) => {
+            const status = this.getStatus(schema.code);
+            let buffer = Buffer.from(status.value, 'base64');
+            if (buffer.length !== 3) {
+                buffer = Buffer.alloc(3);
+            }
+            buffer[0] = value ? 1 : 0;
+            await this.sendCommands([{
+                    code: schema.code,
+                    value: buffer.toString('base64'),
+                }], true);
+        });
+    }
+}
+exports.default = SwitchAccessory;
+//# sourceMappingURL=SwitchAccessory.js.map

package/dist/shared/accessories/TemperatureHumiditySensorAccessory.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const CurrentRelativeHumidity_1 = require("./characteristic/CurrentRelativeHumidity");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const SCHEMA_CODE = {
+    SENSOR_STATUS: ['va_temperature', 'va_humidity', 'humidity_value'],
+    CURRENT_TEMP: ['va_temperature', 'temp_value'],
+    CURRENT_HUMIDITY: ['va_humidity', 'humidity_value'],
+};
+class TemperatureHumiditySensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.SENSOR_STATUS];
+    }
+    configureServices() {
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, CurrentRelativeHumidity_1.configureCurrentRelativeHumidity)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY));
+    }
+}
+exports.default = TemperatureHumiditySensorAccessory;
+//# sourceMappingURL=TemperatureHumiditySensorAccessory.js.map