@marcel2215/homebridge-supla-plugin 2.1.9 → 2.1.11

package/dist/platform.js

@@ -55,7 +55,7 @@ const ActionTriggerAccessory_1 = require("./Accesories/ActionTriggerAccessory");
  */
 class SuplaPlatform {
     constructor(log, config, api) {
-        var _a, _b;
+        var _a, _b, _c;
         this.log = log;
         this.config = config;
         this.api = api;
@@ -63,7 +63,14 @@ class SuplaPlatform {
         this.Characteristic = this.api.hap.Characteristic;
         this.accessories = [];
         this.mqttHandlers = new Map();
+        this.mqttHandlerOwners = new Map();
+        this.mqttWildcardHandlers = new Map();
+        this.ownerCleanups = new Map();
+        this.mqttDesiredSubscriptions = new Set();
         this.mqttSubscriptions = new Set();
+        this.mqttPendingSubscriptions = new Set();
+        this.mqttRetryTimers = new Map();
+        this.mqttRetryState = new Map();
         this.mqttRouterAttached = false;
         this.log.debug('Finished initializing platform:', this.config.name);
         const configView = this.config;
@@ -84,13 +91,37 @@ class SuplaPlatform {
         this.gateLockPulseSeconds = Number(configView.gateLockPulseSeconds) || 0;
         this.gateLockSetOnPayload = ((_a = configView.gateLockSetOnPayload) !== null && _a !== void 0 ? _a : 'true').toString();
         this.gateLockSetOffPayload = ((_b = configView.gateLockSetOffPayload) !== null && _b !== void 0 ? _b : 'false').toString();
+        this.gatePartialHiMode = this.normalizeGatePartialHiMode(configView.gatePartialHiMode);
+        this.commandQos = this.normalizeCommandQos(configView.commandQos);
+        this.commandRetain = this.parseBoolean((_c = configView.commandRetain) !== null && _c !== void 0 ? _c : false);
+        this.api.on('shutdown', () => {
+            this.unregisterAllMqttHandlers();
+            if (this.MqttClient) {
+                this.MqttClient.client.end(true);
+            }
+        });
         this.api.on('didFinishLaunching', () => {
             log.debug('Executed didFinishLaunching callback');
             const mqttSettings = this.config;
             this.MqttClient = new SuplaMqttClient_1.SuplaMqttClient(mqttSettings, this.log);
             this.startMqttRouter();
+            this.MqttClient.client.on('connect', () => {
+                this.resubscribeAll(true);
+            });
+            this.MqttClient.client.on('close', () => {
+                this.clearActiveSubscriptions();
+            });
+            this.MqttClient.client.on('offline', () => {
+                this.clearActiveSubscriptions();
+            });
+            this.MqttClient.client.on('end', () => {
+                this.clearActiveSubscriptions();
+            });
+            if (this.MqttClient.client.connected) {
+                this.resubscribeAll(true);
+            }
             this.discoverDevices();
-            this.MqttClient.discoverChannelsAsync().then((channels) => {
+            this.MqttClient.discoverChannelsAsync((topic, handler) => (this.registerMqttHandler(topic, handler, 'discovery'))).then((channels) => {
                 this.persistChannels(channels);
                 this.discoverDevices(channels);
                 this.log.info('Channels discovered and saved to config file');
@@ -126,10 +157,21 @@ class SuplaPlatform {
             const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
             if (existingAccessory) {
                 this.log.info('Restoring existing accessory from cache:', existingAccessory.displayName);
+                const signature = this.getChannelSignature(channel);
+                const previousSignature = existingAccessory.context.deviceSignature;
+                const wasConfigured = existingAccessory.context.deviceConfigured === true;
                 existingAccessory.context.device = channel;
+                existingAccessory.context.deviceSignature = signature;
                 this.log.debug(`Restoring channel ${channel.channelCaption} (${channel.deviceId}/${channel.channelId}) ` +
                     `function=${channel.channelFunction} type=${channel.channelType}`);
-                this.setupAccessory(channel, existingAccessory);
+                if (previousSignature !== signature || !wasConfigured) {
+                    if (previousSignature && previousSignature !== signature) {
+                        this.resetAccessoryServices(existingAccessory);
+                    }
+                    const configured = this.setupAccessory(channel, existingAccessory);
+                    existingAccessory.context.deviceConfigured = configured;
+                }
+                this.api.updatePlatformAccessories([existingAccessory]);
                 continue;
             }
             this.log.info('Adding new accessory:', channel.channelCaption);
@@ -137,15 +179,19 @@ class SuplaPlatform {
                 `function=${channel.channelFunction} type=${channel.channelType}`);
             const accessory = new this.api.platformAccessory(channel.channelCaption, uuid);
             accessory.context.device = channel;
+            accessory.context.deviceSignature = this.getChannelSignature(channel);
             if (this.setupAccessory(channel, accessory)) {
+                accessory.context.deviceConfigured = true;
                 this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
                 this.accessories.push(accessory);
+                this.api.updatePlatformAccessories([accessory]);
             }
         }
         if (shouldPrune) {
             const accessoriesToRemove = this.accessories.filter(accessory => !channelUuids.has(accessory.UUID));
             for (const accessory of accessoriesToRemove) {
                 this.log.info('Removing existing accessory from cache:', accessory.displayName);
+                this.unregisterMqttHandlers(accessory.UUID);
                 this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
                 const index = this.accessories.indexOf(accessory);
                 if (index !== -1) {
@@ -180,13 +226,16 @@ class SuplaPlatform {
         try {
             const configPath = this.api.user.configPath();
             const config = JSON.parse(fs.readFileSync(configPath).toString());
-            const platformConfig = (_a = config.platforms) === null || _a === void 0 ? void 0 : _a.find((platform) => platform.platform === 'SuplaPlatform');
+            const platformConfig = (_a = config.platforms) === null || _a === void 0 ? void 0 : _a.find((platform) => platform.platform === settings_1.PLATFORM_NAME);
             if (!platformConfig) {
-                this.log.warn('Failed to save channels: SuplaPlatform not found in config.');
+                this.log.warn(`Failed to save channels: ${settings_1.PLATFORM_NAME} not found in config.`);
                 return;
             }
             platformConfig.channels = JSON.stringify(channels);
-            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            const payload = JSON.stringify(config, null, 2);
+            const tempPath = `${configPath}.tmp`;
+            fs.writeFileSync(tempPath, payload);
+            fs.renameSync(tempPath, configPath);
             this.log.debug(`Saved ${channels.length} channels to config.`);
         }
         catch (error) {
@@ -222,12 +271,35 @@ class SuplaPlatform {
         return new SuplaChannelContext_1.SuplaChannelContext(baseTopic, channelType, channelFunction, caption, deviceId, channelId);
     }
     getChannelUuid(channel) {
-        const key = channel.deviceId && channel.channelId
-            ? `${channel.deviceId}:${channel.channelId}`
-            : (channel.topic || channel.channelCaption);
+        const deviceId = channel.deviceId;
+        const channelId = channel.channelId;
+        const hasIds = deviceId && channelId && deviceId !== 'unknown' && channelId !== 'unknown';
+        const key = hasIds
+            ? `${deviceId}:${channelId}`
+            : (channel.topic || channel.channelCaption || `${deviceId}:${channelId}`);
         return this.api.hap.uuid.generate(key);
     }
+    getChannelSignature(channel) {
+        var _a, _b, _c, _d, _e;
+        return [
+            (_a = channel.topic) !== null && _a !== void 0 ? _a : '',
+            (_b = channel.channelFunction) !== null && _b !== void 0 ? _b : '',
+            (_c = channel.channelType) !== null && _c !== void 0 ? _c : '',
+            (_d = channel.deviceId) !== null && _d !== void 0 ? _d : '',
+            (_e = channel.channelId) !== null && _e !== void 0 ? _e : '',
+        ].join('|');
+    }
+    resetAccessoryServices(accessory) {
+        const keepUuid = this.Service.AccessoryInformation.UUID;
+        for (const service of accessory.services) {
+            if (service.UUID === keepUuid) {
+                continue;
+            }
+            accessory.removeService(service);
+        }
+    }
     setupAccessory(channel, accessory) {
+        this.unregisterMqttHandlers(accessory.UUID);
         this.log.debug(`Mapping channel ${channel.channelCaption} (${channel.deviceId}/${channel.channelId}) ` +
             `function=${channel.channelFunction} type=${channel.channelType}`);
         switch (channel.channelFunction) {
@@ -392,6 +464,9 @@ class SuplaPlatform {
     getGateLockSetOffPayload() {
         return this.gateLockSetOffPayload;
     }
+    getGatePartialHiMode() {
+        return this.gatePartialHiMode;
+    }
     normalizeCoveringControlMode(value) {
         const normalized = (value !== null && value !== void 0 ? value : 'set').toString().toLowerCase();
         if (normalized === 'execute_action') {
@@ -416,45 +491,113 @@ class SuplaPlatform {
         }
         return 'execute_action';
     }
+    normalizeGatePartialHiMode(value) {
+        const normalized = (value !== null && value !== void 0 ? value : 'moving').toString().toLowerCase();
+        if (normalized === 'open_endstop' || normalized === 'open') {
+            return 'open_endstop';
+        }
+        if (normalized === 'pedestrian_endstop' || normalized === 'pedestrian') {
+            return 'pedestrian_endstop';
+        }
+        if (normalized === 'ignore' || normalized === 'absent') {
+            return 'ignore';
+        }
+        return 'moving';
+    }
     normalizeTopicSuffix(value) {
         return value.toString().replace(/^\/+/, '');
     }
-    registerMqttHandler(topic, handler) {
-        var _a;
+    registerMqttHandler(topic, handler, ownerId) {
+        var _a, _b, _c;
         if (!topic) {
             return () => undefined;
         }
         this.startMqttRouter();
-        const handlers = (_a = this.mqttHandlers.get(topic)) !== null && _a !== void 0 ? _a : new Set();
+        const handlerMap = this.isWildcardTopic(topic) ? this.mqttWildcardHandlers : this.mqttHandlers;
+        const handlers = (_a = handlerMap.get(topic)) !== null && _a !== void 0 ? _a : new Set();
         handlers.add(handler);
-        this.mqttHandlers.set(topic, handlers);
-        if (!this.mqttSubscriptions.has(topic)) {
-            this.MqttClient.client.subscribe(topic, (err) => {
-                if (err) {
-                    this.log.error(`MQTT subscribe failed for ${topic}: ${err.message}`);
+        handlerMap.set(topic, handlers);
+        const ownerTopics = (_b = this.mqttHandlerOwners.get(ownerId)) !== null && _b !== void 0 ? _b : new Map();
+        const ownerHandlers = (_c = ownerTopics.get(topic)) !== null && _c !== void 0 ? _c : new Set();
+        ownerHandlers.add(handler);
+        ownerTopics.set(topic, ownerHandlers);
+        this.mqttHandlerOwners.set(ownerId, ownerTopics);
+        this.mqttDesiredSubscriptions.add(topic);
+        this.ensureSubscribed(topic, false);
+        return () => {
+            this.removeHandler(topic, handler);
+            const ownerTopics = this.mqttHandlerOwners.get(ownerId);
+            const ownerHandlers = ownerTopics === null || ownerTopics === void 0 ? void 0 : ownerTopics.get(topic);
+            if (ownerHandlers) {
+                ownerHandlers.delete(handler);
+                if (ownerHandlers.size === 0) {
+                    ownerTopics === null || ownerTopics === void 0 ? void 0 : ownerTopics.delete(topic);
                 }
-            });
-            this.mqttSubscriptions.add(topic);
-        }
+            }
+            if (ownerTopics && ownerTopics.size === 0) {
+                this.mqttHandlerOwners.delete(ownerId);
+            }
+        };
+    }
+    registerOwnerCleanup(ownerId, cleanup) {
+        var _a;
+        const cleanups = (_a = this.ownerCleanups.get(ownerId)) !== null && _a !== void 0 ? _a : new Set();
+        cleanups.add(cleanup);
+        this.ownerCleanups.set(ownerId, cleanups);
         return () => {
-            const active = this.mqttHandlers.get(topic);
+            const active = this.ownerCleanups.get(ownerId);
             if (!active) {
                 return;
             }
-            active.delete(handler);
+            active.delete(cleanup);
             if (active.size === 0) {
-                this.mqttHandlers.delete(topic);
-                if (this.mqttSubscriptions.has(topic)) {
-                    this.MqttClient.client.unsubscribe(topic, (err) => {
-                        if (err) {
-                            this.log.error(`MQTT unsubscribe failed for ${topic}: ${err.message}`);
-                        }
-                    });
-                    this.mqttSubscriptions.delete(topic);
-                }
+                this.ownerCleanups.delete(ownerId);
             }
         };
     }
+    unregisterMqttHandlers(ownerId) {
+        this.runOwnerCleanup(ownerId);
+        const ownerTopics = this.mqttHandlerOwners.get(ownerId);
+        if (!ownerTopics) {
+            return;
+        }
+        for (const [topic, handlers] of ownerTopics) {
+            for (const handler of handlers) {
+                this.removeHandler(topic, handler);
+            }
+        }
+        this.mqttHandlerOwners.delete(ownerId);
+    }
+    unregisterAllMqttHandlers() {
+        const ownerIds = new Set([
+            ...this.mqttHandlerOwners.keys(),
+            ...this.ownerCleanups.keys(),
+        ]);
+        for (const ownerId of Array.from(ownerIds)) {
+            this.unregisterMqttHandlers(ownerId);
+        }
+        for (const topic of Array.from(this.mqttDesiredSubscriptions)) {
+            this.removeSubscription(topic);
+        }
+        this.mqttHandlers.clear();
+        this.mqttWildcardHandlers.clear();
+        this.mqttDesiredSubscriptions.clear();
+        this.mqttSubscriptions.clear();
+        this.mqttPendingSubscriptions.clear();
+        this.clearAllSubscriptionRetries();
+        this.ownerCleanups.clear();
+    }
+    publishCommand(topic, payload, callback) {
+        this.MqttClient.client.publish(topic, payload, { qos: this.commandQos, retain: this.commandRetain }, (error) => {
+            if (callback) {
+                callback(error);
+                return;
+            }
+            if (error) {
+                this.log.error(`Publish failed for ${topic}: ${error.message}`);
+            }
+        });
+    }
     parseBoolean(value) {
         if (typeof value === 'boolean') {
             return value;
@@ -471,22 +614,275 @@ class SuplaPlatform {
         }
         return false;
     }
+    runOwnerCleanup(ownerId) {
+        const cleanups = this.ownerCleanups.get(ownerId);
+        if (!cleanups) {
+            return;
+        }
+        for (const cleanup of cleanups) {
+            try {
+                cleanup();
+            }
+            catch (error) {
+                this.log.error(`Owner cleanup error for ${ownerId}: ${error.message}`);
+            }
+        }
+        this.ownerCleanups.delete(ownerId);
+    }
+    clearActiveSubscriptions() {
+        if (this.mqttSubscriptions.size > 0 || this.mqttPendingSubscriptions.size > 0) {
+            this.log.debug('MQTT connection lost; clearing active subscriptions.');
+        }
+        this.mqttSubscriptions.clear();
+        this.mqttPendingSubscriptions.clear();
+        this.clearAllSubscriptionRetries();
+    }
+    clearAllSubscriptionRetries() {
+        for (const timer of this.mqttRetryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.mqttRetryTimers.clear();
+        this.mqttRetryState.clear();
+    }
+    clearSubscriptionRetry(topic) {
+        const timer = this.mqttRetryTimers.get(topic);
+        if (timer) {
+            clearTimeout(timer);
+            this.mqttRetryTimers.delete(topic);
+        }
+        this.mqttRetryState.delete(topic);
+    }
+    scheduleSubscriptionRetry(topic, reason, hardDeny) {
+        var _a;
+        if (this.mqttRetryTimers.has(topic)) {
+            return;
+        }
+        if (!this.mqttDesiredSubscriptions.has(topic)) {
+            return;
+        }
+        const baseDelayMs = 2500;
+        const maxDelayMs = 60000;
+        const now = Date.now();
+        const state = (_a = this.mqttRetryState.get(topic)) !== null && _a !== void 0 ? _a : {
+            attempt: 0,
+            delayMs: baseDelayMs,
+            lastLogAt: 0,
+            hardDenyCount: 0,
+            blockedUntil: 0,
+        };
+        if (hardDeny) {
+            state.hardDenyCount += 1;
+            if (state.hardDenyCount >= 3) {
+                state.blockedUntil = Math.max(state.blockedUntil, now + 5 * 60 * 1000);
+            }
+        }
+        const delayMs = state.delayMs;
+        const blockedDelayMs = state.blockedUntil > now ? state.blockedUntil - now : 0;
+        let scheduledDelayMs = delayMs;
+        if (blockedDelayMs > 0) {
+            scheduledDelayMs = blockedDelayMs;
+        }
+        else {
+            const jitter = Math.round(delayMs * 0.2 * (Math.random() * 2 - 1));
+            scheduledDelayMs = Math.max(baseDelayMs, Math.min(maxDelayMs, delayMs + jitter));
+            state.delayMs = Math.min(maxDelayMs, Math.max(baseDelayMs, delayMs * 2));
+            state.attempt += 1;
+        }
+        this.mqttRetryState.set(topic, state);
+        this.log.debug(`Retrying MQTT subscribe for ${topic} in ${scheduledDelayMs}ms (${reason}).`);
+        const timer = setTimeout(() => {
+            this.mqttRetryTimers.delete(topic);
+            if (!this.mqttDesiredSubscriptions.has(topic)) {
+                return;
+            }
+            this.ensureSubscribed(topic, true);
+        }, scheduledDelayMs);
+        this.mqttRetryTimers.set(topic, timer);
+    }
+    isSubscriptionGranted(topic, granted) {
+        if (!Array.isArray(granted) || granted.length === 0) {
+            return true;
+        }
+        const entry = granted.find((item) => item.topic === topic);
+        if (!entry) {
+            return false;
+        }
+        return entry.qos === 0 || entry.qos === 1 || entry.qos === 2;
+    }
+    logSubscriptionIssue(topic, message) {
+        var _a;
+        const now = Date.now();
+        const state = (_a = this.mqttRetryState.get(topic)) !== null && _a !== void 0 ? _a : {
+            attempt: 0,
+            delayMs: 2500,
+            lastLogAt: 0,
+            hardDenyCount: 0,
+            blockedUntil: 0,
+        };
+        const shouldLog = state.lastLogAt === 0 || now - state.lastLogAt > 60000;
+        if (shouldLog) {
+            this.log.error(message);
+            state.lastLogAt = now;
+        }
+        else {
+            this.log.debug(message);
+        }
+        this.mqttRetryState.set(topic, state);
+    }
+    ensureSubscribed(topic, force) {
+        if (!this.MqttClient) {
+            return;
+        }
+        if (!this.MqttClient.client.connected) {
+            return;
+        }
+        if (!this.mqttDesiredSubscriptions.has(topic)) {
+            return;
+        }
+        if (!force && (this.mqttSubscriptions.has(topic) || this.mqttPendingSubscriptions.has(topic))) {
+            return;
+        }
+        if (this.mqttPendingSubscriptions.has(topic)) {
+            return;
+        }
+        this.mqttPendingSubscriptions.add(topic);
+        this.MqttClient.client.subscribe(topic, (err, granted) => {
+            this.mqttPendingSubscriptions.delete(topic);
+            if (err) {
+                this.logSubscriptionIssue(topic, `MQTT subscribe failed for ${topic}: ${err.message}`);
+                this.mqttSubscriptions.delete(topic);
+                this.scheduleSubscriptionRetry(topic, 'error', false);
+                return;
+            }
+            if (!this.isSubscriptionGranted(topic, granted)) {
+                this.logSubscriptionIssue(topic, `MQTT subscription denied for ${topic}.`);
+                this.mqttSubscriptions.delete(topic);
+                this.scheduleSubscriptionRetry(topic, 'denied', true);
+                return;
+            }
+            if (!this.mqttDesiredSubscriptions.has(topic)) {
+                this.mqttSubscriptions.delete(topic);
+                this.clearSubscriptionRetry(topic);
+                if (this.MqttClient.client.connected) {
+                    this.MqttClient.client.unsubscribe(topic, (unsubscribeErr) => {
+                        if (unsubscribeErr) {
+                            this.log.error(`MQTT unsubscribe failed for ${topic}: ${unsubscribeErr.message}`);
+                        }
+                    });
+                }
+                return;
+            }
+            this.clearSubscriptionRetry(topic);
+            this.mqttSubscriptions.add(topic);
+        });
+    }
+    resubscribeAll(force) {
+        if (!this.MqttClient) {
+            return;
+        }
+        if (force) {
+            this.mqttPendingSubscriptions.clear();
+        }
+        for (const topic of this.mqttDesiredSubscriptions) {
+            this.ensureSubscribed(topic, force);
+        }
+    }
+    removeSubscription(topic) {
+        this.mqttDesiredSubscriptions.delete(topic);
+        this.mqttPendingSubscriptions.delete(topic);
+        this.clearSubscriptionRetry(topic);
+        if (!this.MqttClient) {
+            return;
+        }
+        if (this.mqttSubscriptions.has(topic)) {
+            this.MqttClient.client.unsubscribe(topic, (err) => {
+                if (err) {
+                    this.log.error(`MQTT unsubscribe failed for ${topic}: ${err.message}`);
+                }
+            });
+            this.mqttSubscriptions.delete(topic);
+        }
+    }
+    removeHandler(topic, handler) {
+        const handlerMap = this.isWildcardTopic(topic) ? this.mqttWildcardHandlers : this.mqttHandlers;
+        const active = handlerMap.get(topic);
+        if (!active) {
+            return;
+        }
+        active.delete(handler);
+        if (active.size === 0) {
+            handlerMap.delete(topic);
+            this.removeSubscription(topic);
+        }
+    }
+    isWildcardTopic(topic) {
+        return topic.includes('+') || topic.includes('#');
+    }
+    topicMatchesFilter(topic, filter) {
+        if (filter === topic) {
+            return true;
+        }
+        const filterParts = filter.split('/');
+        const topicParts = topic.split('/');
+        for (let i = 0; i < filterParts.length; i += 1) {
+            const filterPart = filterParts[i];
+            if (filterPart === '#') {
+                return i === filterParts.length - 1;
+            }
+            if (i >= topicParts.length) {
+                return false;
+            }
+            if (filterPart === '+') {
+                continue;
+            }
+            if (filterPart !== topicParts[i]) {
+                return false;
+            }
+        }
+        return filterParts.length === topicParts.length;
+    }
+    normalizeCommandQos(value) {
+        const parsed = Number(value);
+        if (parsed === 1 || parsed === 2) {
+            return parsed;
+        }
+        return 0;
+    }
     startMqttRouter() {
         if (this.mqttRouterAttached || !this.MqttClient) {
             return;
         }
         this.mqttRouterAttached = true;
+        this.resubscribeAll(false);
         this.MqttClient.client.on('message', (topic, message) => {
-            const handlers = this.mqttHandlers.get(topic);
-            if (!handlers) {
-                return;
-            }
-            for (const handler of handlers) {
+            const dispatched = new Set();
+            const dispatch = (handler, label) => {
+                if (dispatched.has(handler)) {
+                    return;
+                }
+                dispatched.add(handler);
                 try {
                     handler(message, topic);
                 }
                 catch (error) {
-                    this.log.error(`MQTT handler error for ${topic}: ${error.message}`);
+                    this.log.error(`MQTT handler error for ${label}: ${error.message}`);
+                }
+            };
+            const exactHandlers = this.mqttHandlers.get(topic);
+            if (exactHandlers) {
+                for (const handler of exactHandlers) {
+                    dispatch(handler, topic);
+                }
+            }
+            if (this.mqttWildcardHandlers.size === 0) {
+                return;
+            }
+            for (const [filter, handlers] of this.mqttWildcardHandlers) {
+                if (!this.topicMatchesFilter(topic, filter)) {
+                    continue;
+                }
+                for (const handler of handlers) {
+                    dispatch(handler, filter);
                 }
             }
         });