@project-chip/matter.js 0.2.1 → 0.3.0

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

@@ -0,0 +1,290 @@
+/**
+ * @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 { Logger } from "../../log/Logger.js";
+import { tryCatchAsync } from "../../common/TryCatchHandler.js";
+import { MatterError } from "../../common/MatterError.js";
+import { UnexpectedMessageError, RetransmissionLimitReachedError } from "../../protocol/MessageExchange.js";
+import { TlvAttributeReport, TlvDataReport, TlvInvokeRequest, TlvInvokeResponse, TlvReadRequest, TlvStatusResponse, TlvSubscribeRequest, TlvSubscribeResponse, TlvTimedRequest, TlvWriteRequest, TlvWriteResponse } from "./InteractionProtocol.js";
+/** Error base Class for all errors related to the status response messages. */
+export class StatusResponseError extends MatterError {
+    constructor(message, code) {
+        super();
+        this.code = code;
+        this.message = `(${code}) ${message}`;
+    }
+}
+const MAX_SPDU_LENGTH = 1024;
+const logger = Logger.get("InteractionMessenger");
+class InteractionMessenger {
+    constructor(exchange) {
+        this.exchange = exchange;
+    }
+    send(messageType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.exchange.send(messageType, payload);
+        });
+    }
+    sendStatus(status) {
+        return this.send(1 /* MessageType.StatusResponse */, TlvStatusResponse.encode({ status, interactionModelRevision: 1 }));
+    }
+    waitForSuccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If the status is not Success, this would throw an Error.
+            yield this.nextMessage(1 /* MessageType.StatusResponse */);
+        });
+    }
+    nextMessage(expectedMessageType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = yield this.exchange.nextMessage();
+            const messageType = message.payloadHeader.messageType;
+            this.throwIfErrorStatusMessage(message);
+            if (expectedMessageType !== undefined && messageType !== expectedMessageType)
+                throw new Error(`Received unexpected message type: ${messageType}, expected: ${expectedMessageType}`);
+            return message;
+        });
+    }
+    close() {
+        this.exchange.close();
+    }
+    throwIfErrorStatusMessage(message) {
+        const { payloadHeader: { messageType }, payload } = message;
+        if (messageType !== 1 /* MessageType.StatusResponse */)
+            return;
+        const { status } = TlvStatusResponse.decode(payload);
+        if (status !== 0 /* StatusCode.Success */)
+            throw new StatusResponseError(`Received error status: ${status}`, status);
+    }
+}
+export class InteractionServerMessenger extends InteractionMessenger {
+    handleRequest(handleReadRequest, handleWriteRequest, handleSubscribeRequest, handleInvokeRequest, handleTimedRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let continueExchange = true;
+            try {
+                while (continueExchange) {
+                    const message = yield this.exchange.nextMessage();
+                    continueExchange = false;
+                    switch (message.payloadHeader.messageType) {
+                        case 2 /* MessageType.ReadRequest */: {
+                            const readRequest = TlvReadRequest.decode(message.payload);
+                            yield this.sendDataReport(handleReadRequest(readRequest));
+                            break;
+                        }
+                        case 6 /* MessageType.WriteRequest */: {
+                            const writeRequest = TlvWriteRequest.decode(message.payload);
+                            const writeResponse = handleWriteRequest(writeRequest);
+                            yield this.send(7 /* MessageType.WriteResponse */, TlvWriteResponse.encode(writeResponse));
+                            break;
+                        }
+                        case 3 /* MessageType.SubscribeRequest */: {
+                            const subscribeRequest = TlvSubscribeRequest.decode(message.payload);
+                            yield handleSubscribeRequest(subscribeRequest, this);
+                            // response is sent by handler
+                            break;
+                        }
+                        case 8 /* MessageType.InvokeCommandRequest */: {
+                            const invokeRequest = TlvInvokeRequest.decode(message.payload);
+                            const invokeResponse = yield handleInvokeRequest(invokeRequest, message);
+                            yield this.send(9 /* MessageType.InvokeCommandResponse */, TlvInvokeResponse.encode(invokeResponse));
+                            break;
+                        }
+                        case 10 /* MessageType.TimedRequest */: {
+                            const timedRequest = TlvTimedRequest.decode(message.payload);
+                            handleTimedRequest(timedRequest);
+                            yield this.sendStatus(0 /* StatusCode.Success */);
+                            continueExchange = true;
+                            break;
+                        }
+                        default:
+                            throw new Error(`Unsupported message type ${message.payloadHeader.messageType}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof StatusResponseError) {
+                    logger.info(`Sending status response ${error.code} for interaction error: ${error}`);
+                    yield this.sendStatus(error.code);
+                }
+                else {
+                    logger.error(error);
+                    yield this.sendStatus(1 /* StatusCode.Failure */);
+                }
+            }
+            finally {
+                this.exchange.close();
+            }
+        });
+    }
+    sendDataReport(dataReport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messageBytes = TlvDataReport.encode(dataReport);
+            if (!Array.isArray(dataReport.attributeReports)) {
+                throw new Error(`DataReport.values must be an array, got: ${dataReport.attributeReports}`);
+            }
+            if (messageBytes.length > MAX_SPDU_LENGTH) {
+                // DataReport is too long, it needs to be sent in chunks
+                const attributeReportsToSend = [...dataReport.attributeReports];
+                dataReport.attributeReports.length = 0;
+                dataReport.moreChunkedMessages = true;
+                const emptyDataReportBytes = TlvDataReport.encode(dataReport);
+                let messageSize = emptyDataReportBytes.length;
+                while (true) {
+                    const attributeReport = attributeReportsToSend.pop();
+                    if (attributeReport === undefined) {
+                        // No more chunks to send
+                        dataReport.moreChunkedMessages = undefined;
+                        break;
+                    }
+                    const attributeReportBytes = TlvAttributeReport.encode(attributeReport).length;
+                    if (messageSize + attributeReportBytes > MAX_SPDU_LENGTH) {
+                        if (messageSize === emptyDataReportBytes.length) {
+                            throw new Error(`Attribute report for is too long to fit in a single chunk, Array chunking not yet supported`);
+                        }
+                        // Report doesn't fit, sending this chunk
+                        yield this.send(5 /* MessageType.ReportData */, TlvDataReport.encode(dataReport));
+                        yield this.waitForSuccess();
+                        dataReport.attributeReports.length = 0;
+                        messageSize = emptyDataReportBytes.length;
+                    }
+                    messageSize += attributeReportBytes;
+                    dataReport.attributeReports.push(attributeReport);
+                }
+            }
+            if (dataReport.suppressResponse) {
+                // We do not expect a response other than a Standalone Ack, so if we receive anything else, we throw an error
+                yield tryCatchAsync(() => __awaiter(this, void 0, void 0, function* () { return yield this.exchange.send(5 /* MessageType.ReportData */, TlvDataReport.encode(dataReport), true); }), UnexpectedMessageError, error => {
+                    const { receivedMessage } = error;
+                    this.throwIfErrorStatusMessage(receivedMessage);
+                });
+            }
+            else {
+                yield this.exchange.send(5 /* MessageType.ReportData */, TlvDataReport.encode(dataReport));
+                yield this.waitForSuccess();
+            }
+        });
+    }
+}
+export class IncomingInteractionClientMessenger extends InteractionMessenger {
+    readDataReport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let subscriptionId;
+            const values = [];
+            while (true) {
+                const dataReportMessage = yield this.exchange.waitFor(5 /* MessageType.ReportData */);
+                const report = TlvDataReport.decode(dataReportMessage.payload);
+                if (subscriptionId === undefined && report.subscriptionId !== undefined) {
+                    subscriptionId = report.subscriptionId;
+                }
+                else if ((subscriptionId !== undefined || report.subscriptionId !== undefined) && report.subscriptionId !== subscriptionId) {
+                    throw new Error(`Invalid subscription ID ${report.subscriptionId} received`);
+                }
+                if (Array.isArray(report.attributeReports) && report.attributeReports.length > 0) {
+                    values.push(...report.attributeReports);
+                }
+                if (!report.moreChunkedMessages) {
+                    report.attributeReports = values;
+                    return report;
+                }
+                yield this.sendStatus(0 /* StatusCode.Success */);
+            }
+        });
+    }
+}
+export class InteractionClientMessenger extends IncomingInteractionClientMessenger {
+    constructor(exchangeProvider) {
+        super(exchangeProvider.initiateExchange());
+        this.exchangeProvider = exchangeProvider;
+    }
+    /** Implements a send method with an automatic reconnection mechanism */
+    send(messageType, payload, expectAckOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.exchange.send(messageType, payload, expectAckOnly);
+            }
+            catch (error) {
+                // When retransmission failed (most likely due to a lost connection or invalid session),
+                // try to reconnect if possible and resend the message once
+                if (error instanceof RetransmissionLimitReachedError) {
+                    this.exchange.close();
+                    if (yield this.exchangeProvider.reconnectChannel()) {
+                        this.exchange = this.exchangeProvider.initiateExchange();
+                        return yield this.exchange.send(messageType, payload);
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    sendReadRequest(readRequest) {
+        return this.request(2 /* MessageType.ReadRequest */, TlvReadRequest, 5 /* MessageType.ReportData */, TlvDataReport, readRequest);
+    }
+    sendSubscribeRequest(subscribeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(3 /* MessageType.SubscribeRequest */, TlvSubscribeRequest.encode(subscribeRequest));
+            const report = yield this.readDataReport();
+            const { subscriptionId } = report;
+            if (subscriptionId === undefined) {
+                throw new Error(`Subscription ID not provided in report`);
+            }
+            yield this.sendStatus(0 /* StatusCode.Success */);
+            const subscribeResponseMessage = yield this.nextMessage(4 /* MessageType.SubscribeResponse */);
+            const subscribeResponse = TlvSubscribeResponse.decode(subscribeResponseMessage.payload);
+            if (subscribeResponse.subscriptionId !== subscriptionId) {
+                throw new Error(`Received subscription ID ${subscribeResponse.subscriptionId} instead of ${subscriptionId}`);
+            }
+            return {
+                subscribeResponse,
+                report,
+            };
+        });
+    }
+    sendInvokeCommand(invokeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (invokeRequest.suppressResponse) {
+                yield this.requestWithSuppressedResponse(8 /* MessageType.InvokeCommandRequest */, TlvInvokeRequest, invokeRequest);
+            }
+            else {
+                return yield this.request(8 /* MessageType.InvokeCommandRequest */, TlvInvokeRequest, 9 /* MessageType.InvokeCommandResponse */, TlvInvokeResponse, invokeRequest);
+            }
+        });
+    }
+    sendWriteCommand(writeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (writeRequest.suppressResponse) {
+                yield this.requestWithSuppressedResponse(6 /* MessageType.WriteRequest */, TlvWriteRequest, writeRequest);
+            }
+            else {
+                return yield this.request(6 /* MessageType.WriteRequest */, TlvWriteRequest, 7 /* MessageType.WriteResponse */, TlvWriteResponse, writeRequest);
+            }
+        });
+    }
+    sendTimedRequest(timeoutSeconds) {
+        return this.request(10 /* MessageType.TimedRequest */, TlvTimedRequest, 1 /* MessageType.StatusResponse */, TlvStatusResponse, {
+            timeout: timeoutSeconds,
+            interactionModelRevision: 1
+        });
+    }
+    requestWithSuppressedResponse(requestMessageType, requestSchema, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(requestMessageType, requestSchema.encode(request), true);
+        });
+    }
+    request(requestMessageType, requestSchema, responseMessageType, responseSchema, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send(requestMessageType, requestSchema.encode(request));
+            const responseMessage = yield this.nextMessage(responseMessageType);
+            return responseSchema.decode(responseMessage.payload);
+        });
+    }
+}