@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/es/protocol/interaction/InteractionServer.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterDevice } from "../../MatterDevice.js";
+import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
+import { MessageExchange } from "../../protocol/MessageExchange.js";
+import { DataReport, InteractionServerMessenger, InvokeRequest, InvokeResponse, ReadRequest, SubscribeRequest, TimedRequest, WriteRequest, WriteResponse } from "./InteractionMessenger.js";
+import { Attributes, Cluster, Commands, Events } from "../../cluster/Cluster.js";
+import { TlvAttributePath } from "./InteractionProtocol.js";
+import { BitSchema, TypeFromBitSchema } from "../../schema/BitmapSchema.js";
+import { TypeFromSchema } from "../../tlv/TlvSchema.js";
+import { Message } from "../../codec/MessageCodec.js";
+import { AttributeInitialValues, AttributeServers, ClusterServerHandlers } from "../../cluster/server/ClusterServer.js";
+import { CommandServer } from "../../cluster/server/CommandServer.js";
+import { AttributeServer } from "../../cluster/server/AttributeServer.js";
+import { StorageContext } from "../../storage/StorageContext.js";
+import { StorageManager } from "../../storage/StorageManager.js";
+export declare const INTERACTION_PROTOCOL_ID = 1;
+export declare class ClusterServer<F extends BitSchema, A extends Attributes, C extends Commands, E extends Events> {
+    readonly id: number;
+    readonly name: string;
+    readonly attributes: AttributeServers<A>;
+    readonly commands: CommandServer<any, any>[];
+    private clusterStorage;
+    private attributeStorageListeners;
+    constructor(clusterDef: Cluster<F, A, C, E>, features: TypeFromBitSchema<F>, attributesInitialValues: AttributeInitialValues<A>, handlers: ClusterServerHandlers<Cluster<F, A, C, E>>);
+    setStorage(storageContext: StorageContext): void;
+    attributeStorageListener(attributeName: string, version: number, value: any): void;
+}
+export interface CommandPath {
+    endpointId: number;
+    clusterId: number;
+    commandId: number;
+}
+export interface AttributePath {
+    endpointId: number;
+    clusterId: number;
+    attributeId: number;
+}
+export interface AttributeWithPath {
+    path: TypeFromSchema<typeof TlvAttributePath>;
+    attribute: AttributeServer<any>;
+}
+export declare function commandPathToId({ endpointId, clusterId, commandId }: CommandPath): string;
+export declare function attributePathToId({ endpointId, clusterId, attributeId }: TypeFromSchema<typeof TlvAttributePath>): string;
+export declare class InteractionServer implements ProtocolHandler<MatterDevice> {
+    private readonly storageManager;
+    private readonly endpoints;
+    private readonly attributes;
+    private readonly attributePaths;
+    private readonly commands;
+    private readonly commandPaths;
+    private nextSubscriptionId;
+    constructor(storageManager: StorageManager);
+    getId(): number;
+    addEndpoint(endpointId: number, device: {
+        name: string;
+        code: number;
+    }, clusters: ClusterServer<any, any, any, any>[]): this;
+    onNewExchange(exchange: MessageExchange<MatterDevice>): Promise<void>;
+    handleReadRequest(exchange: MessageExchange<MatterDevice>, { attributeRequests: attributePaths, isFabricFiltered }: ReadRequest): DataReport;
+    handleWriteRequest(exchange: MessageExchange<MatterDevice>, { suppressResponse, writeRequests }: WriteRequest): WriteResponse;
+    handleSubscribeRequest(exchange: MessageExchange<MatterDevice>, { minIntervalFloorSeconds, maxIntervalCeilingSeconds, attributeRequests, eventRequests, keepSubscriptions }: SubscribeRequest, messenger: InteractionServerMessenger): Promise<void>;
+    handleInvokeRequest(exchange: MessageExchange<MatterDevice>, { invokeRequests }: InvokeRequest, message: Message): Promise<InvokeResponse>;
+    handleTimedRequest(exchange: MessageExchange<MatterDevice>, { timeout }: TimedRequest): void;
+    private resolveAttributeName;
+    private getAttributes;
+}
+//# sourceMappingURL=InteractionServer.d.ts.map

package/dist/es/protocol/interaction/InteractionServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionServer.d.ts","sourceRoot":"","sources":["../../../../src/protocol/interaction/InteractionServer.ts"],"names":[],"mappings":"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"}

package/dist/es/protocol/interaction/InteractionServer.js

@@ -0,0 +1,362 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { InteractionServerMessenger, StatusResponseError } from "./InteractionMessenger.js";
+import { TlvSubscribeResponse } from "./InteractionProtocol.js";
+import { TlvNoArguments } from "../../tlv/TlvNoArguments.js";
+import { DeviceTypeId } from "../../datatype/DeviceTypeId.js";
+import { ClusterId } from "../../datatype/ClusterId.js";
+import { EndpointNumber } from "../../datatype/EndpointNumber.js";
+import { SubscriptionHandler } from "./SubscriptionHandler.js";
+import { Crypto } from "../../crypto/Crypto.js";
+import { decodeValueForSchema, normalizeAttributeData } from "./AttributeDataDecoder.js";
+import { CommandServer } from "../../cluster/server/CommandServer.js";
+import { AttributeGetterServer, AttributeServer } from "../../cluster/server/AttributeServer.js";
+import { DescriptorCluster } from "../../cluster/DescriptorCluster.js";
+import { Logger } from "../../log/Logger.js";
+import { capitalize } from "../../util/String.js";
+import { TlvVoid } from "../../tlv/TlvVoid.js";
+export const INTERACTION_PROTOCOL_ID = 0x0001;
+const logger = Logger.get("InteractionProtocol");
+export class ClusterServer {
+    constructor(clusterDef, features, attributesInitialValues, handlers) {
+        this.attributes = {};
+        this.commands = new Array();
+        this.clusterStorage = null;
+        this.attributeStorageListeners = new Map();
+        const { id, name, attributes: attributeDefs, commands: commandDefs } = clusterDef;
+        this.id = id;
+        this.name = name;
+        // Create attributes
+        attributesInitialValues = Object.assign(Object.assign({}, attributesInitialValues), { clusterRevision: clusterDef.revision, featureMap: features });
+        for (const name in attributesInitialValues) {
+            const { id, schema, writable, persistent } = attributeDefs[name];
+            const validator = typeof schema.validate === 'function' ? schema.validate.bind(schema) : undefined;
+            const getter = handlers[`get${capitalize(name)}`];
+            if (getter === undefined) {
+                this.attributes[name] = new AttributeServer(id, name, schema, validator !== null && validator !== void 0 ? validator : (() => { }), writable, attributesInitialValues[name]);
+            }
+            else {
+                this.attributes[name] = new AttributeGetterServer(id, name, schema, validator !== null && validator !== void 0 ? validator : (() => { }), writable, attributesInitialValues[name], getter);
+            }
+            if (persistent) {
+                const listener = (value, version) => this.attributeStorageListener(name, version, value);
+                this.attributeStorageListeners.set(id, listener);
+                this.attributes[name].addMatterListener(listener);
+            }
+        }
+        // Create commands
+        for (const name in commandDefs) {
+            const handler = handlers[name];
+            if (handler === undefined)
+                continue;
+            const { requestId, requestSchema, responseId, responseSchema } = commandDefs[name];
+            this.commands.push(new CommandServer(requestId, responseId, name, requestSchema, responseSchema, (request, session, message) => handler({ request, attributes: this.attributes, session, message })));
+        }
+    }
+    setStorage(storageContext) {
+        this.clusterStorage = storageContext;
+        for (const name in this.attributes) {
+            const attribute = this.attributes[name];
+            if (!this.attributeStorageListeners.has(attribute.id))
+                return;
+            if (!storageContext.has(attribute.name))
+                return;
+            try {
+                const data = storageContext.get(attribute.name);
+                logger.debug(`Restoring attribute ${attribute.name} (${attribute.id}) in cluster ${this.name} (${this.id})`);
+                attribute.init(data.value, data.version);
+            }
+            catch (error) {
+                logger.warn(`Failed to restore attribute ${attribute.name} (${attribute.id}) in cluster ${this.name} (${this.id})`, error);
+            }
+        }
+    }
+    attributeStorageListener(attributeName, version, value) {
+        if (!this.clusterStorage)
+            return;
+        logger.debug(`Storing attribute ${attributeName} in cluster ${this.name} (${this.id})`);
+        this.clusterStorage.set(attributeName, { version, value });
+    }
+}
+export function commandPathToId({ endpointId, clusterId, commandId }) {
+    return `${endpointId}/${clusterId}/${commandId}`;
+}
+export function attributePathToId({ endpointId, clusterId, attributeId }) {
+    return `${endpointId}/${clusterId}/${attributeId}`;
+}
+function toHex(value) {
+    return value === undefined ? "*" : `0x${value.toString(16)}`;
+}
+export class InteractionServer {
+    constructor(storageManager) {
+        this.storageManager = storageManager;
+        this.endpoints = new Map();
+        this.attributes = new Map();
+        this.attributePaths = new Array();
+        this.commands = new Map();
+        this.commandPaths = new Array();
+        this.nextSubscriptionId = Crypto.getRandomUInt32();
+    }
+    getId() {
+        return INTERACTION_PROTOCOL_ID;
+    }
+    addEndpoint(endpointId, device, clusters) {
+        // Add the descriptor cluster
+        const descriptorCluster = new ClusterServer(DescriptorCluster, {}, {
+            deviceTypeList: [{ revision: 1, deviceType: new DeviceTypeId(device.code) }],
+            serverList: [],
+            clientList: [],
+            partsList: [],
+        }, {});
+        clusters.push(descriptorCluster);
+        descriptorCluster.attributes.serverList.setLocal(clusters.map(({ id }) => new ClusterId(id)));
+        const clusterEndpointNumber = new EndpointNumber(endpointId);
+        const clusterMap = new Map();
+        clusters.forEach(cluster => {
+            const { id: clusterId, attributes, commands } = cluster;
+            cluster.setStorage(this.storageManager.createContext(`Cluster-${clusterEndpointNumber.number}-${clusterId}`));
+            clusterMap.set(clusterId, cluster);
+            // Add attributes
+            for (const name in attributes) {
+                const attribute = attributes[name];
+                const path = { endpointId, clusterId, attributeId: attribute.id };
+                this.attributes.set(attributePathToId(path), attribute);
+                this.attributePaths.push(path);
+            }
+            // Add commands
+            commands.forEach(command => {
+                const path = { endpointId, clusterId, commandId: command.invokeId };
+                this.commands.set(commandPathToId(path), command);
+                this.commandPaths.push(path);
+            });
+        });
+        // Add part list if the endpoint is not root
+        if (endpointId !== 0) {
+            const rootPartsListAttribute = this.attributes.get(attributePathToId({ endpointId: 0, clusterId: DescriptorCluster.id, attributeId: DescriptorCluster.attributes.partsList.id }));
+            if (rootPartsListAttribute === undefined)
+                throw new Error("The root endpoint should be added first!");
+            rootPartsListAttribute.setLocal([...rootPartsListAttribute.getLocal(), clusterEndpointNumber]);
+        }
+        this.endpoints.set(endpointId, Object.assign(Object.assign({}, device), { clusters: clusterMap }));
+        return this;
+    }
+    onNewExchange(exchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new InteractionServerMessenger(exchange).handleRequest(readRequest => this.handleReadRequest(exchange, readRequest), writeRequest => this.handleWriteRequest(exchange, writeRequest), (subscribeRequest, messenger) => this.handleSubscribeRequest(exchange, subscribeRequest, messenger), (invokeRequest, message) => this.handleInvokeRequest(exchange, invokeRequest, message), timedRequest => this.handleTimedRequest(exchange, timedRequest));
+        });
+    }
+    handleReadRequest(exchange, { attributeRequests: attributePaths, isFabricFiltered }) {
+        if (attributePaths === undefined) {
+            throw new StatusResponseError("Only Read requests with attributeRequests are supported right now", 143 /* StatusCode.UnsupportedRead */);
+        }
+        logger.debug(`Received read request from ${exchange.channel.getName()}: ${attributePaths.map(path => this.resolveAttributeName(path)).join(", ")}, isFabricFiltered=${isFabricFiltered}`);
+        // UnsupportedNode/UnsupportedEndpoint/UnsupportedCluster/UnsupportedAttribute/UnsupportedRead
+        const attributeReports = attributePaths.flatMap((path) => {
+            const attributes = this.getAttributes([path]);
+            if (attributes.length === 0) {
+                logger.debug(`Read from ${exchange.channel.getName()}: ${this.resolveAttributeName(path)} unsupported path`);
+                return [{ attributeStatus: { path, status: { status: 134 /* StatusCode.UnsupportedAttribute */ } } }]; // TODO: Find correct status code
+            }
+            return attributes.map(({ path, attribute }) => {
+                const { value, version } = attribute.getWithVersion(exchange.session); // TODO check ACL
+                logger.debug(`Read from ${exchange.channel.getName()}: ${this.resolveAttributeName(path)}=${Logger.toJSON(value)} (version=${version})`);
+                return { attributeData: { path, data: attribute.schema.encodeTlv(value), dataVersion: version } };
+            });
+        });
+        return {
+            interactionModelRevision: 1,
+            suppressResponse: false,
+            attributeReports
+        };
+    }
+    handleWriteRequest(exchange, { suppressResponse, writeRequests }) {
+        logger.debug(`Received write request from ${exchange.channel.getName()}: ${writeRequests.map(req => this.resolveAttributeName(req.path)).join(", ")}, suppressResponse=${suppressResponse}`);
+        // TODO consider TimedRequest constraints
+        const writeData = normalizeAttributeData(writeRequests, true);
+        const writeResults = writeData.flatMap((values) => {
+            const { path, dataVersion } = values[0];
+            const attributes = this.getAttributes([path], true);
+            if (attributes.length === 0) {
+                return [{ path, statusCode: 136 /* StatusCode.UnsupportedWrite */ }]; // TODO: Find correct status code
+            }
+            return attributes.map(({ path, attribute }) => {
+                // TODO add checks or dataVersion
+                // TODO add ACL checks
+                const { schema, defaultValue } = attribute;
+                try {
+                    const value = decodeValueForSchema(schema, values, defaultValue);
+                    logger.debug(`Handle write request from ${exchange.channel.getName()} resolved to: ${this.resolveAttributeName(path)}=${Logger.toJSON(value)} (Version=${dataVersion})`);
+                    attribute.set(value, exchange.session);
+                }
+                catch (error) {
+                    if (attributes.length === 1) { // For Multi-Attribute-Writes we ignore errors
+                        logger.error(`Error while handling write request from ${exchange.channel.getName()} to ${this.resolveAttributeName(path)}: ${error.message}`);
+                        return { path, statusCode: 135 /* StatusCode.ConstraintError */ };
+                    }
+                    else {
+                        logger.debug(`While handling write request from ${exchange.channel.getName()} to ${this.resolveAttributeName(path)} ignored: ${error.message}`);
+                    }
+                }
+                return { path, statusCode: 0 /* StatusCode.Success */ };
+            });
+            //.filter(({ statusCode }) => statusCode !== StatusCode.Success); // see https://github.com/project-chip/connectedhomeip/issues/26198
+        });
+        // TODO respect suppressResponse, potentially also needs adjustment in InteractionMessenger class!
+        const errorResults = writeResults.filter(({ statusCode }) => statusCode !== 0 /* StatusCode.Success */);
+        logger.debug(`Write request from ${exchange.channel.getName()} done ${errorResults.length ? `with following errors: ${errorResults.map(({ path, statusCode }) => `${this.resolveAttributeName(path)}=${Logger.toJSON(statusCode)}`).join(", ")}` : "without errors"}`);
+        return {
+            interactionModelRevision: 1,
+            writeResponses: writeResults.map(({ path, statusCode }) => ({ path, status: { status: statusCode } })),
+        };
+    }
+    handleSubscribeRequest(exchange, { minIntervalFloorSeconds, maxIntervalCeilingSeconds, attributeRequests, eventRequests, keepSubscriptions }, messenger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(`Received subscribe request from ${exchange.channel.getName()}`);
+            if (!exchange.session.isSecure())
+                throw new Error("Subscriptions are only implemented on secure sessions");
+            const session = exchange.session;
+            const fabric = session.getFabric();
+            if (fabric === undefined)
+                throw new Error("Subscriptions are only implemented after a fabric has been assigned");
+            if ((!Array.isArray(attributeRequests) || attributeRequests.length === 0) && (!Array.isArray(eventRequests) || eventRequests.length === 0)) {
+                throw new StatusResponseError("No attributes or events requested", 128 /* StatusCode.InvalidAction */);
+            }
+            if (!keepSubscriptions) {
+                session.clearSubscriptions();
+            }
+            // TODO add eventsRequest and other missing supports
+            if (attributeRequests !== undefined) {
+                logger.debug(`Subscribe to ${attributeRequests.map(path => this.resolveAttributeName(path)).join(", ")}`);
+                if (attributeRequests.length === 0)
+                    throw new Error("Unsupported subscription request with empty attribute list");
+                if (minIntervalFloorSeconds < 0)
+                    throw new Error("minIntervalFloorSeconds should be greater or equal to 0");
+                if (maxIntervalCeilingSeconds < 0)
+                    throw new Error("maxIntervalCeilingSeconds should be greater or equal to 1");
+                if (maxIntervalCeilingSeconds < minIntervalFloorSeconds)
+                    throw new Error("maxIntervalCeilingSeconds should be greater or equal to minIntervalFloorSeconds");
+                const attributes = this.getAttributes(attributeRequests);
+                if (!attributes.length) {
+                    throw new StatusResponseError("Attributes not found", 134 /* StatusCode.UnsupportedAttribute */);
+                }
+                // TODO: Interpret specs:
+                // The publisher SHALL compute an appropriate value for the MaxInterval field in the action. This SHALL respect the following constraint: MinIntervalFloor ≤ MaxInterval ≤ MAX(SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT=60mn, MaxIntervalCeiling)
+                if (this.nextSubscriptionId === 0xFFFFFFFF)
+                    this.nextSubscriptionId = 0;
+                const subscriptionId = this.nextSubscriptionId++;
+                const subscriptionHandler = new SubscriptionHandler(subscriptionId, session.getContext(), fabric, session.getPeerNodeId(), attributes, minIntervalFloorSeconds, maxIntervalCeilingSeconds);
+                session.addSubscription(subscriptionHandler);
+                // Send initial data report to prime the subscription with initial data
+                yield subscriptionHandler.sendInitialReport(messenger, session);
+                const maxInterval = subscriptionHandler.getMaxInterval();
+                logger.info(`Created subscription ${subscriptionId} for Session ${session.getId()} with ${attributes.length} attributes. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${maxInterval} seconds`);
+                // Then send the subscription response
+                yield messenger.send(4 /* MessageType.SubscribeResponse */, TlvSubscribeResponse.encode({ subscriptionId, maxInterval, interactionModelRevision: 1 }));
+                subscriptionHandler.activateSendingUpdates();
+            }
+        });
+    }
+    handleInvokeRequest(exchange, { invokeRequests }, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(`Received invoke request from ${exchange.channel.getName()}: ${invokeRequests.map(({ commandPath: { endpointId, clusterId, commandId } }) => `${toHex(endpointId)}/${toHex(clusterId)}/${toHex(commandId)}`).join(", ")}`);
+            const results = new Array();
+            yield Promise.all(invokeRequests.map(({ commandPath, commandFields }) => __awaiter(this, void 0, void 0, function* () {
+                if (commandPath.endpointId === undefined) {
+                    logger.error("Wildcard command invokes not yet supported!");
+                    results.push({ code: 129 /* StatusCode.UnsupportedCommand */, commandPath, response: TlvVoid.encodeTlv(), responseId: 0 });
+                    return;
+                }
+                const command = this.commands.get(commandPathToId(commandPath));
+                if (command === undefined)
+                    return;
+                // If no arguments are provided in the invoke data (because optional field), we use our type as replacement
+                if (commandFields === undefined) {
+                    commandFields = TlvNoArguments.encodeTlv(commandFields);
+                }
+                const result = yield command.invoke(exchange.session, commandFields, message);
+                results.push(Object.assign(Object.assign({}, result), { commandPath }));
+            })));
+            return {
+                suppressResponse: false,
+                interactionModelRevision: 1,
+                invokeResponses: results.map(({ commandPath, responseId, code, response }) => {
+                    if (response.length === 0) {
+                        return { status: { commandPath, status: { status: code } } };
+                    }
+                    else {
+                        return { command: { commandPath: Object.assign(Object.assign({}, commandPath), { commandId: responseId }), commandFields: response } };
+                    }
+                }),
+            };
+        });
+    }
+    handleTimedRequest(exchange, { timeout }) {
+        logger.debug(`Received timed request (${timeout}) from ${exchange.channel.getName()}`);
+        // TODO: implement this
+    }
+    resolveAttributeName({ endpointId, clusterId, attributeId }) {
+        var _a;
+        if (endpointId === undefined) {
+            return `*/${toHex(clusterId)}/${toHex(attributeId)}`;
+        }
+        const endpoint = this.endpoints.get(endpointId);
+        if (endpoint === undefined) {
+            return `unknown(${toHex(endpointId)})/${toHex(clusterId)}/${toHex(attributeId)}`;
+        }
+        const endpointName = `${endpoint.name}(${toHex(endpointId)})`;
+        if (clusterId === undefined) {
+            return `${endpointName}/*/${toHex(attributeId)}`;
+        }
+        const cluster = endpoint.clusters.get(clusterId);
+        if (cluster === undefined) {
+            return `${endpointName}/unknown(${toHex(clusterId)})/${toHex(attributeId)}`;
+        }
+        const clusterName = `${cluster.name}(${toHex(clusterId)})`;
+        if (attributeId === undefined) {
+            return `${endpointName}/${clusterName}/*`;
+        }
+        const attribute = this.attributes.get(attributePathToId({ endpointId, clusterId, attributeId }));
+        const attributeName = `${(_a = attribute === null || attribute === void 0 ? void 0 : attribute.name) !== null && _a !== void 0 ? _a : "unknown"}(${toHex(attributeId)})`;
+        return `${endpointName}/${clusterName}/${attributeName}`;
+    }
+    getAttributes(filters, onlyWritable = false) {
+        const result = new Array();
+        filters.forEach(({ endpointId, clusterId, attributeId }) => {
+            if (endpointId !== undefined && clusterId !== undefined && attributeId !== undefined) {
+                const path = { endpointId, clusterId, attributeId };
+                const attribute = this.attributes.get(attributePathToId(path));
+                if (attribute === undefined)
+                    return;
+                if (onlyWritable && !attribute.isWritable)
+                    return;
+                result.push({ path, attribute });
+            }
+            else {
+                this.attributePaths.filter(path => (endpointId === undefined || endpointId === path.endpointId)
+                    && (clusterId === undefined || clusterId === path.clusterId)
+                    && (attributeId === undefined || attributeId === path.attributeId))
+                    .forEach(path => {
+                    const attribute = this.attributes.get(attributePathToId(path));
+                    if (attribute === undefined)
+                        return;
+                    if (onlyWritable && !attribute.isWritable)
+                        return;
+                    result.push({ path, attribute });
+                });
+            }
+        });
+        return result;
+    }
+}

package/dist/es/protocol/interaction/SubscriptionHandler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterDevice } from "../../MatterDevice.js";
+import { InteractionServerMessenger } from "./InteractionMessenger.js";
+import { Fabric } from "../../fabric/Fabric.js";
+import { AttributeWithPath } from "./InteractionServer.js";
+import { NodeId } from "../../datatype/NodeId.js";
+import { TlvAttributePath } from "./InteractionProtocol.js";
+import { SecureSession } from "../../session/SecureSession.js";
+import { TlvSchema, TypeFromSchema } from "../../tlv/TlvSchema.js";
+export declare class SubscriptionHandler {
+    readonly subscriptionId: number;
+    private readonly server;
+    private readonly fabric;
+    private readonly peerNodeId;
+    private readonly attributes;
+    private lastUpdateTimeMs;
+    private updateTimer;
+    private outstandingAttributeUpdates;
+    private attributeListeners;
+    private sendUpdatesActivated;
+    private readonly maxInterval;
+    private readonly sendInterval;
+    private readonly minIntervalFloorMs;
+    private readonly maxIntervalCeilingMs;
+    constructor(subscriptionId: number, server: MatterDevice, fabric: Fabric, peerNodeId: NodeId, attributes: AttributeWithPath[], minIntervalFloor: number, maxIntervalCeiling: number);
+    getMaxInterval(): number;
+    activateSendingUpdates(): void;
+    sendUpdate(): Promise<void>;
+    sendInitialReport(messenger: InteractionServerMessenger, session: SecureSession<MatterDevice>): Promise<void>;
+    attributeChangeListener(path: TypeFromSchema<typeof TlvAttributePath>, schema: TlvSchema<any>, version: number, value: any): void;
+    cancel(): void;
+    private sendUpdateMessage;
+}
+//# sourceMappingURL=SubscriptionHandler.d.ts.map

package/dist/es/protocol/interaction/SubscriptionHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionHandler.d.ts","sourceRoot":"","sources":["../../../../src/protocol/interaction/SubscriptionHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAuB,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAA8C,MAAM,wBAAwB,CAAC;AAGvG,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAc,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAExE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAmBnE,qBAAa,mBAAmB;IAYxB,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAf/B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,2BAA2B,CAA4C;IAC/E,OAAO,CAAC,kBAAkB,CAA4D;IACtF,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;gBAGjC,cAAc,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,EAAE,EAChD,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,MAAM;IAsB9B,cAAc,IAAI,MAAM;IAIxB,sBAAsB;IAShB,UAAU;IA0BV,iBAAiB,CAAC,SAAS,EAAE,0BAA0B,EAAE,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC;IAuBnG,uBAAuB,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAK1H,MAAM;YAaQ,iBAAiB;CAmClC"}

package/dist/es/protocol/interaction/SubscriptionHandler.js

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { InteractionServerMessenger, StatusResponseError } from "./InteractionMessenger.js";
+import { INTERACTION_PROTOCOL_ID, attributePathToId } from "./InteractionServer.js";
+import { Logger } from "../../log/Logger.js";
+import { Time } from "../../time/Time.js";
+import { tryCatchAsync } from "../../common/TryCatchHandler.js";
+const logger = Logger.get("SubscriptionHandler");
+// We use 3 minutes as global max interval because with 60mins as defined by spec the timeframe
+// until the controller establishs a new subscription after e.g a reboot can be up to 60 mins
+// and the controller would assume that the value is unchanged. this is too long.
+// chip-tool is not respecting the 60mins at all and only respects the max sent by the controller
+// which can lead to spamming the network with unneeded packages. So I decided for 3 minutes for now
+// as a compromise until we have something better.
+const SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT_MS = 3 * 60 * 1000; /** 3 mins */ // Officially: 1000 * 60 * 60; /** 1 hour */
+export class SubscriptionHandler {
+    constructor(subscriptionId, server, fabric, peerNodeId, attributes, minIntervalFloor, maxIntervalCeiling) {
+        this.subscriptionId = subscriptionId;
+        this.server = server;
+        this.fabric = fabric;
+        this.peerNodeId = peerNodeId;
+        this.attributes = attributes;
+        this.lastUpdateTimeMs = 0;
+        this.outstandingAttributeUpdates = new Map();
+        this.attributeListeners = new Map();
+        this.sendUpdatesActivated = false;
+        this.minIntervalFloorMs = minIntervalFloor * 1000;
+        this.maxIntervalCeilingMs = maxIntervalCeiling * 1000;
+        // The final Max interval needs to be between min-floor and the MAX of max-ceiling and the defined publisher
+        // maximum of 60 minutes - this is to ensure that the publisher is not flooded with updates. But spec also
+        // says that it should be more frequent than the max interval.
+        // So let's calculate a maximum in the second half of the range between the two, but then already send at
+        // half of that time (so ideally we have 2 updates per max interval, so one could fail, and we still are good).
+        const halfMaxIntervalCeilingMs = (Math.max(SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT_MS, this.maxIntervalCeilingMs) - this.minIntervalFloorMs) / 2;
+        this.maxInterval = Math.floor(this.minIntervalFloorMs + halfMaxIntervalCeilingMs + halfMaxIntervalCeilingMs * Math.random());
+        this.sendInterval = Math.floor(this.maxInterval / 2);
+        this.updateTimer = Time.getTimer(this.sendInterval, () => this.sendUpdate()); // will be started later
+        attributes.forEach(({ path, attribute }) => {
+            // TODO: handle attributes with "getter" methods
+            const listener = (value, version) => this.attributeChangeListener(path, attribute.schema, version, value);
+            this.attributeListeners.set(attributePathToId(path), listener);
+            attribute.addMatterListener(listener);
+        });
+    }
+    getMaxInterval() {
+        return Math.ceil(this.maxInterval / 1000);
+    }
+    activateSendingUpdates() {
+        this.sendUpdatesActivated = true;
+        if (this.outstandingAttributeUpdates.size > 0) {
+            void this.sendUpdate();
+        }
+        else {
+            this.updateTimer = Time.getTimer(this.sendInterval, () => this.sendUpdate()).start();
+        }
+    }
+    sendUpdate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.updateTimer.stop();
+            const now = Time.nowMs();
+            const timeSinceLastUpdateMs = now - this.lastUpdateTimeMs;
+            if (timeSinceLastUpdateMs < this.minIntervalFloorMs) {
+                this.updateTimer = Time.getTimer(this.minIntervalFloorMs - timeSinceLastUpdateMs, () => this.sendUpdate()).start();
+                return;
+            }
+            if (!this.sendUpdatesActivated) {
+                return;
+            }
+            const updatesToSend = Array.from(this.outstandingAttributeUpdates.values());
+            this.outstandingAttributeUpdates.clear();
+            this.lastUpdateTimeMs = now;
+            try {
+                yield this.sendUpdateMessage(updatesToSend);
+            }
+            catch (error) {
+                // TODO: Add maybe a counter and cancel subscription update sending after a certain number of errors?
+                logger.error("Error sending subscription update message", error);
+            }
+            this.updateTimer = Time.getTimer(this.sendInterval, () => this.sendUpdate()).start();
+        });
+    }
+    sendInitialReport(messenger, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.updateTimer.stop();
+            const values = this.attributes.map(({ path, attribute }) => {
+                const { value, version } = attribute.getWithVersion(session);
+                return { path, value, version, schema: attribute.schema };
+            }).filter(({ value }) => value !== undefined);
+            this.lastUpdateTimeMs = Time.nowMs();
+            yield messenger.sendDataReport({
+                suppressResponse: false,
+                subscriptionId: this.subscriptionId,
+                interactionModelRevision: 1,
+                attributeReports: values.map(({ path, schema, value, version }) => ({
+                    attributeData: {
+                        path,
+                        dataVersion: version,
+                        data: schema.encodeTlv(value),
+                    },
+                })),
+            });
+        });
+    }
+    attributeChangeListener(path, schema, version, value) {
+        this.outstandingAttributeUpdates.set(attributePathToId(path), { path, schema, version, value });
+        void this.sendUpdate();
+    }
+    cancel() {
+        this.sendUpdatesActivated = false;
+        this.attributes.forEach(({ path, attribute }) => {
+            const pathId = attributePathToId(path);
+            const listener = this.attributeListeners.get(pathId);
+            if (listener !== undefined) {
+                attribute.removeMatterListener(listener);
+            }
+            this.attributeListeners.delete(pathId);
+        });
+        this.updateTimer.stop();
+    }
+    sendUpdateMessage(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(`Sending subscription update message for ID ${this.subscriptionId} with ${values.length} values`);
+            const exchange = this.server.initiateExchange(this.fabric, this.peerNodeId, INTERACTION_PROTOCOL_ID);
+            if (exchange === undefined)
+                return;
+            logger.debug(`Sending subscription changes for ID ${this.subscriptionId}: ${Logger.toJSON(values)}`);
+            const messenger = new InteractionServerMessenger(exchange);
+            try {
+                yield tryCatchAsync(() => __awaiter(this, void 0, void 0, function* () {
+                    yield messenger.sendDataReport({
+                        suppressResponse: !values.length,
+                        subscriptionId: this.subscriptionId,
+                        interactionModelRevision: 1,
+                        attributeReports: values.map(({ path, schema, value, version }) => ({
+                            attributeData: {
+                                path,
+                                dataVersion: version,
+                                data: schema.encodeTlv(value),
+                            },
+                        })),
+                    });
+                }), StatusResponseError, (error) => {
+                    if (error.code === 125 /* StatusCode.InvalidSubscription */ ||
+                        error.code === 1 /* StatusCode.Failure */) {
+                        logger.info(`Subscription ${this.subscriptionId} cancelled by peer.`);
+                        this.cancel();
+                    }
+                    else {
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                messenger.close();
+            }
+        });
+    }
+}