@homebridge-plugins/homebridge-tuya 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/local/LocalDeviceManager.js

@@ -37,14 +37,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const TuyaDevice_1 = __importStar(require("../cloud/device/TuyaDevice"));
-const TuyaOpenAPI_1 = __importDefault(require("../cloud/api/TuyaOpenAPI"));
-const TuyaDeviceManager_1 = __importDefault(require("../cloud/device/TuyaDeviceManager"));
+const TuyaDeviceManager_1 = __importDefault(require("../shared/TuyaDeviceManager"));
 const TuyaDiscovery_1 = __importDefault(require("./TuyaDiscovery"));
 const LocalDevice_1 = __importDefault(require("./LocalDevice"));
-const Logger_1 = require("../shared/util/Logger");
 const ConfigHash_1 = require("../shared/util/ConfigHash");
 const ZigbeeGatewayDetection_1 = require("./ZigbeeGatewayDetection");
 const DynamicChildDiscovery_1 = require("./DynamicChildDiscovery");
+const config_1 = require("../config");
 /**
  * Default DP-to-code mapping used when the user hasn't supplied one.
  * Keys are Tuya standard instruction codes; values are typical DP numbers.
@@ -92,12 +91,8 @@ function buildDpToCodeMap(dpMapping) {
  */
 class LocalDeviceManager extends TuyaDeviceManager_1.default {
     // ──────────────────────────────────────────────────────────────────────────
-    constructor(localConfig, log, persistPath) {
-        // Create a minimal dummy API so the parent initialises without connecting
-        const dummyLog = new Logger_1.PrefixLogger(log, 'LocalDummy', false);
-        const dummyApi = new TuyaOpenAPI_1.default('', '', '', dummyLog);
-        super(dummyApi, false);
-        this.localDevices = [];
+    constructor(localConfig, debugMode = false) {
+        super(debugMode);
         this.localConnections = new Map();
         this.discoveryTimeout = null;
         this.rediscoveryTimeout = null;
@@ -113,20 +108,96 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         this.discoveredVersions = new Map();
         // Pending local response watches to cancel superseded commands
         this.pendingLocalResponseWatchers = new Map();
-        // Tracks which devices had config changes
-        this.configChanged = new Map();
         // ── Zigbee gateway/child support ──────────────────────────────────────────
         /** Parent gateway ID → GatewayRelationship (derived from config at init). */
         this.gatewayRelationships = new Map();
         /** Parent gateway device ID → its active LocalDevice connection. */
         this.gatewayConnections = new Map();
-        // Stop the MQ that the parent started
-        this.mq.stop();
-        this.parentLog = log;
-        this.log = new Logger_1.PrefixLogger(log, 'LocalDeviceManager', false);
         this.config = localConfig;
-        this.discovery = new TuyaDiscovery_1.default(log);
-        this.configHash = new ConfigHash_1.ConfigHash(persistPath || '', 'tuya-local-configs');
+        this.discovery = new TuyaDiscovery_1.default();
+    }
+    async pullDevices() {
+        await this.initLocalDevices();
+        this.connectAllDevices();
+        const devices = [...this.devices];
+        this.log.info(`Registered ${devices.length} local device(s).`);
+        return devices;
+    }
+    createDeviceConfigHash(device) {
+        const cfg = this.config.devices?.find(config => config.tuyaDeviceId === device.id);
+        if (!cfg) {
+            return '';
+        }
+        const effectiveSwitchCount = this._getEffectiveSwitchCount(cfg, device);
+        // Check if config has changed since last run
+        // Hash the config fields that affect device behavior
+        const configToHash = {
+            tuyaDeviceId: cfg.tuyaDeviceId,
+            name: cfg.name,
+            tuyaKey: cfg.tuyaKey,
+            dpMapping: this._getDPMap(cfg.tuyaDeviceId),
+            switchCount: effectiveSwitchCount,
+            outletCount: effectiveSwitchCount,
+            protocolVersion: cfg.protocolVersion,
+            category: cfg.category,
+        };
+        return ConfigHash_1.ConfigHash.computeHash(configToHash);
+    }
+    configDevice(device) {
+        const deviceConfig = this.getDeviceConfig(device);
+        if (deviceConfig?.category) {
+            this.log.warn('Override %o category from %o to %o', device.name, device.category, deviceConfig.category);
+            device.category = deviceConfig.category;
+        }
+        if (deviceConfig?.unbridged) {
+            this.log.warn('Unbridge %o category %o', device.name, device.category);
+            device.unbridged = deviceConfig.unbridged;
+        }
+    }
+    getDeviceSchemaConfig(device, dpCode) {
+        const schema = this.getDeviceConfig(device)?.schema;
+        if (!schema || !dpCode) {
+            return undefined;
+        }
+        // ignore case - allow both the device code and its (optional) rename
+        const target = dpCode.toString().toLowerCase();
+        return schema.find(s => {
+            const code = s.code?.toString().toLowerCase();
+            const newCode = s.newCode?.toString().toLowerCase();
+            return code === target || newCode === target;
+        });
+    }
+    enableGarageDoorUseContactSensorForState(device) {
+        return this.getDeviceConfig(device)?.garageDoorUseContactSensorForState === true;
+    }
+    async retrieveDeviceRTSP(deviceID) {
+        const cameraConfig = this.config.cameras?.find(cameraConfig => cameraConfig.deviceId === deviceID);
+        if (cameraConfig) {
+            const rtspUrl = cameraConfig.rtspUrl;
+            if (rtspUrl.includes('@') || !cameraConfig.username) {
+                return rtspUrl;
+            }
+            else {
+                return `rtsp://${cameraConfig.username}:${cameraConfig.password}@${rtspUrl.substring('rtsp://'.length)}`;
+            }
+        }
+        return '';
+    }
+    getDeviceConfig(device) {
+        if (!this.config) {
+            return undefined;
+        }
+        // Find matching override, respecting source filtering
+        const matches = this.config.deviceOverrides?.filter(config => {
+            const sourceMatch = [config_1.TuyaPluginMode.local, config_1.TuyaPluginMode.both].includes(config.configFor);
+            const idMatch = config.id === device.id || config.id === device.uuid ||
+                config.id === device.product_id || config.id === 'global';
+            return sourceMatch && idMatch;
+        }) ?? [];
+        // Return device-specific config, then product, then global
+        return matches.find(config => config.id === device.id || config.id === device.uuid) ||
+            matches.find(config => config.id === device.product_id) ||
+            matches.find(config => config.id === 'global');
     }
     /**
      * Initialise discovery and register manually configured devices.
@@ -134,9 +205,10 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
      */
     async initLocalDevices() {
         // ── Zigbee: detect parent-child relationships before registering devices ──
-        if (this.config.devices && this.config.devices.length > 0) {
+        const zigbeeDevices = this.config.devices?.filter(ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isZigbeeDevice);
+        if (zigbeeDevices && zigbeeDevices.length > 0) {
             try {
-                this.gatewayRelationships = ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.detectFromDevices(this.config.devices);
+                this.gatewayRelationships = ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.detectFromDevices(zigbeeDevices);
                 if (this.gatewayRelationships.size > 0) {
                     for (const [parentId, rel] of this.gatewayRelationships) {
                         this.log.info(`Zigbee gateway detected: ${parentId} has ${rel.children.length} sub-device(s): ` +
@@ -157,10 +229,13 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
                 if (ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isChild(cfg)) {
                     continue;
                 }
-                this._registerDeviceConfig(cfg);
+                const device = this._registerDeviceConfig(cfg);
+                if (!!device) {
+                    this._syncSubDevices(device);
+                }
             }
             // Validate devices have keys if auto-discovery is disabled
-            if (this.config.autoDiscoverDevices === false) {
+            if (!this.config.autoDiscoverDevices) {
                 for (const cfg of this.config.devices) {
                     if (!cfg.tuyaKey && !ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isChild(cfg)) {
                         const deviceName = cfg.name || cfg.tuyaDeviceId;
@@ -172,7 +247,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         }
         // Start UDP discovery unless explicitly disabled
         if (this.config.autoDiscoverDevices !== false) {
-            this.discovery.on('discover', (result) => {
+            this.discovery.on(TuyaDiscovery_1.default.Events.DEVICE_DISCOVER, (result) => {
                 this._onDiscovered(result);
             });
             this._startDiscoveryPhase();
@@ -185,6 +260,59 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             }
         }
     }
+    /** sync connection info for sub devices */
+    _syncSubDevices(device) {
+        // We assume cases where only the parent device has settings and the sub‑device has none, as well as the opposite situation.
+        // or maybe a possibility that some cases may still be undetected.
+        if (device.sub) {
+            const parentDevice = this.devices.find(d => d.id === device.parent_id);
+            if (parentDevice) {
+                this._syncConnectionInfo(parentDevice, device);
+            }
+            else {
+                const dummyParentDevice = this._buildDiscoveredDevice({
+                    id: device.parent_id,
+                    ip: '',
+                    version: '',
+                });
+                this._syncConnectionInfo(dummyParentDevice, device);
+                this.devices.push(dummyParentDevice);
+            }
+        }
+        else {
+            const subDevices = this.devices.filter(d => d.sub && d.parent_id === device.id);
+            subDevices.forEach(subDevice => {
+                this._syncConnectionInfo(device, subDevice);
+            });
+            // else no subDevices
+        }
+    }
+    /**
+     * parentDevice and subDevice must have same localIp, localKey, localVersion.
+     * priority: value exists > value not exists > subDevice > parentDevice
+     */
+    _syncConnectionInfo(parentDevice, subDevice) {
+        const connectionProps = ['localIp', 'localKey', 'localVersion'];
+        for (const prop of connectionProps) {
+            const parentValue = parentDevice[prop];
+            const subValue = subDevice[prop];
+            const resolvedValue = this._resolveConnectionInfoValue(parentValue, subValue);
+            if (resolvedValue === undefined) {
+                continue;
+            }
+            parentDevice[prop] = resolvedValue;
+            subDevice[prop] = resolvedValue;
+        }
+    }
+    _resolveConnectionInfoValue(parentValue, subValue) {
+        if (subValue !== undefined && subValue !== null && subValue !== '') {
+            return subValue;
+        }
+        if (parentValue !== undefined && parentValue !== null && parentValue !== '') {
+            return parentValue;
+        }
+        return undefined;
+    }
     /** Stop discovery and disconnect all local TCP connections. */
     stopLocalDevices() {
         if (this.discoveryTimeout) {
@@ -207,9 +335,24 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         }
         this.gatewayConnections.clear();
     }
-    /** Returns ALL devices (both local shadow entries from this manager). */
     getDevice(deviceID) {
-        return this.localDevices.find(d => d.id === deviceID);
+        const device = this.devices.find(d => d.id === deviceID);
+        if (device) {
+            // local devices have synthetic schemas based on config, so enrich the device schema from config on retrieval
+            // Merge config schema with device schema, prioritizing config
+            device.schema.forEach(s => {
+                const configSchema = this.getDeviceConfig(device)?.schema?.find(cs => cs.code === s.code);
+                if (configSchema) {
+                    Object.assign(s, configSchema);
+                }
+            });
+            this.getDeviceConfig(device)?.schema?.forEach(cs => {
+                if (!device.schema.some(s => s.code === cs.code)) {
+                    device.schema.push(cs);
+                }
+            });
+        }
+        return device;
     }
     /**
      * Send commands to a local device.
@@ -217,11 +360,12 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
      * all existing accessory handlers work without modification.
      */
     async sendCommands(deviceID, commands) {
-        const dpMap = this.dpMaps.get(deviceID);
+        const dpMap = this._getDPMap(deviceID);
         if (!dpMap) {
             this.log.warn(`No dpMapping for local device ${deviceID}`);
-            return;
+            return false;
         }
+        this.log.error(`dpMap:${JSON.stringify(dpMap)}`);
         const dps = {};
         for (const { code, value } of commands) {
             const dp = dpMap[code];
@@ -232,10 +376,10 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             dps[String(dp)] = value;
         }
         if (Object.keys(dps).length === 0) {
-            return;
+            return false;
         }
         // Log the command for user visibility
-        const device = this.localDevices.find(d => d.id === deviceID);
+        const device = this.getDevice(deviceID);
         const deviceName = device?.name || deviceID;
         const commandStr = commands.map(c => `${c.code}=${c.value}`).join(', ');
         this.log.info(`[${deviceName}] Sending command (local): ${commandStr}`);
@@ -251,7 +395,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         if (!conn) {
             conn = this._createConnection(deviceID);
             if (!conn) {
-                return;
+                return false;
             }
         }
         const expectedDps = new Set(Object.keys(dps));
@@ -312,12 +456,13 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             return true;
         }
         try {
-            await responsePromise;
-            return true;
+            return await responsePromise;
         }
         catch (error) {
             this.log.warn(`Local command timeout or error for ${deviceName}: ${error instanceof Error ? error.message : error}`);
-            throw error;
+            // To prevent forcing the caller to implement try‑catch handling, this function will not throw error.
+            // throw error;
+            return false;
         }
     }
     _cancelSupersededLocalResponseWatchers(deviceID, expectedDps) {
@@ -349,52 +494,11 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             this.pendingLocalResponseWatchers.delete(deviceID);
         }
     }
-    handleCloudStatusUpdate(deviceID, statusUpdates) {
-        const device = this.localDevices.find(d => d.id === deviceID);
-        if (!device) {
-            return;
-        }
-        const dpMap = this.dpMaps.get(deviceID) ?? {};
-        const statusDps = new Set();
-        for (const status of statusUpdates) {
-            const dp = dpMap[status.code];
-            statusDps.add(dp !== undefined ? String(dp) : String(status.code));
-            const existing = device.status.find(s => s.code === status.code);
-            if (existing) {
-                existing.value = status.value;
-            }
-            else {
-                device.status.push({ code: status.code, value: status.value });
-            }
-        }
-        const watchers = this.pendingLocalResponseWatchers.get(deviceID);
-        if (!watchers || watchers.length === 0) {
-            return;
-        }
-        const remaining = [];
-        for (const watcher of watchers) {
-            let matched = false;
-            for (const dp of watcher.expectedDps) {
-                if (statusDps.has(dp)) {
-                    matched = true;
-                    break;
-                }
-            }
-            if (matched) {
-                watcher.cleanup();
-                watcher.resolve(true);
-            }
-            else {
-                remaining.push(watcher);
-            }
-        }
-        if (remaining.length > 0) {
-            this.pendingLocalResponseWatchers.set(deviceID, remaining);
-        }
-        else {
-            this.pendingLocalResponseWatchers.delete(deviceID);
-        }
-        this.emit(TuyaDeviceManager_1.default.Events.DEVICE_STATUS_UPDATE, device, statusUpdates);
+    /**
+     * Logic to suppress unnecessary discovery processes.
+     */
+    static isTargetDevice(device) {
+        return !device.isVirtualDevice() || !device.sub;
     }
     // ── Private helpers ────────────────────────────────────────────────────────
     /**
@@ -407,7 +511,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         }
         this.isDiscoveryActive = true;
         this.discoveredInCurrentPhase.clear();
-        this.log.info('Starting discovery phase');
+        this.log.debug('Starting discovery phase');
         this.discovery.start();
         // Stop after configurable timeout (config is in seconds, default 60s)
         // Convert to milliseconds
@@ -420,16 +524,16 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             this.discovery.stop();
             // Report discovery results for clarity
             if (this.discoveredInCurrentPhase.size > 0) {
-                this.log.info(`Ended discovery phase – rediscovered ${this.discoveredInCurrentPhase.size} device(s)`);
+                this.log.debug(`Ended discovery phase – rediscovered ${this.discoveredInCurrentPhase.size} device(s)`);
             }
             else {
                 // No devices found; they may be using cached IPs from previous discovery
-                const knownDevices = this.localDevices.filter(d => d.localKey);
+                const knownDevices = this.devices.filter(d => d.localKey);
                 if (knownDevices.length > 0) {
-                    this.log.info(`Ended discovery phase – no new devices found (${knownDevices.length} configured device(s) using cached IP)`);
+                    this.log.debug(`Ended discovery phase – no new devices found (${knownDevices.length} configured device(s) using cached IP)`);
                 }
                 else {
-                    this.log.info('Ended discovery phase – no devices found');
+                    this.log.debug('Ended discovery phase – no devices found');
                 }
             }
             this.discoveryTimeout = null;
@@ -457,35 +561,19 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         if (!cfg.tuyaDeviceId) {
             const name = cfg.name ?? 'unknown';
             this.log.warn(`Skipping invalid local config entry for ${name}: missing tuyaDeviceId`);
-            return;
-        }
-        const effectiveMap = Object.assign({}, DEFAULT_DP_MAP, cfg.dpMapping ?? {});
-        this.dpMaps.set(cfg.tuyaDeviceId, effectiveMap);
-        this.reverseDpMaps.set(cfg.tuyaDeviceId, buildDpToCodeMap(effectiveMap));
-        const existing = this.localDevices.find(d => d.id === cfg.tuyaDeviceId);
-        // Check if config has changed since last run
-        // Hash the config fields that affect device behavior
-        const configToHash = {
-            tuyaDeviceId: cfg.tuyaDeviceId,
-            name: cfg.name,
-            tuyaKey: cfg.tuyaKey,
-            dpMapping: cfg.dpMapping,
-            switchCount: cfg.switchCount,
-            outletCount: cfg.outletCount,
-            protocolVersion: cfg.protocolVersion,
-            category: cfg.category,
-        };
-        const { changed: configChanged } = this.configHash.hasConfigChanged(cfg.tuyaDeviceId, configToHash);
-        this.configChanged.set(cfg.tuyaDeviceId, configChanged);
-        if (configChanged && existing) {
-            this.log.info(`Device ${cfg.tuyaDeviceId}: config changed, rebuilding schema`);
+            return undefined;
         }
-        if (!existing) {
-            const device = this._buildTuyaDevice(cfg, configChanged);
-            this.localDevices.push(device);
-            this.devices.push(device); // keep parent's devices array in sync
-            this.emit(TuyaDeviceManager_1.default.Events.DEVICE_ADD, device);
+        const existing = this.getDevice(cfg.tuyaDeviceId);
+        if (existing) {
+            return existing;
         }
+        const effectiveMap = this._createDPMap(cfg);
+        this._setDPMap(cfg.tuyaDeviceId, cfg.parentDeviceId, ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isZigbeeDevice(cfg), effectiveMap);
+        const device = this._buildTuyaDevice(cfg);
+        this.configDevice(device);
+        this.devices.push(device);
+        this.emit(TuyaDeviceManager_1.default.Events.DEVICE_ADD, device);
+        return device;
     }
     /**
      * Set up auto-detection listener to count switches from device status updates.
@@ -494,7 +582,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
      */
     _setupAutoDetectionListener(deviceId, device, conn) {
         const cfg = this.config.devices?.find(d => d.tuyaDeviceId === deviceId);
-        if (!cfg || (cfg.switchCount || cfg.outletCount)) {
+        if (!cfg || this._getConfiguredSwitchCount(cfg) !== undefined) {
             return; // Already has explicit count
         }
         this.log.debug(`[AutoDetect] Setting up auto-detection listener for ${deviceId}`);
@@ -503,8 +591,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         const onStatusChange = (changes) => {
             this.log.debug(`[AutoDetect] Status change received for ${deviceId}: ${JSON.stringify(Object.keys(changes))}`);
             // Collect switch numbers from incoming changes
-            const dpMap = this.dpMaps.get(deviceId) ?? DEFAULT_DP_MAP;
-            const reverseMap = buildDpToCodeMap(dpMap);
+            const reverseMap = this.reverseDpMaps.get(deviceId) ?? {};
             for (const dpStr of Object.keys(changes)) {
                 const dpNum = parseInt(dpStr, 10);
                 const code = reverseMap[dpNum];
@@ -527,28 +614,12 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
                     this.log.info(`[AutoDetect] Auto-detected ${detectedCount} switch(es) for "${cfg.name}" (${deviceId}): ` +
                         `switches=[${switchList}]`);
                     // Update device schema with detected switch count
-                    device.schema = this._buildSyntheticSchema(this.dpMaps.get(deviceId) ?? DEFAULT_DP_MAP, detectedCount);
-                    device.switchCount = detectedCount;
+                    device.schema = this._buildSyntheticSchema(device, this._getDPMap(deviceId), detectedCount);
+                    device.switchCount = this._getEffectiveSwitchCount(cfg) ?? detectedCount;
                     // Auto-detection is now complete
                     device.isAutoDetecting = false;
-                    // Recalculate config hash since the schema has changed
-                    // This ensures SwitchAccessory knows to rebuild services
-                    const updatedConfigToHash = {
-                        tuyaDeviceId: cfg.tuyaDeviceId,
-                        name: cfg.name,
-                        tuyaKey: cfg.tuyaKey,
-                        dpMapping: cfg.dpMapping,
-                        switchCount: detectedCount,
-                        outletCount: cfg.outletCount,
-                        protocolVersion: cfg.protocolVersion,
-                        category: cfg.category,
-                    };
-                    const { changed: schemaChanged } = this.configHash.hasConfigChanged(deviceId, updatedConfigToHash);
-                    if (schemaChanged) {
-                        this.log.debug('[AutoDetect] Schema changed after auto-detection, marking config as changed');
-                        device.configChanged = true;
-                        this.configChanged.set(deviceId, true);
-                    }
+                    // update config
+                    cfg.switchCount = device.switchCount;
                     // Notify the platform so configureServices() is re-run and switch_2+ services are added.
                     this.emit(TuyaDeviceManager_1.default.Events.DEVICE_INFO_UPDATE, device, { schemaUpdated: true });
                 }
@@ -568,7 +639,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         this.discoveredVersions.set(result.id, result.version);
         this.discoveredInCurrentPhase.add(result.id);
         // If we already have a TuyaDevice for this ID (from manual config), update its IP
-        const existing = this.localDevices.find(d => d.id === result.id);
+        const existing = this.getDevice(result.id);
         if (existing) {
             this.log.info(`Device ${result.id} (v${result.version}) rediscovered @ ${result.ip} ` +
                 '– updating connection');
@@ -594,14 +665,14 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         // New device discovered via UDP – create a placeholder TuyaDevice
         // (it won't be controllable until the user provides a tuyaKey via config)
         const device = this._buildDiscoveredDevice(result);
-        this.localDevices.push(device);
+        this.configDevice(device);
         this.devices.push(device);
         const productInfo = result.productKey ? ` productKey=${result.productKey}` : '';
         this.log.info(`Local device discovered: ${result.id} @ ${result.ip} (v${result.version}${productInfo}) ` +
             '– add to config with tuyaKey to control');
         this.emit(TuyaDeviceManager_1.default.Events.DEVICE_ADD, device);
     }
-    _buildTuyaDevice(cfg, configChanged = false) {
+    _buildTuyaDevice(cfg) {
         const device = new TuyaDevice_1.default({});
         const deviceId = cfg.tuyaDeviceId ?? '';
         device.id = deviceId;
@@ -622,11 +693,15 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         device.active_time = 0;
         device.update_time = 0;
         device.status = [];
-        const switchCount = cfg.switchCount ?? cfg.outletCount ?? 1;
-        const autoDetectNote = !cfg.switchCount && !cfg.outletCount && cfg.tuyaKey ? ' (auto-detecting on connect)' : '';
-        const isAutoDetecting = !!(cfg.tuyaKey && !cfg.switchCount && !cfg.outletCount);
+        device.parent_id = cfg.parentDeviceId;
+        device.remote_keys = cfg.remote_keys;
+        device.sub = !ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isChild(cfg) && !!cfg.parentDeviceId;
+        const configuredSwitchCount = this._getConfiguredSwitchCount(cfg);
+        const switchCount = configuredSwitchCount ?? 1;
+        const autoDetectNote = configuredSwitchCount === undefined && cfg.tuyaKey ? ' (auto-detecting on connect)' : '';
+        const isAutoDetecting = !!(cfg.tuyaKey && configuredSwitchCount === undefined);
         this.log.info(`Building synthetic schema for ${cfg.name} with switchCount=${switchCount}${autoDetectNote}`);
-        device.schema = this._buildSyntheticSchema(Object.assign({}, DEFAULT_DP_MAP, cfg.dpMapping ?? {}), switchCount);
+        device.schema = this._buildSyntheticSchema(device, this._getDPMap(device.id), switchCount);
         this.log.info(`Device "${cfg.name}" schema includes ${device.schema.length} codes: ${device.schema.map(s => s.code).join(', ')}`);
         // Store local-specific metadata directly on the device object for later use
         device.localKey = cfg.tuyaKey;
@@ -638,8 +713,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         device.isLocal = true;
         device.switchCount = switchCount;
         device.isAutoDetecting = isAutoDetecting;
-        // Track whether config changed (used by SwitchAccessory to decide whether to remove cached extras)
-        device.configChanged = configChanged;
+        this.log.debug(`_buildTuyaDevice local device:${JSON.stringify(device)}`);
         return device;
     }
     _buildDiscoveredDevice(result) {
@@ -665,11 +739,13 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
         device.schema = [];
         device.isLocal = true;
         device.localVersion = result.version;
+        this.log.info(`_buildDiscoveredDevice local device:${JSON.stringify(device)}`);
         return device;
     }
-    _buildSyntheticSchema(dpMapping, switchCount = 1) {
+    _buildSyntheticSchema(device, dpMapping, switchCount = 1) {
         // If switchCount is limited, filter switch-related entries to only the needed ones
         let filteredMapping = dpMapping;
+        this.log.error(`deviceID:${device.id}, switchCount:${switchCount}`);
         if (switchCount > 0) {
             // Only include switch_1 through switch_N where N = switchCount
             // Also exclude other switch variants (like switch_led, switch_inching) if limited
@@ -694,45 +770,84 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
                 this.log.debug(`Filtered switches: kept [${switchCodes.join(', ')}], excluded others`);
             }
         }
-        return Object.keys(filteredMapping).map(code => ({
+        this.log.debug(`local device schema codes:${JSON.stringify(filteredMapping)}`);
+        const schemas = Object.keys(filteredMapping).map(code => ({
             code,
             mode: TuyaDevice_1.TuyaDeviceSchemaMode.READ_WRITE,
             type: TuyaDevice_1.TuyaDeviceSchemaType.Boolean, // best-effort default; handlers may override
             property: {},
         }));
+        // apply overrides. The synthetic schemas are keyed on the (possibly renamed)
+        // dp code, so match on newCode when a rename is set, otherwise on the device code.
+        this.getDeviceConfig(device)?.schema?.forEach(s => {
+            if (!s.code) {
+                return;
+            }
+            const targetCode = s.newCode?.trim() || s.code;
+            if (!targetCode) {
+                return;
+            }
+            const schema = schemas.find(t => t.code === targetCode);
+            if (!!schema) {
+                schema.type = s.type ?? schema.type;
+                schema.property = s.property ?? schema.property;
+            }
+            else {
+                schemas.push({
+                    code: targetCode,
+                    mode: TuyaDevice_1.TuyaDeviceSchemaMode.READ_WRITE,
+                    type: s.type ?? TuyaDevice_1.TuyaDeviceSchemaType.Boolean,
+                    property: s.property ?? {},
+                });
+            }
+        });
+        this.log.error('schema:%o', schemas);
+        return schemas;
     }
     _createConnection(deviceID) {
-        const device = this.localDevices.find(d => d.id === deviceID);
+        let device = this.getDevice(deviceID);
         if (!device) {
             return undefined;
         }
-        const localKey = device.localKey;
+        // Since the sub‑device’s actual entity is the parent device, no separate connection is established for the sub‑device.
+        if (device.sub) {
+            const parentDevice = this.getDevice(device.parent_id);
+            if (parentDevice) {
+                device = parentDevice;
+            }
+            else {
+                this.log.warn(`parent device not found. parentDeviceID: ${device.parent_id}, subDeviceID: ${deviceID}.`);
+                this.log.warn('sub device will be used as parent device.');
+            }
+        }
+        const connectDeviceID = device.id;
+        let localKey = device.localKey;
         if (!localKey) {
-            this.log.warn(`No tuyaKey configured for local device ${deviceID} — cannot connect.`);
+            this.log.warn(`No tuyaKey configured for local device ${connectDeviceID} — cannot connect.`);
             return undefined;
         }
-        const ip = device.ip || device.localIp;
+        const ip = device.localIp ?? device.ip;
         if (!ip) {
-            this.log.warn(`No IP known for local device ${deviceID} — cannot connect.`);
+            this.log.warn(`No IP known for local device ${connectDeviceID} — cannot connect.`);
             return undefined;
         }
         const version = device.localVersion
-            ?? this.discoveredVersions.get(deviceID)
+            ?? this.discoveredVersions.get(connectDeviceID)
             ?? '3.3';
         const conn = new LocalDevice_1.default({
-            id: deviceID,
+            id: connectDeviceID,
             key: Buffer.from(localKey, 'utf8'),
             ip,
             version,
             name: device.name,
-        }, this.parentLog);
+        });
         conn.on('connect', () => {
             device.online = true;
             this.emit(TuyaDeviceManager_1.default.Events.DEVICE_INFO_UPDATE, device, { online: true });
             // ── Zigbee: when a gateway connects, set up its children ──
-            if (this.gatewayRelationships.has(deviceID)) {
-                this.gatewayConnections.set(deviceID, conn);
-                this._setupZigbeeChildren(deviceID, conn);
+            if (this.gatewayRelationships.has(connectDeviceID)) {
+                this.gatewayConnections.set(connectDeviceID, conn);
+                this._setupZigbeeChildren(connectDeviceID, conn);
             }
         });
         conn.on('disconnect', () => {
@@ -740,7 +855,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             this.emit(TuyaDeviceManager_1.default.Events.DEVICE_INFO_UPDATE, device, { online: false });
         });
         conn.on('change', (changes) => {
-            const reverseMap = this.reverseDpMaps.get(deviceID) ?? {};
+            const reverseMap = this.reverseDpMaps.get(connectDeviceID) ?? {};
             const statusUpdates = [];
             for (const [dp, val] of Object.entries(changes)) {
                 const code = reverseMap[parseInt(dp, 10)] ?? dp;
@@ -759,12 +874,12 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             }
         });
         conn.on('error', (err) => {
-            this.log.warn(`Error for local device ${deviceID}: ${err.message}`);
+            this.log.warn(`Error for local device ${connectDeviceID}: ${err.message}`);
         });
         // Set up auto-detection listener BEFORE connecting to avoid race conditions
-        this._setupAutoDetectionListener(deviceID, device, conn);
+        this._setupAutoDetectionListener(connectDeviceID, device, conn);
         conn.connect();
-        this.localConnections.set(deviceID, conn);
+        this.localConnections.set(connectDeviceID, conn);
         return conn;
     }
     /**
@@ -797,7 +912,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
      * Preserves the child's state and event listeners while updating the parent reference.
      */
     _reconnectZigbeeChild(childDeviceId, cid, childConn, newParentConn) {
-        const childTuyaDevice = this.localDevices.find(d => d.id === childDeviceId);
+        const childTuyaDevice = this.getDevice(childDeviceId);
         if (!childTuyaDevice) {
             this.log.warn(`Zigbee child ${childDeviceId}: TuyaDevice not found during reconnect`);
             return;
@@ -837,10 +952,10 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             this.log.debug(`Zigbee child ${childDeviceId}: using per-child category override`);
         }
         // Register TuyaDevice if not already present
-        if (!this.localDevices.find(d => d.id === childDeviceId)) {
+        if (!this.getDevice(childDeviceId)) {
             this._registerDeviceConfig(effectiveChildCfg);
         }
-        const childTuyaDevice = this.localDevices.find(d => d.id === childDeviceId);
+        const childTuyaDevice = this.getDevice(childDeviceId);
         if (!childTuyaDevice) {
             this.log.warn(`Could not build TuyaDevice for Zigbee child ${childDeviceId}`);
             return;
@@ -852,7 +967,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             ip: parentConn['context'].ip,
             version: parentConn['context'].version,
             name: cfg.name ?? childDeviceId,
-        }, this.parentLog);
+        });
         // Link parent ↔ child
         childConn.parentDevice = parentConn;
         childConn.childId = cid;
@@ -958,7 +1073,7 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
     }
     /** Connect all configured local devices eagerly (called after init). */
     connectAllDevices() {
-        for (const device of this.localDevices) {
+        for (const device of this.devices) {
             const localKey = device.localKey;
             if (!localKey) {
                 continue; // Skip if no local key configured
@@ -976,6 +1091,88 @@ class LocalDeviceManager extends TuyaDeviceManager_1.default {
             }
         }
     }
+    _getConfiguredSwitchCount(cfg) {
+        if (!cfg) {
+            return undefined;
+        }
+        if (cfg.switchCount !== undefined) {
+            return cfg.switchCount;
+        }
+        if (cfg.outletCount !== undefined) {
+            return cfg.outletCount;
+        }
+        return undefined;
+    }
+    _getEffectiveSwitchCount(cfg, device) {
+        const configuredSwitchCount = this._getConfiguredSwitchCount(cfg);
+        if (configuredSwitchCount !== undefined) {
+            return configuredSwitchCount;
+        }
+        const deviceCount = device ? device.switchCount
+            ?? device.outletCount
+            : undefined;
+        return deviceCount;
+    }
+    _createDPMap(cfg) {
+        const effectiveMap = Object.assign({}, cfg.dpMapping, Object.fromEntries(cfg.dpMappingArray?.map(item => [item.dpCode, item.dpID]) ?? []));
+        if (Object.keys(effectiveMap).length === 0) {
+            Object.assign(effectiveMap, DEFAULT_DP_MAP);
+        }
+        // override dpcodes
+        for (const [dpCode, dpID] of Object.entries(effectiveMap)) {
+            const schemaConfig = this.getDeviceSchemaConfig({ id: cfg.tuyaDeviceId }, dpCode);
+            if (!schemaConfig?.newCode) {
+                continue;
+            }
+            // Only treat newCode as a rename when it actually differs from the device code.
+            // Renaming to the same key would set-then-delete it, dropping the dp↔code mapping.
+            if (schemaConfig.newCode && schemaConfig.newCode !== dpCode) {
+                effectiveMap[schemaConfig.newCode] = dpID;
+                delete effectiveMap[dpCode];
+            }
+            const targetCode = schemaConfig.newCode.trim();
+            if (!targetCode || targetCode === dpCode) {
+                continue;
+            }
+            effectiveMap[targetCode] = dpID;
+            delete effectiveMap[dpCode];
+        }
+        return effectiveMap;
+    }
+    _setDPMap(deviceID, parentDeviceId, isZigbeeDevice, dpMap) {
+        // Because sub‑devices have no actual entity, they are registered as part of the parent device’s information.
+        // Since there is only one real device,
+        // configuring each sub‑device individually is unnecessary—and even if you did, the settings would end up identical.
+        // If any inconsistencies occur, the values are merged, with later definitions taking precedence.
+        const isSubDevice = !isZigbeeDevice && !!parentDeviceId;
+        if (isSubDevice) {
+            const parentDPMap = this._getDPMap(parentDeviceId);
+            const mergedDPMap = { ...parentDPMap, ...dpMap };
+            this.dpMaps.set(parentDeviceId, mergedDPMap);
+            this.reverseDpMaps.set(parentDeviceId, buildDpToCodeMap(mergedDPMap));
+        }
+        else {
+            this.dpMaps.set(deviceID, dpMap);
+            this.reverseDpMaps.set(deviceID, buildDpToCodeMap(dpMap));
+        }
+    }
+    _getDPMap(deviceID) {
+        let localConfig = this.config.devices?.find(config => config.tuyaDeviceId === deviceID);
+        if (!localConfig) {
+            // ZigbeeChildDevice or HubSubDevice
+            localConfig = this.config.devices?.find(config => config.parentDeviceId === deviceID);
+        }
+        if (!localConfig) {
+            // A Local device almost never operates without configuration, but this is just in case.
+            return DEFAULT_DP_MAP;
+        }
+        if (!ZigbeeGatewayDetection_1.ZigbeeGatewayDetection.isChild(localConfig) && localConfig.parentDeviceId) {
+            return this.dpMaps.get(localConfig.parentDeviceId) ?? DEFAULT_DP_MAP;
+        }
+        else {
+            return this.dpMaps.get(deviceID) ?? DEFAULT_DP_MAP;
+        }
+    }
 }
 exports.default = LocalDeviceManager;
 //# sourceMappingURL=LocalDeviceManager.js.map