@matter/node 0.16.6 → 0.16.8-alpha.0-20260123-dff2cae52

package/src/behavior/system/software-update/OtaAnnouncements.ts

@@ -21,33 +21,51 @@ const logger = new Logger("OTAAnnouncements");
 
 export class OtaAnnouncements {
     #announcementQueue = new Array<PeerAddress>();
-    #announcementTimer: Timer;
+    #announcementTimer?: Timer;
     #announcementDelayTimer: Timer;
     #ownNodeId: NodeId;
     #ownFabricIndex: FabricIndex;
     #ownVendorId: VendorId;
     #node: ServerNode;
     #otaProviderEndpoint: EndpointNumber;
-    #announcementInterval: Duration;
+    #announcementInterval?: Duration;
     #currentAnnouncementPromise?: Promise<void>;
 
-    constructor(endpoint: Endpoint, ownFabric: Fabric, interval: Duration) {
+    constructor(endpoint: Endpoint, ownFabric: Fabric) {
         this.#node = Node.forEndpoint(endpoint) as ServerNode;
         this.#ownNodeId = ownFabric.rootNodeId;
         this.#ownFabricIndex = ownFabric.fabricIndex;
         this.#ownVendorId = ownFabric.rootVendorId;
         this.#otaProviderEndpoint = endpoint.number;
+
+        // When announcing to multiple nodes, min 1s pause between, let's do some more, but no need for random
+        this.#announcementDelayTimer = Time.getTimer("OTA Node announcement delay", Seconds(10), () =>
+            this.#processQueueEntry(),
+        );
+    }
+
+    /**
+     * Set the interval to a time value or undefined to disable announcements
+     */
+    set interval(interval: Duration | undefined) {
+        if (interval === undefined) {
+            this.#announcementInterval = undefined;
+            this.#announcementTimer?.stop();
+            this.#announcementTimer = undefined;
+            return;
+        }
+
         if (interval < Hours(24)) {
             logger.warn("Announcements interval is too short, consider increasing it to at least 24 hours.");
             interval = Hours(24);
         }
+        if (interval === this.#announcementInterval) {
+            return;
+        }
         // The daily start time should have a random jitter of + >= 60s, so just increase the time randomly a bit
         this.#announcementInterval = Millis(interval + Seconds(Math.floor(Math.random() * 120) + 60));
 
-        // When announcing to multiple nodes, min 1s pause between, let's do some more, but no need for random
-        this.#announcementDelayTimer = Time.getTimer("OTA Node announcement delay", Seconds(10), () =>
-            this.#processQueueEntry(),
-        );
+        this.#announcementTimer?.stop();
 
         const initialDelay = Millis(Seconds(Math.floor(Math.random() * 300)) + Minutes(10));
         logger.debug(`Initial OTA announcement delay is ${Duration.format(initialDelay)}`);
@@ -57,7 +75,10 @@ export class OtaAnnouncements {
     }
 
     #initializeAnnouncements() {
-        this.#announcementTimer.stop();
+        if (this.#announcementInterval === undefined) {
+            return;
+        }
+        this.#announcementTimer?.stop();
         this.#announcementTimer = Time.getTimer("OTA All Nodes announcement timer", this.#announcementInterval, () =>
             this.#queueAllPeers(),
         );
@@ -65,6 +86,9 @@ export class OtaAnnouncements {
     }
 
     #queueAllPeers() {
+        if (this.#announcementTimer === undefined) {
+            return;
+        }
         this.#announcementTimer.stop();
         for (const peer of this.#node.peers) {
             if (!peer.lifecycle.isCommissioned || !peer.lifecycle.isOnline) {
@@ -81,6 +105,9 @@ export class OtaAnnouncements {
 
     // Queue a peer because processing is delayed and better to check /get peer anew when we process it
     #queuePeer(peerAddress: PeerAddress) {
+        if (this.#announcementTimer === undefined) {
+            return;
+        }
         this.#announcementQueue.push(peerAddress);
         logger.debug("Queued peer", peerAddress, "for OTA announcement;", this.#announcementQueue.length, "queued");
         if (this.#announcementQueue.length > 0 && !this.#announcementTimer.isRunning) {
@@ -236,7 +263,7 @@ export class OtaAnnouncements {
     }
 
     async close() {
-        this.#announcementTimer.stop();
+        this.#announcementTimer?.stop();
         this.#announcementDelayTimer.stop();
         if (this.#currentAnnouncementPromise !== undefined) {
             await this.#currentAnnouncementPromise;

package/src/behavior/system/software-update/SoftwareUpdateManager.ts

@@ -144,7 +144,8 @@ export class SoftwareUpdateManager extends Behavior {
             await this.#nodeOnline();
         }
 
-        this.reactTo(this.events.announceAsDefaultProvider$Changed, this.#announceAsDefaultProviderChanged);
+        this.reactTo(this.events.announceAsDefaultProvider$Changed, this.#updateAnnouncementSettings);
+        this.reactTo(this.events.announcementInterval$Changed, this.#updateAnnouncementSettings);
     }
 
     async #nodeOnline() {
@@ -153,7 +154,19 @@ export class SoftwareUpdateManager extends Behavior {
             this.internal.announcements = undefined;
         }
 
-        this.#announceAsDefaultProviderChanged(this.state.announceAsDefaultProvider);
+        // For now let's just provide update functionality when we are the fabric owner
+        // In theory we could also claim that for any other fabric but could conflict with the main controller of
+        // the fabric that then also claims being "the one provider".
+        const fabricAuthority = this.env.get(FabricAuthority);
+        const ownFabric = fabricAuthority.fabrics[0];
+        if (!ownFabric) {
+            // Can only happen if the SoftwareUpdateManager is used without any commissioned nodes
+            logger.info(`No commissioned peers yet, cannot check for OTA updates. Wait for Fabric being added.`);
+            fabricAuthority.fabricAdded.once(this.callback(this.#nodeOnline));
+            return;
+        }
+        this.internal.announcements = new OtaAnnouncements(this.endpoint, ownFabric);
+        this.#updateAnnouncementSettings();
 
         // Randomly force the first update check 5-10 minutes after startup
         const delay = Millis(Seconds(Math.floor(Math.random() * 300)) + Minutes(5));
@@ -166,33 +179,14 @@ export class SoftwareUpdateManager extends Behavior {
         ).start();
     }
 
-    #announceAsDefaultProviderChanged(enabled: boolean) {
-        if (!!this.internal.announcements === enabled) {
+    #updateAnnouncementSettings() {
+        if (this.internal.announcements === undefined) {
             return;
         }
-
-        if (enabled) {
-            // For now let's just provide update functionality when we are the fabric owner
-            // In theory we could also claim that for any other fabric but could conflict with the main controller of
-            // the fabric that then also claims being "the one provider".
-            const fabricAuthority = this.env.get(FabricAuthority);
-            const ownFabric = fabricAuthority.fabrics[0];
-            if (!ownFabric) {
-                // Can only happen if the SoftwareUpdateManager is used without any commissioned nodes
-                logger.info(`No commissioned peers yet, cannot check for OTA updates. Wait for Fabric being added.`);
-                fabricAuthority.fabricAdded.once(this.callback(this.#nodeOnline));
-                return;
-            }
-
-            this.internal.announcements = new OtaAnnouncements(
-                this.endpoint,
-                ownFabric,
-                this.state.announcementInterval,
-            );
+        if (this.state.announceAsDefaultProvider) {
+            this.internal.announcements.interval = this.state.announcementInterval;
         } else {
-            const announcements = this.internal.announcements!;
-            this.internal.announcements = undefined;
-            this.env.runtime.add(announcements.close());
+            this.internal.announcements.interval = undefined;
         }
     }
 
@@ -851,10 +845,7 @@ export namespace SoftwareUpdateManager {
         /** Default Update check Interval */
         updateCheckInterval = Hours(24);
 
-        /**
-         * Announce this controller as Update provider to all nodes
-         * Defaults to false because we saw strange effects in the field
-         */
+        /** Announce this controller as Update provider to all nodes */
         announceAsDefaultProvider = false;
 
         /** Interval to Announces this controller as Update provider. Must not be lower than 24h! */
@@ -890,5 +881,7 @@ export namespace SoftwareUpdateManager {
         updateDone = Observable<[peer: PeerAddress]>();
 
         announceAsDefaultProvider$Changed = Observable<[announceAsDefaultProvider: boolean]>();
+
+        announcementInterval$Changed = Observable<[announcementInterval: Duration]>();
     }
 }

package/src/behaviors/thermostat/ThermostatServer.ts

@@ -335,7 +335,9 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
 
             // TODO Add support for correct Time handling, leave disabled for now
             if (this.state.setpointHoldExpiryTimestamp === undefined) {
-                //this.state.setpointHoldExpiryTimestamp = null;
+                //this.agent.asLocalActor(() => {
+                //    this.state.setpointHoldExpiryTimestamp = null;
+                //});
             } else {
                 logger.warn(
                     "Handling for setpointHoldExpiryTimestamp is not yet implemented. To use this attribute you need to install the needed logic yourself",
@@ -405,7 +407,9 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
                 }
                 break;
         }
-        this.state.thermostatRunningMode = newState;
+        this.agent.asLocalActor(() => {
+            this.state.thermostatRunningMode = newState;
+        });
     }
 
     /**
@@ -1000,13 +1004,15 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
 
     #handleSystemModeChange(newMode: Thermostat.SystemMode) {
         if (this.state.thermostatRunningMode !== undefined && newMode !== Thermostat.SystemMode.Auto) {
-            if (newMode === Thermostat.SystemMode.Off) {
-                this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Off;
-            } else if (newMode === Thermostat.SystemMode.Heat) {
-                this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Heat;
-            } else if (newMode === Thermostat.SystemMode.Cool) {
-                this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Cool;
-            }
+            this.agent.asLocalActor(() => {
+                if (newMode === Thermostat.SystemMode.Off) {
+                    this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Off;
+                } else if (newMode === Thermostat.SystemMode.Heat) {
+                    this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Heat;
+                } else if (newMode === Thermostat.SystemMode.Cool) {
+                    this.state.thermostatRunningMode = Thermostat.ThermostatRunningMode.Cool;
+                }
+            });
         }
     }
 

package/src/node/integration/ProtocolService.ts

@@ -610,8 +610,9 @@ function invokeCommand(
             result = Promise.resolve(result)
                 .then(result => {
                     if (isObject(result)) {
-                        logger.debug(
-                            "Invoke result",
+                        logger.info(
+                            "Invoke",
+                            Mark.OUTBOUND,
                             Diagnostic.strong(`${path.toString()}.${command.name}`),
                             session.transaction!.via,
                             Diagnostic.dict(result),
@@ -622,8 +623,9 @@ function invokeCommand(
                 .finally(() => activity?.[Symbol.dispose]());
         } else {
             if (isObject(result)) {
-                logger.debug(
-                    "Invoke result",
+                logger.info(
+                    "Invoke",
+                    Mark.OUTBOUND,
                     Diagnostic.strong(`${path.toString()}.${command.name}`),
                     session.transaction.via,
                     Diagnostic.dict(result),