@marcel2215/homebridge-supla-plugin 2.1.8 → 2.1.10

package/dist/platform.js

@@ -30,7 +30,8 @@ const LightBulbAccesory_1 = require("./Accesories/LightBulbAccesory");
 const fs = __importStar(require("fs"));
 const SuplaMqttClient_1 = require("./Heplers/SuplaMqttClient");
 const RGBLightBulbAccesory_1 = require("./Accesories/RGBLightBulbAccesory");
-const DoorAccessory_1 = require("./Accesories/DoorAccessory");
+const GateAccessory_1 = require("./Accesories/GateAccessory");
+const GateLockAccessory_1 = require("./Accesories/GateLockAccessory");
 const SuplaChannelContext_1 = require("./Heplers/SuplaChannelContext");
 const DimmerAccessory_1 = require("./Accesories/DimmerAccessory");
 const SwitchAccessory_1 = require("./Accesories/SwitchAccessory");
@@ -54,12 +55,23 @@ const ActionTriggerAccessory_1 = require("./Accesories/ActionTriggerAccessory");
  */
 class SuplaPlatform {
     constructor(log, config, api) {
+        var _a, _b, _c;
         this.log = log;
         this.config = config;
         this.api = api;
         this.Service = this.api.hap.Service;
         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;
         this.coveringControlMode = this.normalizeCoveringControlMode(configView.coveringControlMode);
@@ -69,12 +81,46 @@ class SuplaPlatform {
         this.coveringExecuteActionClose = (configView.coveringExecuteActionClose || 'shut').toString();
         this.coveringExecuteActionStop = (configView.coveringExecuteActionStop || 'stop').toString();
         this.coveringTravelTimeSeconds = Number(configView.coveringTravelTimeSeconds) || 0;
+        this.gateControlMode = this.normalizeGateControlMode(configView.gateControlMode);
+        this.gateExecuteActionOpen = (configView.gateExecuteActionOpen || 'open').toString();
+        this.gateExecuteActionClose = (configView.gateExecuteActionClose || 'close').toString();
+        this.gateExecuteActionToggle = (configView.gateExecuteActionToggle || 'toggle').toString();
+        this.gateLockControlMode = this.normalizeGateLockControlMode(configView.gateLockControlMode);
+        this.gateLockExecuteAction = (configView.gateLockExecuteAction || 'open').toString();
+        this.gateLockSetTopicSuffix = this.normalizeTopicSuffix(configView.gateLockSetTopicSuffix || 'set/on');
+        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.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');
@@ -110,10 +156,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);
@@ -121,15 +178,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) {
@@ -164,13 +225,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) {
@@ -206,12 +270,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) {
@@ -219,8 +306,10 @@ class SuplaPlatform {
                 new GarageDoorOpenerAccesory_1.GarageDoorOpenerAccesory(this, accessory, channel);
                 return true;
             case 'CONTROLLINGTHEGATE':
+                new GateAccessory_1.GateAccessory(this, accessory, channel);
+                return true;
             case 'CONTROLLINGTHEGATEWAYLOCK':
-                new DoorAccessory_1.DoorAccessory(this, accessory, channel);
+                new GateLockAccessory_1.GateLockAccessory(this, accessory, channel);
                 return true;
             case 'LIGHTSWITCH':
                 new LightBulbAccesory_1.LightAccesory(this, accessory, channel);
@@ -344,6 +433,36 @@ class SuplaPlatform {
     getCoveringTravelTimeSeconds() {
         return this.coveringTravelTimeSeconds;
     }
+    getGateControlMode() {
+        return this.gateControlMode;
+    }
+    getGateExecuteActionOpen() {
+        return this.gateExecuteActionOpen;
+    }
+    getGateExecuteActionClose() {
+        return this.gateExecuteActionClose;
+    }
+    getGateExecuteActionToggle() {
+        return this.gateExecuteActionToggle;
+    }
+    getGateLockControlMode() {
+        return this.gateLockControlMode;
+    }
+    getGateLockExecuteAction() {
+        return this.gateLockExecuteAction;
+    }
+    getGateLockSetTopicSuffix() {
+        return this.gateLockSetTopicSuffix;
+    }
+    getGateLockPulseSeconds() {
+        return this.gateLockPulseSeconds;
+    }
+    getGateLockSetOnPayload() {
+        return this.gateLockSetOnPayload;
+    }
+    getGateLockSetOffPayload() {
+        return this.gateLockSetOffPayload;
+    }
     normalizeCoveringControlMode(value) {
         const normalized = (value !== null && value !== void 0 ? value : 'set').toString().toLowerCase();
         if (normalized === 'execute_action') {
@@ -354,9 +473,403 @@ class SuplaPlatform {
         }
         return 'set';
     }
+    normalizeGateControlMode(value) {
+        const normalized = (value !== null && value !== void 0 ? value : 'execute_action').toString().toLowerCase();
+        if (normalized === 'toggle') {
+            return 'toggle';
+        }
+        return 'execute_action';
+    }
+    normalizeGateLockControlMode(value) {
+        const normalized = (value !== null && value !== void 0 ? value : 'execute_action').toString().toLowerCase();
+        if (normalized === 'set_on_pulse') {
+            return 'set_on_pulse';
+        }
+        return 'execute_action';
+    }
     normalizeTopicSuffix(value) {
         return value.toString().replace(/^\/+/, '');
     }
+    registerMqttHandler(topic, handler, ownerId) {
+        var _a, _b, _c;
+        if (!topic) {
+            return () => undefined;
+        }
+        this.startMqttRouter();
+        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);
+        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);
+                }
+            }
+            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.ownerCleanups.get(ownerId);
+            if (!active) {
+                return;
+            }
+            active.delete(cleanup);
+            if (active.size === 0) {
+                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;
+        }
+        if (typeof value === 'number') {
+            return value === 1;
+        }
+        if (typeof value === 'string') {
+            const normalized = value.trim().toLowerCase();
+            return normalized === '1'
+                || normalized === 'true'
+                || normalized === 'on'
+                || normalized === 'yes';
+        }
+        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 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 ${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);
+                }
+            }
+        });
+    }
 }
 exports.SuplaPlatform = SuplaPlatform;
 //# sourceMappingURL=platform.js.map