homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/BaseAccessory.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const Logger_1 = require("../util/Logger");
+const util_2 = require("../util/util");
+const MANUFACTURER = 'Tuya Inc.';
+const SCHEMA_CODE = {
+    BATTERY_STATE: ['battery_state'],
+    BATTERY_PERCENT: ['battery_percentage', 'residual_electricity', 'wireless_electricity', 'va_battery', 'battery'],
+    BATTERY_CHARGING: ['charge_state'],
+};
+/**
+ * Homebridge Accessory Categories Documentation:
+ *   https://developers.homebridge.io/#/categories
+ * Tuya Standard Instruction Set Documentation:
+ *   https://developer.tuya.com/en/docs/iot/standarddescription?id=K9i5ql6waswzq
+ */
+class BaseAccessory {
+    get deviceManager() {
+        // Return whichever manager owns this device (local takes priority in hybrid mode)
+        const deviceID = this.accessory.context.deviceID;
+        if (deviceID && this.platform.localDeviceManager?.getDevice(deviceID)) {
+            return this.platform.localDeviceManager;
+        }
+        return this.platform.deviceManager;
+    }
+    get deviceSource() {
+        // Determine which source this device comes from for override lookup
+        const deviceID = this.accessory.context.deviceID;
+        if (deviceID && this.platform.localDeviceManager?.getDevice(deviceID)) {
+            return 'local';
+        }
+        if (deviceID && this.platform.deviceManager?.getDevice(deviceID)) {
+            return 'cloud';
+        }
+        return undefined;
+    }
+    get device() {
+        // Try local device manager first (for local-only or hybrid modes)
+        const localDevice = this.platform.localDeviceManager?.getDevice(this.accessory.context.deviceID);
+        if (localDevice) {
+            return localDevice;
+        }
+        // Fall back to cloud device manager
+        return this.platform.deviceManager?.getDevice(this.accessory.context.deviceID);
+    }
+    get log() {
+        if (!this.cachedLog) {
+            const deviceName = this.device?.name ?? this.device?.id ?? this.accessory.context.deviceID ?? 'Unknown Device';
+            this.cachedLog = new Logger_1.PrefixLogger(this.platform.log, deviceName, this.platform.options.debug && ((this.platform.options.debugLevel ?? '').length > 0
+                ? this.platform.options.debugLevel?.includes(this.device?.id ?? '')
+                : true));
+        }
+        return this.cachedLog;
+    }
+    constructor(platform, accessory) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.Service = this.platform.api.hap.Service;
+        this.Characteristic = this.platform.api.hap.Characteristic;
+        this.initialized = false;
+        this.sendQueue = new Map();
+        this.debounceSendCommands = (0, util_2.debounce)(async () => {
+            const commands = [...this.sendQueue.values()];
+            if (commands.length === 0) {
+                return;
+            }
+            if (!this.device || !this.deviceManager) {
+                this.log.warn('Device manager or device not available, cannot send commands.');
+                this.sendQueue.clear();
+                return;
+            }
+            try {
+                await this.deviceManager.sendCommands(this.device.id, commands);
+            }
+            catch (error) {
+                if (this.platform.deviceManager && this.deviceManager === this.platform.localDeviceManager) {
+                    const deviceName = this.device?.name || this.device?.id || 'Unknown Device';
+                    this.log.warn(`[${deviceName}] Local debounced send failed, falling back to cloud: ${error instanceof Error ? error.message : error}`);
+                    try {
+                        await this.platform.deviceManager.sendCommands(this.device.id, commands);
+                    }
+                    catch (cloudError) {
+                        this.log.warn(`[${deviceName}] Cloud fallback failed: ${cloudError instanceof Error ? cloudError.message : cloudError}`);
+                    }
+                }
+                else {
+                    this.log.warn(`Debounced send failed: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+            finally {
+                this.sendQueue.clear();
+            }
+        }, 100);
+        this.addAccessoryInfoService();
+        this.addBatteryService();
+    }
+    addAccessoryInfoService() {
+        const service = this.accessory.getService(this.Service.AccessoryInformation)
+            || this.accessory.addService(this.Service.AccessoryInformation);
+        if (!this.device) {
+            // Use fallback values if device is not available yet
+            const safeName = (0, util_1.sanitizeName)(this.accessory.displayName) ?? 'Tuya Device';
+            service
+                .setCharacteristic(this.Characteristic.Manufacturer, MANUFACTURER)
+                .setCharacteristic(this.Characteristic.Name, safeName)
+                .setCharacteristic(this.Characteristic.ConfiguredName, safeName);
+            return;
+        }
+        const safeName = (0, util_1.sanitizeName)(this.device.name) ?? (this.device.id || 'Tuya Device');
+        service
+            .setCharacteristic(this.Characteristic.Manufacturer, MANUFACTURER)
+            .setCharacteristic(this.Characteristic.Model, this.device.model || this.device.product_name || this.device.product_id)
+            .setCharacteristic(this.Characteristic.Name, safeName)
+            .setCharacteristic(this.Characteristic.ConfiguredName, safeName);
+        const serialNumber = typeof this.device.uuid === 'string' ? this.device.uuid.trim() : '';
+        if (serialNumber.length > 1) {
+            service.setCharacteristic(this.Characteristic.SerialNumber, serialNumber);
+        }
+        else {
+            this.log.warn(`Skipping invalid SerialNumber for accessory ${safeName}`);
+        }
+    }
+    addBatteryService() {
+        const percentSchema = this.getSchema(...SCHEMA_CODE.BATTERY_PERCENT);
+        if (!percentSchema) {
+            return;
+        }
+        const { BATTERY_LEVEL_NORMAL, BATTERY_LEVEL_LOW } = this.Characteristic.StatusLowBattery;
+        const service = this.accessory.getService(this.Service.Battery)
+            || this.accessory.addService(this.Service.Battery);
+        const stateSchema = this.getSchema(...SCHEMA_CODE.BATTERY_STATE);
+        if (stateSchema || percentSchema) {
+            service.getCharacteristic(this.Characteristic.StatusLowBattery)
+                .onGet(() => {
+                if (stateSchema) {
+                    const status = this.getStatus(stateSchema.code);
+                    if (!status) {
+                        return BATTERY_LEVEL_NORMAL;
+                    }
+                    return (status.value === 'low') ? BATTERY_LEVEL_LOW : BATTERY_LEVEL_NORMAL;
+                }
+                // fallback
+                const status = this.getStatus(percentSchema.code);
+                if (!status) {
+                    return BATTERY_LEVEL_NORMAL;
+                }
+                return (status.value <= 20) ? BATTERY_LEVEL_LOW : BATTERY_LEVEL_NORMAL;
+            });
+        }
+        const property = percentSchema.property;
+        const multiple = Math.pow(10, property ? property.scale : 0);
+        service.getCharacteristic(this.Characteristic.BatteryLevel)
+            .onGet(() => {
+            const status = this.getStatus(percentSchema.code);
+            if (!status) {
+                return 0;
+            }
+            return (0, util_1.limit)(status.value / multiple, 0, 100);
+        });
+        const chargingSchema = this.getSchema(...SCHEMA_CODE.BATTERY_CHARGING);
+        if (chargingSchema) {
+            const { NOT_CHARGING, CHARGING } = this.Characteristic.ChargingState;
+            service.getCharacteristic(this.Characteristic.ChargingState)
+                .onGet(() => {
+                const status = this.getStatus(chargingSchema.code);
+                if (!status) {
+                    return NOT_CHARGING;
+                }
+                return status.value ? CHARGING : NOT_CHARGING;
+            });
+        }
+    }
+    configureStatusActive() {
+        for (const service of this.accessory.services) {
+            if (!service.testCharacteristic(this.Characteristic.StatusActive)) { // silence warning
+                service.addOptionalCharacteristic(this.Characteristic.StatusActive);
+            }
+            service.getCharacteristic(this.Characteristic.StatusActive)
+                .onGet(() => this.device?.online ?? true);
+        }
+    }
+    async updateAllValues() {
+        for (const service of this.accessory.services) {
+            for (const characteristic of service.characteristics) {
+                if (characteristic.UUID === this.Characteristic.ProgrammableSwitchEvent.UUID) {
+                    continue;
+                }
+                let newValue = characteristic.value;
+                const getHandler = characteristic['getHandler'];
+                if (getHandler) {
+                    try {
+                        newValue = await getHandler();
+                    }
+                    catch (error) {
+                        // TODO: why `characteristic.updateValue(HapStatusError)` not working?
+                        // newValue = error as Error;
+                        continue;
+                    }
+                }
+                if (characteristic.value !== newValue && !(newValue instanceof Error)) {
+                    this.log.debug('[%s/%s/%s] Update value: %o => %o', service.constructor.name, service.subtype, characteristic.constructor.name, characteristic.value, newValue);
+                }
+                characteristic.updateValue(newValue);
+            }
+        }
+    }
+    checkOnlineStatus() {
+        if (this.device?.online === false) {
+            const { HapStatusError, HAPStatus } = this.platform.api.hap;
+            throw new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        }
+    }
+    getSchema(...codes) {
+        if (!this.device) {
+            return undefined;
+        }
+        for (const code of codes) {
+            const schema = this.device.schema.find(schema => {
+                // ignore case
+                return schema.code.toLowerCase() === code.toLowerCase();
+            });
+            if (schema) {
+                return schema;
+            }
+        }
+        return undefined;
+    }
+    getStatus(code) {
+        if (!this.device) {
+            return undefined;
+        }
+        return this.device.status.find(status => status.code === code);
+    }
+    async sendCommands(commands, debounce = false) {
+        if (commands.length === 0) {
+            return;
+        }
+        if (!this.device || !this.deviceManager) {
+            this.log.warn('Device manager or device not available, cannot send commands.');
+            return;
+        }
+        commands = commands.filter((status) => status.code && status.value !== undefined);
+        if (this.device.online === false) {
+            this.log.warn('Device is offline, skip send command.');
+            this.updateAllValues();
+            const { HapStatusError, HAPStatus } = this.platform.api.hap;
+            throw new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            return;
+        }
+        // Update cache immediately
+        for (const newStatus of commands) {
+            const oldStatus = this.device.status.find(_status => _status.code === newStatus.code);
+            if (oldStatus) {
+                oldStatus.value = newStatus.value;
+            }
+        }
+        if (debounce === false) {
+            try {
+                return await this.deviceManager.sendCommands(this.device.id, commands);
+            }
+            catch (error) {
+                if (this.platform.deviceManager && this.deviceManager === this.platform.localDeviceManager) {
+                    const deviceName = this.device?.name || this.device?.id || 'Unknown Device';
+                    this.log.warn(`[${deviceName}] Local send failed, falling back to cloud: ${error instanceof Error ? error.message : error}`);
+                    return await this.platform.deviceManager.sendCommands(this.device.id, commands);
+                }
+                throw error;
+            }
+        }
+        for (const newStatus of commands) {
+            // Update send queue
+            this.sendQueue.set(newStatus.code, newStatus);
+        }
+        this.debounceSendCommands();
+    }
+    checkRequirements() {
+        if (!this.device) {
+            return false;
+        }
+        let result = true;
+        for (const codes of this.requiredSchema()) {
+            const schema = this.getSchema(...codes);
+            if (schema) {
+                continue;
+            }
+            this.log.warn('Product Category: %s', this.device.category);
+            this.log.warn('Missing one of the required schema: %s', codes);
+            this.log.warn('Please switch device control mode to "DP Instruction", and set `deviceOverrides` manually.');
+            this.log.warn('Detail information: https://github.com/homebridge-plugins/homebridge-tuya#faq');
+            result = false;
+        }
+        if (!result) {
+            this.log.warn('Existing schema: %o', this.device.schema);
+        }
+        return result;
+    }
+    requiredSchema() {
+        return [];
+    }
+    configureServices() {
+        //
+    }
+    async onDeviceInfoUpdate(info) {
+        this.updateAllValues();
+    }
+    async onDeviceStatusUpdate(status) {
+        this.updateAllValues();
+    }
+}
+// Overriding getSchema, getStatus, sendCommands
+class OverridedBaseAccessory extends BaseAccessory {
+    constructor() {
+        super(...arguments);
+        this.eval = (script, device, value) => eval(script);
+    }
+    getOverridedSchema(code) {
+        if (!this.device) {
+            return undefined;
+        }
+        const schemaConfig = this.platform.getDeviceSchemaConfig(this.device, code, this.deviceSource);
+        if (!schemaConfig) {
+            return undefined;
+        }
+        const oldSchema = this.device.schema.find(schema => {
+            // ignore case
+            return schema.code.toLowerCase() === schemaConfig.code.toLowerCase();
+        });
+        if (!oldSchema) {
+            return undefined;
+        }
+        const schema = {
+            code,
+            mode: oldSchema.mode,
+            type: schemaConfig.type || oldSchema.type,
+            property: schemaConfig.property || oldSchema.property,
+            _hidden: schemaConfig.hidden,
+        };
+        if (!(0, util_2.deepEqual)(oldSchema, schema)) {
+            this.log.debug('Override schema %o => %o', oldSchema, schema);
+        }
+        return schema;
+    }
+    getSchema(...codes) {
+        for (const code of codes) {
+            const schema = this.getOverridedSchema(code) || super.getSchema(code);
+            if (!schema) {
+                continue;
+            }
+            if (schema['_hidden']) {
+                return undefined;
+            }
+            return schema;
+        }
+        return undefined;
+    }
+    getOverridedStatus(code) {
+        if (!this.device) {
+            return undefined;
+        }
+        const schemaConfig = this.platform.getDeviceSchemaConfig(this.device, code, this.deviceSource);
+        if (!schemaConfig) {
+            return undefined;
+        }
+        const oldStatus = super.getStatus(schemaConfig.code);
+        if (!oldStatus) {
+            return undefined;
+        }
+        const status = { code: schemaConfig.newCode || schemaConfig.code, value: oldStatus.value };
+        if (schemaConfig.onGet) {
+            status.value = this.eval(schemaConfig.onGet, this.device, oldStatus.value);
+        }
+        if (!(0, util_2.deepEqual)(oldStatus, status)) {
+            this.log.debug('Override status %o => %o', oldStatus, status);
+        }
+        return status;
+    }
+    getStatus(code) {
+        return this.getOverridedStatus(code) || super.getStatus(code);
+    }
+    async sendCommands(commands, debounce) {
+        if (!this.device) {
+            await super.sendCommands(commands, debounce);
+            return;
+        }
+        // convert to original commands
+        for (const command of commands) {
+            const schemaConfig = this.platform.getDeviceSchemaConfig(this.device, command.code, this.deviceSource);
+            if (!schemaConfig) {
+                continue;
+            }
+            const oldCommand = { code: schemaConfig.code, value: command.value };
+            if (schemaConfig.onSet) {
+                oldCommand.value = this.eval(schemaConfig.onSet, this.device, command.value);
+            }
+            if (!(0, util_2.deepEqual)(oldCommand, command)) {
+                this.log.debug('Override command %o => %o', command, oldCommand);
+                command.code = oldCommand.code;
+                command.value = oldCommand.value;
+            }
+        }
+        await super.sendCommands(commands, debounce);
+    }
+}
+exports.default = OverridedBaseAccessory;
+//# sourceMappingURL=BaseAccessory.js.map

package/dist/shared/accessories/BlindsAccessory.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    CONTROL: ['control', 'mach_operate'],
+    CURRENT_POSITION: ['percent_state'],
+    TARGET_POSITION: ['percent_control', 'position'],
+    POSITION: ['position'],
+};
+/**
+ * BlindsAccessory – handles roller motor shades and blinds.
+ * Supports position control with tracking and state management.
+ *
+ * Categories: 'mg' (blinds), 'mgmt' (motorized blinds)
+ */
+class BlindsAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CONTROL];
+    }
+    configureServices() {
+        this.configureCurrentPosition();
+        this.configurePositionState();
+        this.configureTargetPosition();
+    }
+    /**
+     * Configure CurrentPosition characteristic.
+     * Read-only value showing actual blind position (0-100%).
+     */
+    configureCurrentPosition() {
+        const currentSchema = this.getSchema(...SCHEMA_CODE.CURRENT_POSITION);
+        const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_POSITION) ||
+            this.getSchema(...SCHEMA_CODE.POSITION);
+        const service = this.accessory.getService(this.Service.WindowCovering) ||
+            this.accessory.addService(this.Service.WindowCovering);
+        service.getCharacteristic(this.Characteristic.CurrentPosition)
+            .onGet(() => {
+            // Prefer current position schema if available
+            if (currentSchema) {
+                const status = this.getStatus(currentSchema.code);
+                return (0, util_1.limit)(status.value, 0, 100);
+            }
+            // Fall back to target position schema
+            if (targetSchema) {
+                const status = this.getStatus(targetSchema.code);
+                return (0, util_1.limit)(status.value, 0, 100);
+            }
+            // Fall back to control command status (open/close/stop)
+            const controlSchema = this.getSchema(...SCHEMA_CODE.CONTROL);
+            if (controlSchema) {
+                const status = this.getStatus(controlSchema.code);
+                return this.controlValueToPosition(status.value);
+            }
+            return 50; // Default to middle position
+        });
+    }
+    /**
+     * Configure PositionState characteristic.
+     * Indicates if blinds are going up (INCREASING), down (DECREASING), or stopped.
+     */
+    configurePositionState() {
+        const currentSchema = this.getSchema(...SCHEMA_CODE.CURRENT_POSITION);
+        const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_POSITION) ||
+            this.getSchema(...SCHEMA_CODE.POSITION);
+        const { DECREASING, INCREASING, STOPPED } = this.Characteristic.PositionState;
+        const service = this.accessory.getService(this.Service.WindowCovering) ||
+            this.accessory.addService(this.Service.WindowCovering);
+        service.getCharacteristic(this.Characteristic.PositionState)
+            .onGet(() => {
+            // If we don't have both current and target, assume stopped
+            if (!currentSchema || !targetSchema) {
+                return STOPPED;
+            }
+            const currentStatus = this.getStatus(currentSchema.code);
+            const targetStatus = this.getStatus(targetSchema.code);
+            const currentPos = currentStatus.value;
+            const targetPos = targetStatus.value;
+            if (targetPos > currentPos) {
+                return INCREASING; // Moving up/open
+            }
+            else if (targetPos < currentPos) {
+                return DECREASING; // Moving down/close
+            }
+            else {
+                return STOPPED; // At target position
+            }
+        });
+    }
+    /**
+     * Configure TargetPosition characteristic.
+     * Allows user to set desired blind position (0-100%).
+     */
+    configureTargetPosition() {
+        const controlSchema = this.getSchema(...SCHEMA_CODE.CONTROL);
+        const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_POSITION) ||
+            this.getSchema(...SCHEMA_CODE.POSITION);
+        if (!controlSchema && !targetSchema) {
+            this.log.warn('No target position schema available for blinds control');
+            return;
+        }
+        const service = this.accessory.getService(this.Service.WindowCovering) ||
+            this.accessory.addService(this.Service.WindowCovering);
+        service.getCharacteristic(this.Characteristic.TargetPosition)
+            .onGet(() => {
+            // If target position schema exists, use it
+            if (targetSchema) {
+                const status = this.getStatus(targetSchema.code);
+                return (0, util_1.limit)(status.value, 0, 100);
+            }
+            // Otherwise, use control schema (open/close/stop)
+            if (controlSchema) {
+                const status = this.getStatus(controlSchema.code);
+                return this.controlValueToPosition(status.value);
+            }
+            return this.targetPosition ?? 50;
+        })
+            .onSet(async (value) => {
+            const targetPos = value;
+            this.targetPosition = targetPos;
+            // Clear any pending reset timer
+            if (this.positionResetTimer) {
+                clearTimeout(this.positionResetTimer);
+                this.positionResetTimer = undefined;
+            }
+            // If we have a percent_control schema, use it directly
+            if (targetSchema && targetSchema.code !== 'control' && targetSchema.code !== 'mach_operate') {
+                await this.sendCommands([{ code: targetSchema.code, value: targetPos }], true);
+            }
+            else if (controlSchema) {
+                // Otherwise, use the control schema (open/close/stop)
+                const controlValue = this.positionToControlValue(targetPos);
+                await this.sendCommands([{ code: controlSchema.code, value: controlValue }], true);
+                // Schedule idle reset after 30 seconds if device doesn't report position
+                // This prevents the blinds from continuously moving
+                this.positionResetTimer = setTimeout(() => {
+                    this._resetToIdle();
+                }, 30 * 1000);
+            }
+        });
+    }
+    /**
+     * Convert HomeKit position value (0-100) to Tuya control value (open/close/stop).
+     */
+    positionToControlValue(position) {
+        if (position >= 95) {
+            return 'open'; // or 'ZZ' for some devices
+        }
+        else if (position <= 5) {
+            return 'close'; // or 'FZ' for some devices
+        }
+        else {
+            return 'stop'; // or 'STOP' for some devices
+        }
+    }
+    /**
+     * Convert Tuya control value (open/close/stop) to HomeKit position (0-100).
+     */
+    controlValueToPosition(value) {
+        const lowerValue = value.toLowerCase();
+        if (lowerValue === 'open' || lowerValue === 'zz') {
+            return 100;
+        }
+        else if (lowerValue === 'close' || lowerValue === 'fz') {
+            return 0;
+        }
+        else if (lowerValue === 'stop' || lowerValue === 'stopped') {
+            return 50;
+        }
+        return 50; // Default to middle
+    }
+    /**
+     * Reset control to idle state after position movement completes.
+     */
+    _resetToIdle() {
+        const controlSchema = this.getSchema(...SCHEMA_CODE.CONTROL);
+        if (controlSchema) {
+            this.sendCommands([{ code: controlSchema.code, value: 'stop' }]);
+        }
+        this.positionResetTimer = undefined;
+    }
+    /**
+     * Handle device status updates from cloud/local.
+     */
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        // If we receive a position update, clear the reset timer
+        const positionUpdate = status.find(s => SCHEMA_CODE.CURRENT_POSITION.includes(s.code) ||
+            (SCHEMA_CODE.TARGET_POSITION.includes(s.code) && s.code !== 'control'));
+        if (positionUpdate && this.positionResetTimer) {
+            clearTimeout(this.positionResetTimer);
+            this.positionResetTimer = undefined;
+        }
+    }
+}
+exports.default = BlindsAccessory;
+//# sourceMappingURL=BlindsAccessory.js.map