@project-chip/matter.js 0.9.2 → 0.9.4

package/src/protocol/interaction/InteractionClient.ts

@@ -460,7 +460,7 @@ export class InteractionClient {
             const writeRequests = attributes.map(
                 ({ endpointId, clusterId, attribute: { id, schema }, value, dataVersion }) => ({
                     path: { endpointId, clusterId, attributeId: id },
-                    data: schema.encodeTlv(value, true),
+                    data: schema.encodeTlv(value, { forWriteInteraction: true }),
                     dataVersion,
                 }),
             );

package/src/protocol/interaction/InteractionEndpointStructure.ts

@@ -7,7 +7,7 @@
 import { AnyAttributeServer } from "../../cluster/server/AttributeServer.js";
 import { ClusterServerObj, asClusterServerInternal } from "../../cluster/server/ClusterServerTypes.js";
 import { CommandServer } from "../../cluster/server/CommandServer.js";
-import { EventServer } from "../../cluster/server/EventServer.js";
+import { AnyEventServer } from "../../cluster/server/EventServer.js";
 import { ImplementationError, InternalError } from "../../common/MatterError.js";
 import { AttributeId } from "../../datatype/AttributeId.js";
 import { ClusterId } from "../../datatype/ClusterId.js";
@@ -37,11 +37,11 @@ export class InteractionEndpointStructure {
     endpoints = new Map<EndpointNumber, EndpointInterface>();
     attributes = new Map<string, AnyAttributeServer<any>>();
     attributePaths = new Array<AttributePath>();
-    events = new Map<string, EventServer<any, any>>();
+    events = new Map<string, AnyEventServer<any, any>>();
     eventPaths = new Array<EventPath>();
     commands = new Map<string, CommandServer<any, any>>();
     commandPaths = new Array<CommandPath>();
-    change = new Observable();
+    change = new Observable(); // TODO adjust to AsyncObservable when we remove legacy API
 
     public clear() {
         this.endpoints.clear();
@@ -220,7 +220,7 @@ export class InteractionEndpointStructure {
         throw new StatusResponseError(`Attribute ${attributeId} does not exist`, StatusCode.UnsupportedAttribute);
     }
 
-    getEvent(endpointId: EndpointNumber, clusterId: ClusterId, eventId: EventId): EventServer<any, any> | undefined {
+    getEvent(endpointId: EndpointNumber, clusterId: ClusterId, eventId: EventId): AnyEventServer<any, any> | undefined {
         return this.events.get(eventPathToId({ endpointId, clusterId, eventId }));
     }
 

package/src/protocol/interaction/InteractionMessenger.ts

@@ -166,6 +166,7 @@ export class InteractionServerMessenger extends InteractionMessenger<MatterDevic
                         const readRequest = TlvReadRequest.decode(message.payload);
                         await this.sendDataReport(
                             await recipient.handleReadRequest(this.exchange, readRequest, message),
+                            readRequest.isFabricFiltered,
                         );
                         break;
                     }
@@ -229,7 +230,7 @@ export class InteractionServerMessenger extends InteractionMessenger<MatterDevic
      * Handle DataReportPayload with the content of a DataReport to send, split them into multiple DataReport
      * messages and send them out based on the size.
      */
-    async sendDataReport(dataReportPayload: DataReportPayload) {
+    async sendDataReport(dataReportPayload: DataReportPayload, forFabricFilteredRead: boolean) {
         const {
             subscriptionId,
             attributeReportsPayload,
@@ -272,7 +273,11 @@ export class InteractionServerMessenger extends InteractionMessenger<MatterDevic
                             firstAttributeAddedToReportMessage = true;
                             messageSize += 3; // Array element is added now which needs 3 bytes
                         }
-                        const encodedAttribute = encodeAttributePayload(attributeReport);
+                        const allowMissingFieldsForNonFabricFilteredRead =
+                            !forFabricFilteredRead && attributeReport.hasFabricSensitiveData;
+                        const encodedAttribute = encodeAttributePayload(attributeReport, {
+                            allowMissingFieldsForNonFabricFilteredRead,
+                        });
                         const attributeReportBytes = TlvAny.getEncodedByteLength(encodedAttribute);
                         if (messageSize + attributeReportBytes > MAX_SPDU_LENGTH) {
                             if (canAttributePayloadBeChunked(attributeReport)) {
@@ -297,7 +302,11 @@ export class InteractionServerMessenger extends InteractionMessenger<MatterDevic
                         firstEventAddedToReportMessage = true;
                         messageSize += 3; // Array element is added now which needs 3 bytes
                     }
-                    const encodedEvent = encodeEventPayload(eventReport);
+                    const allowMissingFieldsForNonFabricFilteredRead =
+                        !forFabricFilteredRead && eventReport.hasFabricSensitiveData;
+                    const encodedEvent = encodeEventPayload(eventReport, {
+                        allowMissingFieldsForNonFabricFilteredRead,
+                    });
                     const eventReportBytes = TlvAny.getEncodedByteLength(encodedEvent);
                     if (messageSize + eventReportBytes > MAX_SPDU_LENGTH) {
                         await sendAndResetReport();

package/src/protocol/interaction/InteractionServer.ts

@@ -12,7 +12,7 @@ import {
     FabricScopedAttributeServer,
 } from "../../cluster/server/AttributeServer.js";
 import { CommandServer } from "../../cluster/server/CommandServer.js";
-import { EventServer } from "../../cluster/server/EventServer.js";
+import { AnyEventServer } from "../../cluster/server/EventServer.js";
 import { Message, SessionType } from "../../codec/MessageCodec.js";
 import { InternalError, MatterFlowError } from "../../common/MatterError.js";
 import { tryCatch, tryCatchAsync } from "../../common/TryCatchHandler.js";
@@ -31,7 +31,6 @@ import { Logger } from "../../log/Logger.js";
 import { GLOBAL_IDS } from "../../model/index.js";
 import { MessageExchange } from "../../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
-import { EventHandler } from "../../protocol/interaction/EventHandler.js";
 import { NoAssociatedFabricError, SecureSession, assertSecureSession } from "../../session/SecureSession.js";
 import { ArraySchema } from "../../tlv/TlvArray.js";
 import { TlvNoArguments } from "../../tlv/TlvNoArguments.js";
@@ -41,12 +40,7 @@ import {
     decodeListAttributeValueWithSchema,
     expandPathsInAttributeData,
 } from "./AttributeDataDecoder.js";
-import {
-    AttributeReportPayload,
-    DataReportPayload,
-    EventDataPayload,
-    EventReportPayload,
-} from "./AttributeDataEncoder.js";
+import { AttributeReportPayload, DataReportPayload, EventReportPayload } from "./AttributeDataEncoder.js";
 import { InteractionEndpointStructure } from "./InteractionEndpointStructure.js";
 import {
     InteractionRecipient,
@@ -103,6 +97,7 @@ export interface EventPath {
     endpointId: EndpointNumber;
     clusterId: ClusterId;
     eventId: EventId;
+    isUrgent?: boolean;
 }
 
 export interface AttributeWithPath {
@@ -112,7 +107,7 @@ export interface AttributeWithPath {
 
 export interface EventWithPath {
     path: EventPath;
-    event: EventServer<any, any>;
+    event: AnyEventServer<any, any>;
 }
 
 export interface CommandWithPath {
@@ -224,17 +219,15 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
     #nextSubscriptionId = Crypto.getRandomUInt32();
     readonly #subscriptionMap = new Map<number, SubscriptionHandler>();
     #isClosing = false;
-    #subscriptionConfig: SubscriptionOptions.Configuration;
-    #eventHandler: EventHandler;
+    readonly #subscriptionConfig: SubscriptionOptions.Configuration;
 
-    constructor({ subscriptionOptions, eventHandler, endpointStructure }: InteractionServer.Configuration) {
+    constructor({ subscriptionOptions, endpointStructure }: InteractionServer.Configuration) {
         this.#subscriptionConfig = SubscriptionOptions.configurationFor(subscriptionOptions);
-        this.#eventHandler = eventHandler;
         this.#endpointStructure = endpointStructure;
 
-        this.#endpointStructure.change.on(() => {
+        this.#endpointStructure.change.on(async () => {
             for (const subscription of this.#subscriptionMap.values()) {
-                subscription.updateSubscription();
+                await subscription.updateSubscription();
             }
         });
     }
@@ -340,6 +333,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                                 }`,
                             );
                             attributeReportsPayload.push({
+                                hasFabricSensitiveData: false,
                                 attributeStatus: { path: requestPath, status: { status: error.code } },
                             });
                         },
@@ -405,6 +399,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
 
                     const { schema } = attribute;
                     attributeReportsPayload.push({
+                        hasFabricSensitiveData: attribute.hasFabricSensitiveData,
                         attributeData: { path, dataVersion: version, payload: value, schema },
                     });
                 } catch (error) {
@@ -417,7 +412,10 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                     if (error instanceof StatusResponseError) {
                         // Add StatusResponseErrors, but only when the initial path was concrete, else error are ignored
                         if (isConcreteAttributePath(requestPath)) {
-                            attributeReportsPayload.push({ attributeStatus: { path, status: { status: error.code } } });
+                            attributeReportsPayload.push({
+                                hasFabricSensitiveData: false,
+                                attributeStatus: { path, status: { status: error.code } },
+                            });
                         }
                     } else {
                         throw error;
@@ -463,6 +461,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                                     }`,
                                 );
                                 eventReportsPayload?.push({
+                                    hasFabricSensitiveData: false,
                                     eventStatus: { path: requestPath, status: { status: error.code } },
                                 });
                             },
@@ -471,7 +470,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                     continue;
                 }
 
-                const reportsForPath = new Array<{ eventData: EventDataPayload }>();
+                const reportsForPath = new Array<EventReportPayload>();
                 for (const { path, event } of events) {
                     try {
                         const { endpointId } = path;
@@ -492,6 +491,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                         const { schema } = event;
                         reportsForPath.push(
                             ...matchingEvents.map(({ eventNumber, priority, epochTimestamp, data }) => ({
+                                hasFabricSensitiveData: event.hasFabricSensitiveData,
                                 eventData: {
                                     path,
                                     eventNumber,
@@ -512,7 +512,10 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
                         if (error instanceof StatusResponseError) {
                             // Add StatusResponseErrors, but only when the initial path was concrete, else error are ignored
                             if (isConcreteEventPath(requestPath)) {
-                                eventReportsPayload?.push({ eventStatus: { path, status: { status: error.code } } });
+                                eventReportsPayload?.push({
+                                    hasFabricSensitiveData: false,
+                                    eventStatus: { path, status: { status: error.code } },
+                                });
                             }
                         } else {
                             throw error;
@@ -558,7 +561,7 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
     protected async readEvent(
         _path: EventPath,
         eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
-        event: EventServer<any, any>,
+        event: AnyEventServer<any, any>,
         exchange: MessageExchange<MatterDevice>,
         isFabricFiltered: boolean,
         message: Message,
@@ -1006,46 +1009,43 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
 
         if (this.#nextSubscriptionId === 0xffffffff) this.#nextSubscriptionId = 0;
         const subscriptionId = this.#nextSubscriptionId++;
-        const subscriptionHandler = new SubscriptionHandler(
+        const subscriptionHandler = new SubscriptionHandler({
             subscriptionId,
             session,
-            this.#endpointStructure,
+            endpointStructure: this.#endpointStructure,
             attributeRequests,
             dataVersionFilters,
             eventRequests,
             eventFilters,
-            this.#eventHandler,
             isFabricFiltered,
-            minIntervalFloorSeconds,
-            maxIntervalCeilingSeconds,
-            () => this.#subscriptionMap.delete(subscriptionId),
-            this.#subscriptionConfig,
-        );
+            minIntervalFloor: minIntervalFloorSeconds,
+            maxIntervalCeiling: maxIntervalCeilingSeconds,
+            cancelCallback: () => this.#subscriptionMap.delete(subscriptionId),
+            subscriptionOptions: this.#subscriptionConfig,
+            readAttribute: (path, attribute) =>
+                this.readAttribute(
+                    path,
+                    attribute,
+                    exchange,
+                    isFabricFiltered,
+                    message,
+                    this.#endpointStructure.getEndpoint(path.endpointId)!,
+                ),
+            readEvent: (path, event, eventFilters) =>
+                this.readEvent(
+                    path,
+                    eventFilters,
+                    event,
+                    exchange,
+                    isFabricFiltered,
+                    message,
+                    this.#endpointStructure.getEndpoint(path.endpointId)!,
+                ),
+        });
 
         try {
             // Send initial data report to prime the subscription with initial data
-            await subscriptionHandler.sendInitialReport(
-                messenger,
-                (path, attribute) =>
-                    this.readAttribute(
-                        path,
-                        attribute,
-                        exchange,
-                        isFabricFiltered,
-                        message,
-                        this.#endpointStructure.getEndpoint(path.endpointId)!,
-                    ),
-                (path, event, eventFilters) =>
-                    this.readEvent(
-                        path,
-                        eventFilters,
-                        event,
-                        exchange,
-                        isFabricFiltered,
-                        message,
-                        this.#endpointStructure.getEndpoint(path.endpointId)!,
-                    ),
-            );
+            await subscriptionHandler.sendInitialReport(messenger);
         } catch (error: any) {
             logger.error(
                 `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports`,
@@ -1061,8 +1061,10 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
         }
 
         if (!keepSubscriptions) {
-            logger.debug(`Clear subscriptions for Session ${session.name} because keepSubscriptions=false`);
-            await session.clearSubscriptions(true);
+            logger.debug(
+                `Clear subscriptions for Subscriber node ${session.peerNodeId} because keepSubscriptions=false`,
+            );
+            await session.context.clearSubscriptionsForNode(fabric.fabricIndex, session.peerNodeId, true);
         }
 
         const maxInterval = subscriptionHandler.getMaxInterval();
@@ -1309,7 +1311,6 @@ export class InteractionServer implements ProtocolHandler<MatterDevice>, Interac
 export namespace InteractionServer {
     export interface Configuration {
         readonly subscriptionOptions?: SubscriptionOptions;
-        readonly eventHandler: EventHandler;
         readonly endpointStructure: InteractionEndpointStructure;
     }
 }