From 7dcffa339093d2306dbe20abfef5ff2bebfa9d80 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Tue, 14 May 2024 19:15:42 +0800 Subject: [PATCH 1/4] Initialize thread border router management xml template file and run zap_generate_all.py --- .github/workflows/tests.yaml | 1 + docs/zap_clusters.md | 1 + scripts/rules.matterlint | 1 + src/app/common/templates/config-data.yaml | 1 + src/app/zap-templates/zcl/data-model/all.xml | 1 + .../zcl/data-model/chip/matter-devices.xml | 15 + ...hread-border-router-management-cluster.xml | 140 ++ .../zcl/zcl-with-test-extensions.json | 10 + src/app/zap-templates/zcl/zcl.json | 10 + src/app/zap_cluster_list.json | 2 + .../data_model/controller-clusters.matter | 100 ++ .../data_model/controller-clusters.zap | 100 ++ .../chip/devicecontroller/ChipClusters.java | 526 ++++++ .../chip/devicecontroller/ChipStructs.java | 409 +++++ .../devicecontroller/ClusterIDMapping.java | 165 ++ .../devicecontroller/ClusterInfoMapping.java | 279 ++++ .../devicecontroller/ClusterReadMapping.java | 126 ++ .../devicecontroller/ClusterWriteMapping.java | 2 + .../chip/devicecontroller/cluster/files.gni | 4 + ...RouterManagementClusterChildTableStruct.kt | 67 + ...outerManagementClusterNeiborTableStruct.kt | 109 ++ ...RouterManagementClusterRouteTableStruct.kt | 72 + ...RouterManagementClusterThreadNodeStruct.kt | 127 ++ .../ThreadBorderRouterManagementCluster.kt | 1413 ++++++++++++++++ .../java/matter/controller/cluster/files.gni | 5 + ...RouterManagementClusterChildTableStruct.kt | 67 + ...outerManagementClusterNeiborTableStruct.kt | 109 ++ ...RouterManagementClusterRouteTableStruct.kt | 72 + ...RouterManagementClusterThreadNodeStruct.kt | 127 ++ .../CHIPAttributeTLVValueDecoder.cpp | 408 +++++ .../CHIPEventTLVValueDecoder.cpp | 10 + .../python/chip/clusters/CHIPClusters.py | 118 ++ .../python/chip/clusters/Objects.py | 442 +++++ .../python/chip/clusters/__init__.py | 6 +- .../MTRAttributeSpecifiedCheck.mm | 48 + .../MTRAttributeTLVValueDecoder.mm | 148 ++ .../CHIP/zap-generated/MTRBaseClusters.h | 146 ++ .../CHIP/zap-generated/MTRBaseClusters.mm | 565 +++++++ .../CHIP/zap-generated/MTRClusterConstants.h | 24 + .../CHIP/zap-generated/MTRClusterNames.mm | 61 + .../CHIP/zap-generated/MTRClusters.h | 58 + .../CHIP/zap-generated/MTRClusters.mm | 207 +++ .../zap-generated/MTRCommandPayloadsObjc.h | 196 +++ .../zap-generated/MTRCommandPayloadsObjc.mm | 646 ++++++++ .../MTRCommandPayloads_Internal.h | 42 + .../zap-generated/MTRCommandTimedCheck.mm | 12 + .../zap-generated/MTRDeviceTypeMetadata.mm | 1 + .../zap-generated/MTREventTLVValueDecoder.mm | 15 + .../CHIP/zap-generated/MTRStructsObjc.h | 35 + .../CHIP/zap-generated/MTRStructsObjc.mm | 153 ++ .../zap-generated/attributes/Accessors.cpp | 53 + .../zap-generated/attributes/Accessors.h | 12 + .../app-common/zap-generated/callback.h | 44 + .../zap-generated/cluster-enums-check.h | 18 + .../app-common/zap-generated/cluster-enums.h | 26 + .../zap-generated/cluster-objects.cpp | 511 ++++++ .../zap-generated/cluster-objects.h | 543 +++++++ .../app-common/zap-generated/ids/Attributes.h | 54 + .../app-common/zap-generated/ids/Clusters.h | 3 + .../app-common/zap-generated/ids/Commands.h | 34 + .../zap-generated/cluster/Commands.h | 310 ++++ .../cluster/ComplexArgumentParser.cpp | 202 +++ .../cluster/ComplexArgumentParser.h | 24 + .../cluster/logging/DataModelLogger.cpp | 293 ++++ .../cluster/logging/DataModelLogger.h | 22 + .../zap-generated/cluster/Commands.h | 1419 +++++++++++++++++ 66 files changed, 10967 insertions(+), 3 deletions(-) create mode 100644 src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadBorderRouterManagementCluster.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 57bc3971d44ea3..8c328c60b7c4b5 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -180,6 +180,7 @@ jobs: src/app/zap-templates/zcl/data-model/chip/test-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/thermostat-user-interface-configuration-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/thread-network-diagnostics-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/time-format-localization-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml \ diff --git a/docs/zap_clusters.md b/docs/zap_clusters.md index eedfb7190e2f27..777b31b8a028dd 100644 --- a/docs/zap_clusters.md +++ b/docs/zap_clusters.md @@ -112,6 +112,7 @@ Generally regenerate using one of: | 1069 | 0x42D | Pm10ConcentrationMeasurement | | 1070 | 0x42E | TotalVolatileOrganicCompoundsConcentrationMeasurement | | 1071 | 0x42F | RadonConcentrationMeasurement | +| 1106 | 0x452 | ThreadBorderRouterManagement | | 1283 | 0x503 | WakeOnLan | | 1284 | 0x504 | Channel | | 1285 | 0x505 | TargetNavigator | diff --git a/scripts/rules.matterlint b/scripts/rules.matterlint index e876bae22094c6..6a1654de8b5901 100644 --- a/scripts/rules.matterlint +++ b/scripts/rules.matterlint @@ -88,6 +88,7 @@ load "../src/app/zap-templates/zcl/data-model/chip/temperature-measurement-clust load "../src/app/zap-templates/zcl/data-model/chip/test-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/thermostat-user-interface-configuration-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml"; +load "../src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/thread-network-diagnostics-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/time-format-localization-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml"; diff --git a/src/app/common/templates/config-data.yaml b/src/app/common/templates/config-data.yaml index 875cdbcdbd1514..b208c6c33388c8 100644 --- a/src/app/common/templates/config-data.yaml +++ b/src/app/common/templates/config-data.yaml @@ -40,6 +40,7 @@ CommandHandlerInterfaceOnlyClusters: - Device Energy Management Mode - Electrical Power Measurement - Electrical Energy Measurement + - Thread Border Router Management # We need a more configurable way of deciding which clusters have which init functions.... # See https://github.com/project-chip/connectedhomeip/issues/4369 diff --git a/src/app/zap-templates/zcl/data-model/all.xml b/src/app/zap-templates/zcl/data-model/all.xml index 86d2085718291d..93cfb9e292d1cc 100644 --- a/src/app/zap-templates/zcl/data-model/all.xml +++ b/src/app/zap-templates/zcl/data-model/all.xml @@ -93,6 +93,7 @@ + diff --git a/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml b/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml index 795f7a71cf54bc..1161f84b7afa90 100644 --- a/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml +++ b/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml @@ -2427,6 +2427,21 @@ limitations under the License. + + MA-thread-border-router + HRAP + Matter Thread Border Router + 0x0103 + 0xFFF10011 + Simple + Endpoint + + + + + + + MA-all-clusters-app CHIP diff --git a/src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml new file mode 100644 index 00000000000000..fbbd6060fc3176 --- /dev/null +++ b/src/app/zap-templates/zcl/data-model/chip/thread-border-router-management-cluster.xml @@ -0,0 +1,140 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HRAP + Thread Border Router Management + 0x0452 + THREAD_BORDER_ROUTER_MANAGEMENT + true + true + Thread BR management + + + + BorderRouterName + + BorderAgentId + + ThreadVersion + + InterfaceEnabled + + ThreadNode + + ActiveDatasetTimestamp + + + + On receipt of this command, the Thread Border Router will read the active operational dataset of the Thread network that it is connaected to, and send the DatasetResponse as the response. This command must be sent over a valid CASE session + + + + + On receipt of this command, the Thread Border Router will read the pending dataset and send the DatasetResponse as the response. This command must be sent over a valid CASE session + + + + + Generated response to GetActiveDatasetRequest or GetPendingDatasetRequest commands + + + + + On receipt of this command, the Thread Border Router will set or update the active Dataset of the Thread network that the Stub Router is connected to. + + + + + + + On receipt of this command, the Thread Border Router will set or update the pending Dataset + + + + + + On receipt of this command, the Thread Border Router will response the current topology of the Thread network that it is connected to. + + + + + + + + Generated response to TopologyRequest command + + + + + + + + diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json index 7213b96cf0e012..60ff2cc43c310b 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -115,6 +115,7 @@ "test-cluster.xml", "thermostat-cluster.xml", "thermostat-user-interface-configuration-cluster.xml", + "thread-border-router-management-cluster.xml", "thread-network-diagnostics-cluster.xml", "time-format-localization-cluster.xml", "time-synchronization-cluster.xml", @@ -289,6 +290,15 @@ "general_error_boolean", "cluster_error_boolean" ], + "Thread Border Router Management": [ + "BorderRouterName", + "BorderAgentId", + "ThreadVersion", + "InterfaceEnabled", + "ThreadNode", + "ActiveDatasetTimestamp", + "FeatureMap" + ], "Thread Network Diagnostics": [ "Channel", "RoutingRole", diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index 8a4159e98f7eb8..e5c44b690f6ad9 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -113,6 +113,7 @@ "test-cluster.xml", "thermostat-cluster.xml", "thermostat-user-interface-configuration-cluster.xml", + "thread-border-router-management-cluster.xml", "thread-network-diagnostics-cluster.xml", "time-format-localization-cluster.xml", "time-synchronization-cluster.xml", @@ -287,6 +288,15 @@ "general_error_boolean", "cluster_error_boolean" ], + "Thread Border Router Management": [ + "BorderRouterName", + "BorderAgentId", + "ThreadVersion", + "InterfaceEnabled", + "ThreadNode", + "ActiveDatasetTimestamp", + "FeatureMap" + ], "Thread Network Diagnostics": [ "Channel", "RoutingRole", diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json index 2edfb272ad23e1..fb4c438bcb5d92 100644 --- a/src/app/zap_cluster_list.json +++ b/src/app/zap_cluster_list.json @@ -114,6 +114,7 @@ "TEMPERATURE_MEASUREMENT_CLUSTER": [], "THERMOSTAT_CLUSTER": ["thermostat-client"], "THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER": [], + "THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER": [], "THREAD_NETWORK_DIAGNOSTICS_CLUSTER": [], "TIME_CLUSTER": [], "TIME_FORMAT_LOCALIZATION_CLUSTER": [], @@ -286,6 +287,7 @@ "THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER": [ "thermostat-user-interface-configuration-server" ], + "THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER": [], "THREAD_NETWORK_DIAGNOSTICS_CLUSTER": [ "thread-network-diagnostics-server" ], diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index c559d1d0e9b129..222003cfc67f21 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -7654,6 +7654,106 @@ cluster RadonConcentrationMeasurement = 1071 { readonly attribute int16u clusterRevision = 65533; } +/** Thread BR management */ +cluster ThreadBorderRouterManagement = 1106 { + revision 1; + + enum RoutingRoleEnum : enum8 { + kUnspecified = 0; + kUnassigned = 1; + kSleepyEndDevice = 2; + kEndDevice = 3; + kREED = 4; + kRouter = 5; + kLeader = 6; + } + + bitmap Feature : bitmap32 { + kPANChange = 0x1; + } + + struct ChildTableStruct { + int16u rloc16 = 0; + int8u linkQuality = 1; + RoutingRoleEnum routingRole = 2; + } + + struct RouteTableStruct { + int8u routerId = 0; + int8u pathCost = 1; + int8u LQIIn = 2; + int8u LQIOut = 3; + } + + struct ThreadNodeStruct { + int64u extAddress = 0; + int16u rloc16 = 1; + octet_string IPv6s[] = 2; + RoutingRoleEnum routingRole = 3; + RouteTableStruct routeTable[] = 4; + ChildTableStruct childTable[] = 5; + } + + struct NeiborTableStruct { + int64u extAddress = 0; + int32u age = 1; + int16u rloc16 = 2; + nullable int8s averageRssi = 3; + nullable int8s lastRssi = 4; + RoutingRoleEnum routingRole = 5; + } + + readonly attribute char_string<63> borderRouterName = 0; + readonly attribute octet_string<16> borderAgentId = 1; + readonly attribute int16u threadVersion = 2; + readonly attribute boolean interfaceEnabled = 3; + readonly attribute ThreadNodeStruct threadNode = 4; + readonly attribute nullable int64u activeDatasetTimestamp = 5; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + response struct DatasetResponse = 2 { + octet_string<254> dataset = 0; + } + + request struct SetActiveDatasetRequestRequest { + octet_string<254> activeDataset = 0; + int64u breadcrumb = 1; + } + + request struct SetPendingDatasetRequestRequest { + octet_string<254> pendingDataset = 0; + } + + request struct TopologyRequestRequest { + int16u count = 0; + int16u startIndex = 1; + int8u snapshot = 2; + } + + response struct TopologyResponse = 6 { + status status = 0; + int8u snapshot = 1; + int16u numberOfDevices = 2; + ThreadNodeStruct threadTopology[] = 3; + } + + /** On receipt of this command, the Thread Border Router will read the active operational dataset of the Thread network that it is connaected to, and send the DatasetResponse as the response. This command must be sent over a valid CASE session */ + command access(invoke: manage) GetActiveDatasetRequest(): DatasetResponse = 0; + /** On receipt of this command, the Thread Border Router will read the pending dataset and send the DatasetResponse as the response. This command must be sent over a valid CASE session */ + command access(invoke: manage) GetPendingDatasetRequest(): DatasetResponse = 1; + /** On receipt of this command, the Thread Border Router will set or update the active Dataset of the Thread network that the Stub Router is connected to. */ + command access(invoke: manage) SetActiveDatasetRequest(SetActiveDatasetRequestRequest): DefaultSuccess = 3; + /** On receipt of this command, the Thread Border Router will set or update the pending Dataset */ + command access(invoke: manage) SetPendingDatasetRequest(SetPendingDatasetRequestRequest): DefaultSuccess = 4; + /** On receipt of this command, the Thread Border Router will response the current topology of the Thread network that it is connected to. */ + command access(invoke: administer) TopologyRequest(TopologyRequestRequest): TopologyResponse = 5; +} + /** This cluster provides an interface for managing low power mode on a device that supports the Wake On LAN protocol. */ cluster WakeOnLan = 1283 { revision 1; diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 66863228023a7b..f78b80e09cddf8 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -1180,6 +1180,106 @@ } ] }, + { + "name": "Thread Border Router Management", + "code": 1106, + "mfgCode": null, + "define": "THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER", + "side": "client", + "enabled": 1, + "commands": [ + { + "name": "GetActiveDatasetRequest", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "GetPendingDatasetRequest", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "DatasetResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "SetActiveDatasetRequest", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "SetPendingDatasetRequest", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "TopologyRequest", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "TopologyResponse", + "code": 6, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "2", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, { "name": "Thread Network Diagnostics", "code": 53, diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java index 2e64d37cd62b11..951ccf9a6b73c6 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java @@ -52829,6 +52829,532 @@ public void onSuccess(byte[] tlv) { } } + public static class ThreadBorderRouterManagementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1106L; + + private static final long BORDER_ROUTER_NAME_ATTRIBUTE_ID = 0L; + private static final long BORDER_AGENT_ID_ATTRIBUTE_ID = 1L; + private static final long THREAD_VERSION_ATTRIBUTE_ID = 2L; + private static final long INTERFACE_ENABLED_ATTRIBUTE_ID = 3L; + private static final long THREAD_NODE_ATTRIBUTE_ID = 4L; + private static final long ACTIVE_DATASET_TIMESTAMP_ATTRIBUTE_ID = 5L; + private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L; + private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L; + private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L; + private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L; + private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L; + private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L; + + public ThreadBorderRouterManagementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId, CLUSTER_ID); + } + + @Override + @Deprecated + public long initWithDevice(long devicePtr, int endpointId) { + return 0L; + } + + public void getActiveDatasetRequest(DatasetResponseCallback callback) { + getActiveDatasetRequest(callback, 0); + } + + public void getActiveDatasetRequest(DatasetResponseCallback callback, int timedInvokeTimeoutMs) { + final long commandId = 0L; + + ArrayList elements = new ArrayList<>(); + StructType commandArgs = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + final long datasetFieldID = 0L; + byte[] dataset = null; + for (StructElement element: invokeStructValue.value()) { + if (element.contextTagNum() == datasetFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + dataset = castingValue.value(byte[].class); + } + } + } + callback.onSuccess(dataset); + }}, commandId, commandArgs, timedInvokeTimeoutMs); + } + + public void getPendingDatasetRequest(DatasetResponseCallback callback) { + getPendingDatasetRequest(callback, 0); + } + + public void getPendingDatasetRequest(DatasetResponseCallback callback, int timedInvokeTimeoutMs) { + final long commandId = 1L; + + ArrayList elements = new ArrayList<>(); + StructType commandArgs = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + final long datasetFieldID = 0L; + byte[] dataset = null; + for (StructElement element: invokeStructValue.value()) { + if (element.contextTagNum() == datasetFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + dataset = castingValue.value(byte[].class); + } + } + } + callback.onSuccess(dataset); + }}, commandId, commandArgs, timedInvokeTimeoutMs); + } + + public void setActiveDatasetRequest(DefaultClusterCallback callback, byte[] activeDataset, Long breadcrumb) { + setActiveDatasetRequest(callback, activeDataset, breadcrumb, 0); + } + + public void setActiveDatasetRequest(DefaultClusterCallback callback, byte[] activeDataset, Long breadcrumb, int timedInvokeTimeoutMs) { + final long commandId = 3L; + + ArrayList elements = new ArrayList<>(); + final long activeDatasetFieldID = 0L; + BaseTLVType activeDatasettlvValue = new ByteArrayType(activeDataset); + elements.add(new StructElement(activeDatasetFieldID, activeDatasettlvValue)); + + final long breadcrumbFieldID = 1L; + BaseTLVType breadcrumbtlvValue = new UIntType(breadcrumb); + elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue)); + + StructType commandArgs = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, commandArgs, timedInvokeTimeoutMs); + } + + public void setPendingDatasetRequest(DefaultClusterCallback callback, byte[] pendingDataset) { + setPendingDatasetRequest(callback, pendingDataset, 0); + } + + public void setPendingDatasetRequest(DefaultClusterCallback callback, byte[] pendingDataset, int timedInvokeTimeoutMs) { + final long commandId = 4L; + + ArrayList elements = new ArrayList<>(); + final long pendingDatasetFieldID = 0L; + BaseTLVType pendingDatasettlvValue = new ByteArrayType(pendingDataset); + elements.add(new StructElement(pendingDatasetFieldID, pendingDatasettlvValue)); + + StructType commandArgs = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, commandArgs, timedInvokeTimeoutMs); + } + + public void topologyRequest(TopologyResponseCallback callback, Integer count, Integer startIndex, Integer snapshot) { + topologyRequest(callback, count, startIndex, snapshot, 0); + } + + public void topologyRequest(TopologyResponseCallback callback, Integer count, Integer startIndex, Integer snapshot, int timedInvokeTimeoutMs) { + final long commandId = 5L; + + ArrayList elements = new ArrayList<>(); + final long countFieldID = 0L; + BaseTLVType counttlvValue = new UIntType(count); + elements.add(new StructElement(countFieldID, counttlvValue)); + + final long startIndexFieldID = 1L; + BaseTLVType startIndextlvValue = new UIntType(startIndex); + elements.add(new StructElement(startIndexFieldID, startIndextlvValue)); + + final long snapshotFieldID = 2L; + BaseTLVType snapshottlvValue = new UIntType(snapshot); + elements.add(new StructElement(snapshotFieldID, snapshottlvValue)); + + StructType commandArgs = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + final long statusFieldID = 0L; + Integer status = null; + final long snapshotFieldID = 1L; + Integer snapshot = null; + final long numberOfDevicesFieldID = 2L; + Integer numberOfDevices = null; + final long threadTopologyFieldID = 3L; + ArrayList threadTopology = null; + for (StructElement element: invokeStructValue.value()) { + if (element.contextTagNum() == statusFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + status = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == snapshotFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + snapshot = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == numberOfDevicesFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + numberOfDevices = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == threadTopologyFieldID) { + if (element.value(BaseTLVType.class).type() == TLVType.Array) { + ArrayType castingValue = element.value(ArrayType.class); + threadTopology = castingValue.map((elementcastingValue) -> ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct.decodeTlv(elementcastingValue)); + } + } + } + callback.onSuccess(status, snapshot, numberOfDevices, threadTopology); + }}, commandId, commandArgs, timedInvokeTimeoutMs); + } + + public interface DatasetResponseCallback extends BaseClusterCallback { + void onSuccess(byte[] dataset); + } + + public interface TopologyResponseCallback extends BaseClusterCallback { + void onSuccess(Integer status, Integer snapshot, Integer numberOfDevices, ArrayList threadTopology); + } + + public interface ThreadNodeAttributeCallback extends BaseAttributeCallback { + void onSuccess(ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct value); + } + + public interface ActiveDatasetTimestampAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Long value); + } + + public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface EventListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AttributeListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public void readBorderRouterNameAttribute( + CharStringAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BORDER_ROUTER_NAME_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, BORDER_ROUTER_NAME_ATTRIBUTE_ID, true); + } + + public void subscribeBorderRouterNameAttribute( + CharStringAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BORDER_ROUTER_NAME_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, BORDER_ROUTER_NAME_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readBorderAgentIdAttribute( + OctetStringAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BORDER_AGENT_ID_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, BORDER_AGENT_ID_ATTRIBUTE_ID, true); + } + + public void subscribeBorderAgentIdAttribute( + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BORDER_AGENT_ID_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, BORDER_AGENT_ID_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readThreadVersionAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_VERSION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, THREAD_VERSION_ATTRIBUTE_ID, true); + } + + public void subscribeThreadVersionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_VERSION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, THREAD_VERSION_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readInterfaceEnabledAttribute( + BooleanAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERFACE_ENABLED_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, INTERFACE_ENABLED_ATTRIBUTE_ID, true); + } + + public void subscribeInterfaceEnabledAttribute( + BooleanAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERFACE_ENABLED_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, INTERFACE_ENABLED_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readThreadNodeAttribute( + ThreadNodeAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_NODE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, THREAD_NODE_ATTRIBUTE_ID, true); + } + + public void subscribeThreadNodeAttribute( + ThreadNodeAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_NODE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, THREAD_NODE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readActiveDatasetTimestampAttribute( + ActiveDatasetTimestampAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_DATASET_TIMESTAMP_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACTIVE_DATASET_TIMESTAMP_ATTRIBUTE_ID, true); + } + + public void subscribeActiveDatasetTimestampAttribute( + ActiveDatasetTimestampAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_DATASET_TIMESTAMP_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACTIVE_DATASET_TIMESTAMP_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, EVENT_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeEventListAttribute( + EventListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, FEATURE_MAP_ATTRIBUTE_ID, true); + } + + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, true); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval); + } + } + public static class WakeOnLanCluster extends BaseChipCluster { public static final long CLUSTER_ID = 1283L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java index 7730f05efe734a..4b452ae234f6fe 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java @@ -9277,6 +9277,415 @@ public String toString() { return output.toString(); } } +public static class ThreadBorderRouterManagementClusterChildTableStruct { + public Integer rloc16; + public Integer linkQuality; + public Integer routingRole; + private static final long RLOC16_ID = 0L; + private static final long LINK_QUALITY_ID = 1L; + private static final long ROUTING_ROLE_ID = 2L; + + public ThreadBorderRouterManagementClusterChildTableStruct( + Integer rloc16, + Integer linkQuality, + Integer routingRole + ) { + this.rloc16 = rloc16; + this.linkQuality = linkQuality; + this.routingRole = routingRole; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(RLOC16_ID, new UIntType(rloc16))); + values.add(new StructElement(LINK_QUALITY_ID, new UIntType(linkQuality))); + values.add(new StructElement(ROUTING_ROLE_ID, new UIntType(routingRole))); + + return new StructType(values); + } + + public static ThreadBorderRouterManagementClusterChildTableStruct decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer rloc16 = null; + Integer linkQuality = null; + Integer routingRole = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == RLOC16_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + rloc16 = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == LINK_QUALITY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + linkQuality = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == ROUTING_ROLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + routingRole = castingValue.value(Integer.class); + } + } + } + return new ThreadBorderRouterManagementClusterChildTableStruct( + rloc16, + linkQuality, + routingRole + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadBorderRouterManagementClusterChildTableStruct {\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkQuality: "); + output.append(linkQuality); + output.append("\n"); + output.append("\troutingRole: "); + output.append(routingRole); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThreadBorderRouterManagementClusterRouteTableStruct { + public Integer routerId; + public Integer pathCost; + public Integer LQIIn; + public Integer LQIOut; + private static final long ROUTER_ID_ID = 0L; + private static final long PATH_COST_ID = 1L; + private static final long L_Q_I_IN_ID = 2L; + private static final long L_Q_I_OUT_ID = 3L; + + public ThreadBorderRouterManagementClusterRouteTableStruct( + Integer routerId, + Integer pathCost, + Integer LQIIn, + Integer LQIOut + ) { + this.routerId = routerId; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(ROUTER_ID_ID, new UIntType(routerId))); + values.add(new StructElement(PATH_COST_ID, new UIntType(pathCost))); + values.add(new StructElement(L_Q_I_IN_ID, new UIntType(LQIIn))); + values.add(new StructElement(L_Q_I_OUT_ID, new UIntType(LQIOut))); + + return new StructType(values); + } + + public static ThreadBorderRouterManagementClusterRouteTableStruct decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer routerId = null; + Integer pathCost = null; + Integer LQIIn = null; + Integer LQIOut = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == ROUTER_ID_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + routerId = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == PATH_COST_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + pathCost = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == L_Q_I_IN_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + LQIIn = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == L_Q_I_OUT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + LQIOut = castingValue.value(Integer.class); + } + } + } + return new ThreadBorderRouterManagementClusterRouteTableStruct( + routerId, + pathCost, + LQIIn, + LQIOut + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadBorderRouterManagementClusterRouteTableStruct {\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThreadBorderRouterManagementClusterThreadNodeStruct { + public Long extAddress; + public Integer rloc16; + public ArrayList IPv6s; + public Integer routingRole; + public ArrayList routeTable; + public ArrayList childTable; + private static final long EXT_ADDRESS_ID = 0L; + private static final long RLOC16_ID = 1L; + private static final long I_PV6S_ID = 2L; + private static final long ROUTING_ROLE_ID = 3L; + private static final long ROUTE_TABLE_ID = 4L; + private static final long CHILD_TABLE_ID = 5L; + + public ThreadBorderRouterManagementClusterThreadNodeStruct( + Long extAddress, + Integer rloc16, + ArrayList IPv6s, + Integer routingRole, + ArrayList routeTable, + ArrayList childTable + ) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.IPv6s = IPv6s; + this.routingRole = routingRole; + this.routeTable = routeTable; + this.childTable = childTable; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(EXT_ADDRESS_ID, new UIntType(extAddress))); + values.add(new StructElement(RLOC16_ID, new UIntType(rloc16))); + values.add(new StructElement(I_PV6S_ID, ArrayType.generateArrayType(IPv6s, (elementIPv6s) -> new ByteArrayType(elementIPv6s)))); + values.add(new StructElement(ROUTING_ROLE_ID, new UIntType(routingRole))); + values.add(new StructElement(ROUTE_TABLE_ID, ArrayType.generateArrayType(routeTable, (elementrouteTable) -> elementrouteTable.encodeTlv()))); + values.add(new StructElement(CHILD_TABLE_ID, ArrayType.generateArrayType(childTable, (elementchildTable) -> elementchildTable.encodeTlv()))); + + return new StructType(values); + } + + public static ThreadBorderRouterManagementClusterThreadNodeStruct decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Long extAddress = null; + Integer rloc16 = null; + ArrayList IPv6s = null; + Integer routingRole = null; + ArrayList routeTable = null; + ArrayList childTable = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == EXT_ADDRESS_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + extAddress = castingValue.value(Long.class); + } + } else if (element.contextTagNum() == RLOC16_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + rloc16 = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == I_PV6S_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Array) { + ArrayType castingValue = element.value(ArrayType.class); + IPv6s = castingValue.map((elementcastingValue) -> elementcastingValue.value(byte[].class)); + } + } else if (element.contextTagNum() == ROUTING_ROLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + routingRole = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == ROUTE_TABLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Array) { + ArrayType castingValue = element.value(ArrayType.class); + routeTable = castingValue.map((elementcastingValue) -> ChipStructs.ThreadBorderRouterManagementClusterRouteTableStruct.decodeTlv(elementcastingValue)); + } + } else if (element.contextTagNum() == CHILD_TABLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Array) { + ArrayType castingValue = element.value(ArrayType.class); + childTable = castingValue.map((elementcastingValue) -> ChipStructs.ThreadBorderRouterManagementClusterChildTableStruct.decodeTlv(elementcastingValue)); + } + } + } + return new ThreadBorderRouterManagementClusterThreadNodeStruct( + extAddress, + rloc16, + IPv6s, + routingRole, + routeTable, + childTable + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadBorderRouterManagementClusterThreadNodeStruct {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tIPv6s: "); + output.append(IPv6s); + output.append("\n"); + output.append("\troutingRole: "); + output.append(routingRole); + output.append("\n"); + output.append("\trouteTable: "); + output.append(routeTable); + output.append("\n"); + output.append("\tchildTable: "); + output.append(childTable); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThreadBorderRouterManagementClusterNeiborTableStruct { + public Long extAddress; + public Long age; + public Integer rloc16; + public @Nullable Integer averageRssi; + public @Nullable Integer lastRssi; + public Integer routingRole; + private static final long EXT_ADDRESS_ID = 0L; + private static final long AGE_ID = 1L; + private static final long RLOC16_ID = 2L; + private static final long AVERAGE_RSSI_ID = 3L; + private static final long LAST_RSSI_ID = 4L; + private static final long ROUTING_ROLE_ID = 5L; + + public ThreadBorderRouterManagementClusterNeiborTableStruct( + Long extAddress, + Long age, + Integer rloc16, + @Nullable Integer averageRssi, + @Nullable Integer lastRssi, + Integer routingRole + ) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.routingRole = routingRole; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(EXT_ADDRESS_ID, new UIntType(extAddress))); + values.add(new StructElement(AGE_ID, new UIntType(age))); + values.add(new StructElement(RLOC16_ID, new UIntType(rloc16))); + values.add(new StructElement(AVERAGE_RSSI_ID, averageRssi != null ? new IntType(averageRssi) : new NullType())); + values.add(new StructElement(LAST_RSSI_ID, lastRssi != null ? new IntType(lastRssi) : new NullType())); + values.add(new StructElement(ROUTING_ROLE_ID, new UIntType(routingRole))); + + return new StructType(values); + } + + public static ThreadBorderRouterManagementClusterNeiborTableStruct decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Long extAddress = null; + Long age = null; + Integer rloc16 = null; + @Nullable Integer averageRssi = null; + @Nullable Integer lastRssi = null; + Integer routingRole = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == EXT_ADDRESS_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + extAddress = castingValue.value(Long.class); + } + } else if (element.contextTagNum() == AGE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + age = castingValue.value(Long.class); + } + } else if (element.contextTagNum() == RLOC16_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + rloc16 = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == AVERAGE_RSSI_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + averageRssi = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == LAST_RSSI_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + lastRssi = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == ROUTING_ROLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + routingRole = castingValue.value(Integer.class); + } + } + } + return new ThreadBorderRouterManagementClusterNeiborTableStruct( + extAddress, + age, + rloc16, + averageRssi, + lastRssi, + routingRole + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadBorderRouterManagementClusterNeiborTableStruct {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\troutingRole: "); + output.append(routingRole); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} public static class ChannelClusterProgramCastStruct { public String name; public String role; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 3437b8a981e476..2b4ccc41351393 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -328,6 +328,9 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == RadonConcentrationMeasurement.ID) { return new RadonConcentrationMeasurement(); } + if (clusterId == ThreadBorderRouterManagement.ID) { + return new ThreadBorderRouterManagement(); + } if (clusterId == WakeOnLan.ID) { return new WakeOnLan(); } @@ -14313,6 +14316,168 @@ public long getCommandID(String name) throws IllegalArgumentException { return Command.valueOf(name).getID(); } } + public static class ThreadBorderRouterManagement implements BaseCluster { + public static final long ID = 1106L; + public long getID() { + return ID; + } + + public enum Attribute { + BorderRouterName(0L), + BorderAgentId(1L), + ThreadVersion(2L), + InterfaceEnabled(3L), + ThreadNode(4L), + ActiveDatasetTimestamp(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + GetActiveDatasetRequest(0L), + GetPendingDatasetRequest(1L), + SetActiveDatasetRequest(3L), + SetPendingDatasetRequest(4L), + TopologyRequest(5L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SetActiveDatasetRequestCommandField {ActiveDataset(0),Breadcrumb(1),; + private final int id; + SetActiveDatasetRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetActiveDatasetRequestCommandField value(int id) throws NoSuchFieldError { + for (SetActiveDatasetRequestCommandField field : SetActiveDatasetRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetPendingDatasetRequestCommandField {PendingDataset(0),; + private final int id; + SetPendingDatasetRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetPendingDatasetRequestCommandField value(int id) throws NoSuchFieldError { + for (SetPendingDatasetRequestCommandField field : SetPendingDatasetRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TopologyRequestCommandField {Count(0),StartIndex(1),Snapshot(2),; + private final int id; + TopologyRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TopologyRequestCommandField value(int id) throws NoSuchFieldError { + for (TopologyRequestCommandField field : TopologyRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } public static class WakeOnLan implements BaseCluster { public static final long ID = 1283L; public long getID() { diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java index 4ded328fad6ed5..d5ec5fb7b0e6c4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java @@ -17299,6 +17299,183 @@ public void onError(Exception ex) { } } + + public static class DelegatedThreadBorderRouterManagementClusterDatasetResponseCallback implements ChipClusters.ThreadBorderRouterManagementCluster.DatasetResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] dataset) { + Map responseValues = new LinkedHashMap<>(); + + CommandResponseInfo datasetResponseValue = new CommandResponseInfo("dataset", "byte[]"); + responseValues.put(datasetResponseValue, dataset); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterTopologyResponseCallback implements ChipClusters.ThreadBorderRouterManagementCluster.TopologyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer snapshot, Integer numberOfDevices, ArrayList threadTopology) { + Map responseValues = new LinkedHashMap<>(); + + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo snapshotResponseValue = new CommandResponseInfo("snapshot", "Integer"); + responseValues.put(snapshotResponseValue, snapshot); + CommandResponseInfo numberOfDevicesResponseValue = new CommandResponseInfo("numberOfDevices", "Integer"); + responseValues.put(numberOfDevicesResponseValue, numberOfDevices); + // threadTopology: ThreadNodeStruct + // Conversion from this type to Java is not properly implemented yet + + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + public static class DelegatedThreadBorderRouterManagementClusterThreadNodeAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.ThreadNodeAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "ChipStructs.ThreadBorderRouterManagementClusterThreadNodeStruct"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterActiveDatasetTimestampAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.ActiveDatasetTimestampAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterGeneratedCommandListAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterAcceptedCommandListAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterEventListAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.EventListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedThreadBorderRouterManagementClusterAttributeListAttributeCallback implements ChipClusters.ThreadBorderRouterManagementCluster.AttributeListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedWakeOnLanClusterGeneratedCommandListAttributeCallback implements ChipClusters.WakeOnLanCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -21177,6 +21354,10 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.RadonConcentrationMeasurementCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("radonConcentrationMeasurement", radonConcentrationMeasurementClusterInfo); + ClusterInfo threadBorderRouterManagementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadBorderRouterManagementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("threadBorderRouterManagement", threadBorderRouterManagementClusterInfo); + ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); @@ -21353,6 +21534,7 @@ public void combineCommand(Map destination, Map> getCommandMap() { commandMap.put("radonConcentrationMeasurement", radonConcentrationMeasurementClusterInteractionInfoMap); + Map threadBorderRouterManagementClusterInteractionInfoMap = new LinkedHashMap<>(); + + Map threadBorderRouterManagementgetActiveDatasetRequestCommandParams = new LinkedHashMap(); + InteractionInfo threadBorderRouterManagementgetActiveDatasetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster) + .getActiveDatasetRequest((ChipClusters.ThreadBorderRouterManagementCluster.DatasetResponseCallback) callback + ); + }, + () -> new DelegatedThreadBorderRouterManagementClusterDatasetResponseCallback(), + threadBorderRouterManagementgetActiveDatasetRequestCommandParams + ); + threadBorderRouterManagementClusterInteractionInfoMap.put("getActiveDatasetRequest", threadBorderRouterManagementgetActiveDatasetRequestInteractionInfo); + + Map threadBorderRouterManagementgetPendingDatasetRequestCommandParams = new LinkedHashMap(); + InteractionInfo threadBorderRouterManagementgetPendingDatasetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster) + .getPendingDatasetRequest((ChipClusters.ThreadBorderRouterManagementCluster.DatasetResponseCallback) callback + ); + }, + () -> new DelegatedThreadBorderRouterManagementClusterDatasetResponseCallback(), + threadBorderRouterManagementgetPendingDatasetRequestCommandParams + ); + threadBorderRouterManagementClusterInteractionInfoMap.put("getPendingDatasetRequest", threadBorderRouterManagementgetPendingDatasetRequestInteractionInfo); + + Map threadBorderRouterManagementsetActiveDatasetRequestCommandParams = new LinkedHashMap(); + + CommandParameterInfo threadBorderRouterManagementsetActiveDatasetRequestactiveDatasetCommandParameterInfo = new CommandParameterInfo("activeDataset", byte[].class, byte[].class); + threadBorderRouterManagementsetActiveDatasetRequestCommandParams.put("activeDataset",threadBorderRouterManagementsetActiveDatasetRequestactiveDatasetCommandParameterInfo); + + CommandParameterInfo threadBorderRouterManagementsetActiveDatasetRequestbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class, Long.class); + threadBorderRouterManagementsetActiveDatasetRequestCommandParams.put("breadcrumb",threadBorderRouterManagementsetActiveDatasetRequestbreadcrumbCommandParameterInfo); + InteractionInfo threadBorderRouterManagementsetActiveDatasetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster) + .setActiveDatasetRequest((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("activeDataset") + , (Long) + commandArguments.get("breadcrumb") + ); + }, + () -> new DelegatedDefaultClusterCallback(), + threadBorderRouterManagementsetActiveDatasetRequestCommandParams + ); + threadBorderRouterManagementClusterInteractionInfoMap.put("setActiveDatasetRequest", threadBorderRouterManagementsetActiveDatasetRequestInteractionInfo); + + Map threadBorderRouterManagementsetPendingDatasetRequestCommandParams = new LinkedHashMap(); + + CommandParameterInfo threadBorderRouterManagementsetPendingDatasetRequestpendingDatasetCommandParameterInfo = new CommandParameterInfo("pendingDataset", byte[].class, byte[].class); + threadBorderRouterManagementsetPendingDatasetRequestCommandParams.put("pendingDataset",threadBorderRouterManagementsetPendingDatasetRequestpendingDatasetCommandParameterInfo); + InteractionInfo threadBorderRouterManagementsetPendingDatasetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster) + .setPendingDatasetRequest((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("pendingDataset") + ); + }, + () -> new DelegatedDefaultClusterCallback(), + threadBorderRouterManagementsetPendingDatasetRequestCommandParams + ); + threadBorderRouterManagementClusterInteractionInfoMap.put("setPendingDatasetRequest", threadBorderRouterManagementsetPendingDatasetRequestInteractionInfo); + + Map threadBorderRouterManagementtopologyRequestCommandParams = new LinkedHashMap(); + + CommandParameterInfo threadBorderRouterManagementtopologyRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class, Integer.class); + threadBorderRouterManagementtopologyRequestCommandParams.put("count",threadBorderRouterManagementtopologyRequestcountCommandParameterInfo); + + CommandParameterInfo threadBorderRouterManagementtopologyRequeststartIndexCommandParameterInfo = new CommandParameterInfo("startIndex", Integer.class, Integer.class); + threadBorderRouterManagementtopologyRequestCommandParams.put("startIndex",threadBorderRouterManagementtopologyRequeststartIndexCommandParameterInfo); + + CommandParameterInfo threadBorderRouterManagementtopologyRequestsnapshotCommandParameterInfo = new CommandParameterInfo("snapshot", Integer.class, Integer.class); + threadBorderRouterManagementtopologyRequestCommandParams.put("snapshot",threadBorderRouterManagementtopologyRequestsnapshotCommandParameterInfo); + InteractionInfo threadBorderRouterManagementtopologyRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster) + .topologyRequest((ChipClusters.ThreadBorderRouterManagementCluster.TopologyResponseCallback) callback + , (Integer) + commandArguments.get("count") + + , (Integer) + commandArguments.get("startIndex") + + , (Integer) + commandArguments.get("snapshot") + + ); + }, + () -> new DelegatedThreadBorderRouterManagementClusterTopologyResponseCallback(), + threadBorderRouterManagementtopologyRequestCommandParams + ); + threadBorderRouterManagementClusterInteractionInfoMap.put("topologyRequest", threadBorderRouterManagementtopologyRequestInteractionInfo); + + commandMap.put("threadBorderRouterManagement", threadBorderRouterManagementClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index cc18af0810cc10..1f6165d3abf7d3 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -16529,6 +16529,131 @@ private static Map readRadonConcentrationMeasurementInt return result; } + private static Map readThreadBorderRouterManagementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readThreadBorderRouterManagementBorderRouterNameCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementBorderRouterNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readBorderRouterNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readThreadBorderRouterManagementBorderRouterNameCommandParams + ); + result.put("readBorderRouterNameAttribute", readThreadBorderRouterManagementBorderRouterNameAttributeInteractionInfo); + Map readThreadBorderRouterManagementBorderAgentIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementBorderAgentIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readBorderAgentIdAttribute( + (ChipClusters.OctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), + readThreadBorderRouterManagementBorderAgentIdCommandParams + ); + result.put("readBorderAgentIdAttribute", readThreadBorderRouterManagementBorderAgentIdAttributeInteractionInfo); + Map readThreadBorderRouterManagementThreadVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementThreadVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readThreadVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadBorderRouterManagementThreadVersionCommandParams + ); + result.put("readThreadVersionAttribute", readThreadBorderRouterManagementThreadVersionAttributeInteractionInfo); + Map readThreadBorderRouterManagementInterfaceEnabledCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readInterfaceEnabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readThreadBorderRouterManagementInterfaceEnabledCommandParams + ); + result.put("readInterfaceEnabledAttribute", readThreadBorderRouterManagementInterfaceEnabledAttributeInteractionInfo); + Map readThreadBorderRouterManagementActiveDatasetTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementActiveDatasetTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readActiveDatasetTimestampAttribute( + (ChipClusters.ThreadBorderRouterManagementCluster.ActiveDatasetTimestampAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadBorderRouterManagementClusterActiveDatasetTimestampAttributeCallback(), + readThreadBorderRouterManagementActiveDatasetTimestampCommandParams + ); + result.put("readActiveDatasetTimestampAttribute", readThreadBorderRouterManagementActiveDatasetTimestampAttributeInteractionInfo); + Map readThreadBorderRouterManagementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ThreadBorderRouterManagementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadBorderRouterManagementClusterGeneratedCommandListAttributeCallback(), + readThreadBorderRouterManagementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readThreadBorderRouterManagementGeneratedCommandListAttributeInteractionInfo); + Map readThreadBorderRouterManagementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ThreadBorderRouterManagementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadBorderRouterManagementClusterAcceptedCommandListAttributeCallback(), + readThreadBorderRouterManagementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readThreadBorderRouterManagementAcceptedCommandListAttributeInteractionInfo); + Map readThreadBorderRouterManagementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readEventListAttribute( + (ChipClusters.ThreadBorderRouterManagementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadBorderRouterManagementClusterEventListAttributeCallback(), + readThreadBorderRouterManagementEventListCommandParams + ); + result.put("readEventListAttribute", readThreadBorderRouterManagementEventListAttributeInteractionInfo); + Map readThreadBorderRouterManagementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ThreadBorderRouterManagementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadBorderRouterManagementClusterAttributeListAttributeCallback(), + readThreadBorderRouterManagementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readThreadBorderRouterManagementAttributeListAttributeInteractionInfo); + Map readThreadBorderRouterManagementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadBorderRouterManagementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readThreadBorderRouterManagementFeatureMapAttributeInteractionInfo); + Map readThreadBorderRouterManagementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadBorderRouterManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadBorderRouterManagementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadBorderRouterManagementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readThreadBorderRouterManagementClusterRevisionAttributeInteractionInfo); + + return result; + } private static Map readWakeOnLanInteractionInfo() { Map result = new LinkedHashMap<>();Map readWakeOnLanMACAddressCommandParams = new LinkedHashMap(); InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = new InteractionInfo( @@ -20588,6 +20713,7 @@ public Map> getReadAttributeMap() { put("pm10ConcentrationMeasurement", readPm10ConcentrationMeasurementInteractionInfo()); put("totalVolatileOrganicCompoundsConcentrationMeasurement", readTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo()); put("radonConcentrationMeasurement", readRadonConcentrationMeasurementInteractionInfo()); + put("threadBorderRouterManagement", readThreadBorderRouterManagementInteractionInfo()); put("wakeOnLan", readWakeOnLanInteractionInfo()); put("channel", readChannelInteractionInfo()); put("targetNavigator", readTargetNavigatorInteractionInfo()); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index 0e5a32b23f04c4..833a9af6e27cac 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -3636,6 +3636,8 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("totalVolatileOrganicCompoundsConcentrationMeasurement", writeTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo); Map writeRadonConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("radonConcentrationMeasurement", writeRadonConcentrationMeasurementInteractionInfo); + Map writeThreadBorderRouterManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("threadBorderRouterManagement", writeThreadBorderRouterManagementInteractionInfo); Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); Map writeChannelInteractionInfo = new LinkedHashMap<>(); diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni index 34fd21bb27d770..52e323444fa65f 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -123,6 +123,10 @@ structs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThermostatClusterScheduleTransitionStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThermostatClusterScheduleTypeStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThermostatClusterWeeklyScheduleTransitionStruct.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterNeighborTableStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterOperationalDatasetComponents.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterRouteTableStruct.kt", diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt new file mode 100644 index 00000000000000..a9146b6581a846 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt @@ -0,0 +1,67 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.structs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterChildTableStruct( + val rloc16: UInt, + val linkQuality: UInt, + val routingRole: UInt +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterChildTableStruct {\n") + append("\trloc16 : $rloc16\n") + append("\tlinkQuality : $linkQuality\n") + append("\troutingRole : $routingRole\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + put(ContextSpecificTag(TAG_LINK_QUALITY), linkQuality) + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + endStructure() + } + } + + companion object { + private const val TAG_RLOC16 = 0 + private const val TAG_LINK_QUALITY = 1 + private const val TAG_ROUTING_ROLE = 2 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterChildTableStruct { + tlvReader.enterStructure(tlvTag) + val rloc16 = tlvReader.getUInt(ContextSpecificTag(TAG_RLOC16)) + val linkQuality = tlvReader.getUInt(ContextSpecificTag(TAG_LINK_QUALITY)) + val routingRole = tlvReader.getUInt(ContextSpecificTag(TAG_ROUTING_ROLE)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterChildTableStruct(rloc16, linkQuality, routingRole) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt new file mode 100644 index 00000000000000..49aab4a8c13c81 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt @@ -0,0 +1,109 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.structs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterNeiborTableStruct( + val extAddress: ULong, + val age: ULong, + val rloc16: UInt, + val averageRssi: Int?, + val lastRssi: Int?, + val routingRole: UInt +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterNeiborTableStruct {\n") + append("\textAddress : $extAddress\n") + append("\tage : $age\n") + append("\trloc16 : $rloc16\n") + append("\taverageRssi : $averageRssi\n") + append("\tlastRssi : $lastRssi\n") + append("\troutingRole : $routingRole\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_EXT_ADDRESS), extAddress) + put(ContextSpecificTag(TAG_AGE), age) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + if (averageRssi != null) { + put(ContextSpecificTag(TAG_AVERAGE_RSSI), averageRssi) + } else { + putNull(ContextSpecificTag(TAG_AVERAGE_RSSI)) + } + if (lastRssi != null) { + put(ContextSpecificTag(TAG_LAST_RSSI), lastRssi) + } else { + putNull(ContextSpecificTag(TAG_LAST_RSSI)) + } + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + endStructure() + } + } + + companion object { + private const val TAG_EXT_ADDRESS = 0 + private const val TAG_AGE = 1 + private const val TAG_RLOC16 = 2 + private const val TAG_AVERAGE_RSSI = 3 + private const val TAG_LAST_RSSI = 4 + private const val TAG_ROUTING_ROLE = 5 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterNeiborTableStruct { + tlvReader.enterStructure(tlvTag) + val extAddress = tlvReader.getULong(ContextSpecificTag(TAG_EXT_ADDRESS)) + val age = tlvReader.getULong(ContextSpecificTag(TAG_AGE)) + val rloc16 = tlvReader.getUInt(ContextSpecificTag(TAG_RLOC16)) + val averageRssi = + if (!tlvReader.isNull()) { + tlvReader.getInt(ContextSpecificTag(TAG_AVERAGE_RSSI)) + } else { + tlvReader.getNull(ContextSpecificTag(TAG_AVERAGE_RSSI)) + null + } + val lastRssi = + if (!tlvReader.isNull()) { + tlvReader.getInt(ContextSpecificTag(TAG_LAST_RSSI)) + } else { + tlvReader.getNull(ContextSpecificTag(TAG_LAST_RSSI)) + null + } + val routingRole = tlvReader.getUInt(ContextSpecificTag(TAG_ROUTING_ROLE)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterNeiborTableStruct( + extAddress, + age, + rloc16, + averageRssi, + lastRssi, + routingRole + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt new file mode 100644 index 00000000000000..12b5fb6e9e0e3d --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt @@ -0,0 +1,72 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.structs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterRouteTableStruct( + val routerId: UInt, + val pathCost: UInt, + val LQIIn: UInt, + val LQIOut: UInt +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterRouteTableStruct {\n") + append("\trouterId : $routerId\n") + append("\tpathCost : $pathCost\n") + append("\tLQIIn : $LQIIn\n") + append("\tLQIOut : $LQIOut\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ROUTER_ID), routerId) + put(ContextSpecificTag(TAG_PATH_COST), pathCost) + put(ContextSpecificTag(TAG_L_Q_I_IN), LQIIn) + put(ContextSpecificTag(TAG_L_Q_I_OUT), LQIOut) + endStructure() + } + } + + companion object { + private const val TAG_ROUTER_ID = 0 + private const val TAG_PATH_COST = 1 + private const val TAG_L_Q_I_IN = 2 + private const val TAG_L_Q_I_OUT = 3 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterRouteTableStruct { + tlvReader.enterStructure(tlvTag) + val routerId = tlvReader.getUInt(ContextSpecificTag(TAG_ROUTER_ID)) + val pathCost = tlvReader.getUInt(ContextSpecificTag(TAG_PATH_COST)) + val LQIIn = tlvReader.getUInt(ContextSpecificTag(TAG_L_Q_I_IN)) + val LQIOut = tlvReader.getUInt(ContextSpecificTag(TAG_L_Q_I_OUT)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterRouteTableStruct(routerId, pathCost, LQIIn, LQIOut) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt new file mode 100644 index 00000000000000..bfe71bce903319 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt @@ -0,0 +1,127 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.structs + +import chip.devicecontroller.cluster.* +import matter.tlv.AnonymousTag +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterThreadNodeStruct( + val extAddress: ULong, + val rloc16: UInt, + val IPv6s: List, + val routingRole: UInt, + val routeTable: List, + val childTable: List +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterThreadNodeStruct {\n") + append("\textAddress : $extAddress\n") + append("\trloc16 : $rloc16\n") + append("\tIPv6s : $IPv6s\n") + append("\troutingRole : $routingRole\n") + append("\trouteTable : $routeTable\n") + append("\tchildTable : $childTable\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_EXT_ADDRESS), extAddress) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + startArray(ContextSpecificTag(TAG_I_PV6S)) + for (item in IPv6s.iterator()) { + put(AnonymousTag, item) + } + endArray() + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + startArray(ContextSpecificTag(TAG_ROUTE_TABLE)) + for (item in routeTable.iterator()) { + item.toTlv(AnonymousTag, this) + } + endArray() + startArray(ContextSpecificTag(TAG_CHILD_TABLE)) + for (item in childTable.iterator()) { + item.toTlv(AnonymousTag, this) + } + endArray() + endStructure() + } + } + + companion object { + private const val TAG_EXT_ADDRESS = 0 + private const val TAG_RLOC16 = 1 + private const val TAG_I_PV6S = 2 + private const val TAG_ROUTING_ROLE = 3 + private const val TAG_ROUTE_TABLE = 4 + private const val TAG_CHILD_TABLE = 5 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterThreadNodeStruct { + tlvReader.enterStructure(tlvTag) + val extAddress = tlvReader.getULong(ContextSpecificTag(TAG_EXT_ADDRESS)) + val rloc16 = tlvReader.getUInt(ContextSpecificTag(TAG_RLOC16)) + val IPv6s = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_I_PV6S)) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getByteArray(AnonymousTag)) + } + tlvReader.exitContainer() + } + val routingRole = tlvReader.getUInt(ContextSpecificTag(TAG_ROUTING_ROLE)) + val routeTable = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_ROUTE_TABLE)) + while (!tlvReader.isEndOfContainer()) { + add( + ThreadBorderRouterManagementClusterRouteTableStruct.fromTlv(AnonymousTag, tlvReader) + ) + } + tlvReader.exitContainer() + } + val childTable = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_CHILD_TABLE)) + while (!tlvReader.isEndOfContainer()) { + add( + ThreadBorderRouterManagementClusterChildTableStruct.fromTlv(AnonymousTag, tlvReader) + ) + } + tlvReader.exitContainer() + } + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterThreadNodeStruct( + extAddress, + rloc16, + IPv6s, + routingRole, + routeTable, + childTable + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadBorderRouterManagementCluster.kt b/src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadBorderRouterManagementCluster.kt new file mode 100644 index 00000000000000..b2e66f23f74394 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadBorderRouterManagementCluster.kt @@ -0,0 +1,1413 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package matter.controller.cluster.clusters + +import java.time.Duration +import java.util.logging.Level +import java.util.logging.Logger +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.transform +import matter.controller.BooleanSubscriptionState +import matter.controller.ByteArraySubscriptionState +import matter.controller.InvokeRequest +import matter.controller.InvokeResponse +import matter.controller.MatterController +import matter.controller.ReadData +import matter.controller.ReadRequest +import matter.controller.StringSubscriptionState +import matter.controller.SubscribeRequest +import matter.controller.SubscriptionState +import matter.controller.UIntSubscriptionState +import matter.controller.UShortSubscriptionState +import matter.controller.cluster.structs.* +import matter.controller.model.AttributePath +import matter.controller.model.CommandPath +import matter.tlv.AnonymousTag +import matter.tlv.ContextSpecificTag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementCluster( + private val controller: MatterController, + private val endpointId: UShort +) { + class DatasetResponse(val dataset: ByteArray) + + class TopologyResponse( + val status: UByte, + val snapshot: UByte, + val numberOfDevices: UShort, + val threadTopology: List + ) + + class ThreadNodeAttribute(val value: ThreadBorderRouterManagementClusterThreadNodeStruct) + + sealed class ThreadNodeAttributeSubscriptionState { + data class Success(val value: ThreadBorderRouterManagementClusterThreadNodeStruct) : + ThreadNodeAttributeSubscriptionState() + + data class Error(val exception: Exception) : ThreadNodeAttributeSubscriptionState() + + object SubscriptionEstablished : ThreadNodeAttributeSubscriptionState() + } + + class ActiveDatasetTimestampAttribute(val value: ULong?) + + sealed class ActiveDatasetTimestampAttributeSubscriptionState { + data class Success(val value: ULong?) : ActiveDatasetTimestampAttributeSubscriptionState() + + data class Error(val exception: Exception) : ActiveDatasetTimestampAttributeSubscriptionState() + + object SubscriptionEstablished : ActiveDatasetTimestampAttributeSubscriptionState() + } + + class GeneratedCommandListAttribute(val value: List) + + sealed class GeneratedCommandListAttributeSubscriptionState { + data class Success(val value: List) : GeneratedCommandListAttributeSubscriptionState() + + data class Error(val exception: Exception) : GeneratedCommandListAttributeSubscriptionState() + + object SubscriptionEstablished : GeneratedCommandListAttributeSubscriptionState() + } + + class AcceptedCommandListAttribute(val value: List) + + sealed class AcceptedCommandListAttributeSubscriptionState { + data class Success(val value: List) : AcceptedCommandListAttributeSubscriptionState() + + data class Error(val exception: Exception) : AcceptedCommandListAttributeSubscriptionState() + + object SubscriptionEstablished : AcceptedCommandListAttributeSubscriptionState() + } + + class EventListAttribute(val value: List) + + sealed class EventListAttributeSubscriptionState { + data class Success(val value: List) : EventListAttributeSubscriptionState() + + data class Error(val exception: Exception) : EventListAttributeSubscriptionState() + + object SubscriptionEstablished : EventListAttributeSubscriptionState() + } + + class AttributeListAttribute(val value: List) + + sealed class AttributeListAttributeSubscriptionState { + data class Success(val value: List) : AttributeListAttributeSubscriptionState() + + data class Error(val exception: Exception) : AttributeListAttributeSubscriptionState() + + object SubscriptionEstablished : AttributeListAttributeSubscriptionState() + } + + suspend fun getActiveDatasetRequest(timedInvokeTimeout: Duration? = null): DatasetResponse { + val commandId: UInt = 0u + + val tlvWriter = TlvWriter() + tlvWriter.startStructure(AnonymousTag) + tlvWriter.endStructure() + + val request: InvokeRequest = + InvokeRequest( + CommandPath(endpointId, clusterId = CLUSTER_ID, commandId), + tlvPayload = tlvWriter.getEncoded(), + timedRequest = timedInvokeTimeout + ) + + val response: InvokeResponse = controller.invoke(request) + logger.log(Level.FINE, "Invoke command succeeded: ${response}") + + val tlvReader = TlvReader(response.payload) + tlvReader.enterStructure(AnonymousTag) + val TAG_DATASET: Int = 0 + var dataset_decoded: ByteArray? = null + + while (!tlvReader.isEndOfContainer()) { + val tag = tlvReader.peekElement().tag + + if (tag == ContextSpecificTag(TAG_DATASET)) { + dataset_decoded = tlvReader.getByteArray(tag) + } else { + tlvReader.skipElement() + } + } + + if (dataset_decoded == null) { + throw IllegalStateException("dataset not found in TLV") + } + + tlvReader.exitContainer() + + return DatasetResponse(dataset_decoded) + } + + suspend fun getPendingDatasetRequest(timedInvokeTimeout: Duration? = null): DatasetResponse { + val commandId: UInt = 1u + + val tlvWriter = TlvWriter() + tlvWriter.startStructure(AnonymousTag) + tlvWriter.endStructure() + + val request: InvokeRequest = + InvokeRequest( + CommandPath(endpointId, clusterId = CLUSTER_ID, commandId), + tlvPayload = tlvWriter.getEncoded(), + timedRequest = timedInvokeTimeout + ) + + val response: InvokeResponse = controller.invoke(request) + logger.log(Level.FINE, "Invoke command succeeded: ${response}") + + val tlvReader = TlvReader(response.payload) + tlvReader.enterStructure(AnonymousTag) + val TAG_DATASET: Int = 0 + var dataset_decoded: ByteArray? = null + + while (!tlvReader.isEndOfContainer()) { + val tag = tlvReader.peekElement().tag + + if (tag == ContextSpecificTag(TAG_DATASET)) { + dataset_decoded = tlvReader.getByteArray(tag) + } else { + tlvReader.skipElement() + } + } + + if (dataset_decoded == null) { + throw IllegalStateException("dataset not found in TLV") + } + + tlvReader.exitContainer() + + return DatasetResponse(dataset_decoded) + } + + suspend fun setActiveDatasetRequest( + activeDataset: ByteArray, + breadcrumb: ULong, + timedInvokeTimeout: Duration? = null + ) { + val commandId: UInt = 3u + + val tlvWriter = TlvWriter() + tlvWriter.startStructure(AnonymousTag) + + val TAG_ACTIVE_DATASET_REQ: Int = 0 + tlvWriter.put(ContextSpecificTag(TAG_ACTIVE_DATASET_REQ), activeDataset) + + val TAG_BREADCRUMB_REQ: Int = 1 + tlvWriter.put(ContextSpecificTag(TAG_BREADCRUMB_REQ), breadcrumb) + tlvWriter.endStructure() + + val request: InvokeRequest = + InvokeRequest( + CommandPath(endpointId, clusterId = CLUSTER_ID, commandId), + tlvPayload = tlvWriter.getEncoded(), + timedRequest = timedInvokeTimeout + ) + + val response: InvokeResponse = controller.invoke(request) + logger.log(Level.FINE, "Invoke command succeeded: ${response}") + } + + suspend fun setPendingDatasetRequest( + pendingDataset: ByteArray, + timedInvokeTimeout: Duration? = null + ) { + val commandId: UInt = 4u + + val tlvWriter = TlvWriter() + tlvWriter.startStructure(AnonymousTag) + + val TAG_PENDING_DATASET_REQ: Int = 0 + tlvWriter.put(ContextSpecificTag(TAG_PENDING_DATASET_REQ), pendingDataset) + tlvWriter.endStructure() + + val request: InvokeRequest = + InvokeRequest( + CommandPath(endpointId, clusterId = CLUSTER_ID, commandId), + tlvPayload = tlvWriter.getEncoded(), + timedRequest = timedInvokeTimeout + ) + + val response: InvokeResponse = controller.invoke(request) + logger.log(Level.FINE, "Invoke command succeeded: ${response}") + } + + suspend fun topologyRequest( + count: UShort, + startIndex: UShort, + snapshot: UByte, + timedInvokeTimeout: Duration? = null + ): TopologyResponse { + val commandId: UInt = 5u + + val tlvWriter = TlvWriter() + tlvWriter.startStructure(AnonymousTag) + + val TAG_COUNT_REQ: Int = 0 + tlvWriter.put(ContextSpecificTag(TAG_COUNT_REQ), count) + + val TAG_START_INDEX_REQ: Int = 1 + tlvWriter.put(ContextSpecificTag(TAG_START_INDEX_REQ), startIndex) + + val TAG_SNAPSHOT_REQ: Int = 2 + tlvWriter.put(ContextSpecificTag(TAG_SNAPSHOT_REQ), snapshot) + tlvWriter.endStructure() + + val request: InvokeRequest = + InvokeRequest( + CommandPath(endpointId, clusterId = CLUSTER_ID, commandId), + tlvPayload = tlvWriter.getEncoded(), + timedRequest = timedInvokeTimeout + ) + + val response: InvokeResponse = controller.invoke(request) + logger.log(Level.FINE, "Invoke command succeeded: ${response}") + + val tlvReader = TlvReader(response.payload) + tlvReader.enterStructure(AnonymousTag) + val TAG_STATUS: Int = 0 + var status_decoded: UByte? = null + + val TAG_SNAPSHOT: Int = 1 + var snapshot_decoded: UByte? = null + + val TAG_NUMBER_OF_DEVICES: Int = 2 + var numberOfDevices_decoded: UShort? = null + + val TAG_THREAD_TOPOLOGY: Int = 3 + var threadTopology_decoded: List? = null + + while (!tlvReader.isEndOfContainer()) { + val tag = tlvReader.peekElement().tag + + if (tag == ContextSpecificTag(TAG_STATUS)) { + status_decoded = tlvReader.getUByte(tag) + } + + if (tag == ContextSpecificTag(TAG_SNAPSHOT)) { + snapshot_decoded = tlvReader.getUByte(tag) + } + + if (tag == ContextSpecificTag(TAG_NUMBER_OF_DEVICES)) { + numberOfDevices_decoded = tlvReader.getUShort(tag) + } + + if (tag == ContextSpecificTag(TAG_THREAD_TOPOLOGY)) { + threadTopology_decoded = + buildList { + tlvReader.enterArray(tag) + while (!tlvReader.isEndOfContainer()) { + add( + ThreadBorderRouterManagementClusterThreadNodeStruct.fromTlv(AnonymousTag, tlvReader) + ) + } + tlvReader.exitContainer() + } + } else { + tlvReader.skipElement() + } + } + + if (status_decoded == null) { + throw IllegalStateException("status not found in TLV") + } + + if (snapshot_decoded == null) { + throw IllegalStateException("snapshot not found in TLV") + } + + if (numberOfDevices_decoded == null) { + throw IllegalStateException("numberOfDevices not found in TLV") + } + + if (threadTopology_decoded == null) { + throw IllegalStateException("threadTopology not found in TLV") + } + + tlvReader.exitContainer() + + return TopologyResponse( + status_decoded, + snapshot_decoded, + numberOfDevices_decoded, + threadTopology_decoded + ) + } + + suspend fun readBorderRouterNameAttribute(): String { + val ATTRIBUTE_ID: UInt = 0u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Borderroutername attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: String = tlvReader.getString(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeBorderRouterNameAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 0u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + StringSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Borderroutername attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: String = tlvReader.getString(AnonymousTag) + + emit(StringSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(StringSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readBorderAgentIdAttribute(): ByteArray { + val ATTRIBUTE_ID: UInt = 1u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Borderagentid attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ByteArray = tlvReader.getByteArray(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeBorderAgentIdAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 1u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + ByteArraySubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Borderagentid attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ByteArray = tlvReader.getByteArray(AnonymousTag) + + emit(ByteArraySubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(ByteArraySubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readThreadVersionAttribute(): UShort { + val ATTRIBUTE_ID: UInt = 2u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Threadversion attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UShort = tlvReader.getUShort(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeThreadVersionAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 2u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + UShortSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Threadversion attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UShort = tlvReader.getUShort(AnonymousTag) + + emit(UShortSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(UShortSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readInterfaceEnabledAttribute(): Boolean { + val ATTRIBUTE_ID: UInt = 3u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Interfaceenabled attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: Boolean = tlvReader.getBoolean(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeInterfaceEnabledAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 3u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + BooleanSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Interfaceenabled attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: Boolean = tlvReader.getBoolean(AnonymousTag) + + emit(BooleanSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(BooleanSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readThreadNodeAttribute(): ThreadNodeAttribute { + val ATTRIBUTE_ID: UInt = 4u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Threadnode attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ThreadBorderRouterManagementClusterThreadNodeStruct = + ThreadBorderRouterManagementClusterThreadNodeStruct.fromTlv(AnonymousTag, tlvReader) + + return ThreadNodeAttribute(decodedValue) + } + + suspend fun subscribeThreadNodeAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 4u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + ThreadNodeAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Threadnode attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ThreadBorderRouterManagementClusterThreadNodeStruct = + ThreadBorderRouterManagementClusterThreadNodeStruct.fromTlv(AnonymousTag, tlvReader) + + emit(ThreadNodeAttributeSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(ThreadNodeAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readActiveDatasetTimestampAttribute(): ActiveDatasetTimestampAttribute { + val ATTRIBUTE_ID: UInt = 5u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Activedatasettimestamp attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ULong? = + if (!tlvReader.isNull()) { + tlvReader.getULong(AnonymousTag) + } else { + tlvReader.getNull(AnonymousTag) + null + } + + return ActiveDatasetTimestampAttribute(decodedValue) + } + + suspend fun subscribeActiveDatasetTimestampAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 5u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + ActiveDatasetTimestampAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Activedatasettimestamp attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: ULong? = + if (!tlvReader.isNull()) { + tlvReader.getULong(AnonymousTag) + } else { + tlvReader.getNull(AnonymousTag) + null + } + + decodedValue?.let { emit(ActiveDatasetTimestampAttributeSubscriptionState.Success(it)) } + } + SubscriptionState.SubscriptionEstablished -> { + emit(ActiveDatasetTimestampAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readGeneratedCommandListAttribute(): GeneratedCommandListAttribute { + val ATTRIBUTE_ID: UInt = 65528u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Generatedcommandlist attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + return GeneratedCommandListAttribute(decodedValue) + } + + suspend fun subscribeGeneratedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65528u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + GeneratedCommandListAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Generatedcommandlist attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + emit(GeneratedCommandListAttributeSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(GeneratedCommandListAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readAcceptedCommandListAttribute(): AcceptedCommandListAttribute { + val ATTRIBUTE_ID: UInt = 65529u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Acceptedcommandlist attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + return AcceptedCommandListAttribute(decodedValue) + } + + suspend fun subscribeAcceptedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65529u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + AcceptedCommandListAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Acceptedcommandlist attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + emit(AcceptedCommandListAttributeSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(AcceptedCommandListAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readEventListAttribute(): EventListAttribute { + val ATTRIBUTE_ID: UInt = 65530u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Eventlist attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + return EventListAttribute(decodedValue) + } + + suspend fun subscribeEventListAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65530u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + EventListAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Eventlist attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + emit(EventListAttributeSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(EventListAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readAttributeListAttribute(): AttributeListAttribute { + val ATTRIBUTE_ID: UInt = 65531u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Attributelist attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + return AttributeListAttribute(decodedValue) + } + + suspend fun subscribeAttributeListAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65531u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + AttributeListAttributeSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Attributelist attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: List = + buildList { + tlvReader.enterArray(AnonymousTag) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getUInt(AnonymousTag)) + } + tlvReader.exitContainer() + } + + emit(AttributeListAttributeSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(AttributeListAttributeSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readFeatureMapAttribute(): UInt { + val ATTRIBUTE_ID: UInt = 65532u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Featuremap attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UInt = tlvReader.getUInt(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeFeatureMapAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65532u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + UIntSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { "Featuremap attribute not found in Node State update" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UInt = tlvReader.getUInt(AnonymousTag) + + emit(UIntSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(UIntSubscriptionState.SubscriptionEstablished) + } + } + } + } + + suspend fun readClusterRevisionAttribute(): UShort { + val ATTRIBUTE_ID: UInt = 65533u + + val attributePath = + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + + val readRequest = ReadRequest(eventPaths = emptyList(), attributePaths = listOf(attributePath)) + + val response = controller.read(readRequest) + + if (response.successes.isEmpty()) { + logger.log(Level.WARNING, "Read command failed") + throw IllegalStateException("Read command failed with failures: ${response.failures}") + } + + logger.log(Level.FINE, "Read command succeeded") + + val attributeData = + response.successes.filterIsInstance().firstOrNull { + it.path.attributeId == ATTRIBUTE_ID + } + + requireNotNull(attributeData) { "Clusterrevision attribute not found in response" } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UShort = tlvReader.getUShort(AnonymousTag) + + return decodedValue + } + + suspend fun subscribeClusterRevisionAttribute( + minInterval: Int, + maxInterval: Int + ): Flow { + val ATTRIBUTE_ID: UInt = 65533u + val attributePaths = + listOf( + AttributePath(endpointId = endpointId, clusterId = CLUSTER_ID, attributeId = ATTRIBUTE_ID) + ) + + val subscribeRequest: SubscribeRequest = + SubscribeRequest( + eventPaths = emptyList(), + attributePaths = attributePaths, + minInterval = Duration.ofSeconds(minInterval.toLong()), + maxInterval = Duration.ofSeconds(maxInterval.toLong()) + ) + + return controller.subscribe(subscribeRequest).transform { subscriptionState -> + when (subscriptionState) { + is SubscriptionState.SubscriptionErrorNotification -> { + emit( + UShortSubscriptionState.Error( + Exception( + "Subscription terminated with error code: ${subscriptionState.terminationCause}" + ) + ) + ) + } + is SubscriptionState.NodeStateUpdate -> { + val attributeData = + subscriptionState.updateState.successes + .filterIsInstance() + .firstOrNull { it.path.attributeId == ATTRIBUTE_ID } + + requireNotNull(attributeData) { + "Clusterrevision attribute not found in Node State update" + } + + // Decode the TLV data into the appropriate type + val tlvReader = TlvReader(attributeData.data) + val decodedValue: UShort = tlvReader.getUShort(AnonymousTag) + + emit(UShortSubscriptionState.Success(decodedValue)) + } + SubscriptionState.SubscriptionEstablished -> { + emit(UShortSubscriptionState.SubscriptionEstablished) + } + } + } + } + + companion object { + private val logger = Logger.getLogger(ThreadBorderRouterManagementCluster::class.java.name) + const val CLUSTER_ID: UInt = 1106u + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/files.gni b/src/controller/java/generated/java/matter/controller/cluster/files.gni index f62cee23bdd5b3..431b3eb8751913 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/files.gni +++ b/src/controller/java/generated/java/matter/controller/cluster/files.gni @@ -123,6 +123,10 @@ matter_structs_sources = [ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThermostatClusterScheduleTransitionStruct.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThermostatClusterScheduleTypeStruct.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThermostatClusterWeeklyScheduleTransitionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadNetworkDiagnosticsClusterNeighborTableStruct.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadNetworkDiagnosticsClusterOperationalDatasetComponents.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadNetworkDiagnosticsClusterRouteTableStruct.kt", @@ -330,6 +334,7 @@ matter_clusters_sources = [ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/TemperatureMeasurementCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ThermostatCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ThermostatUserInterfaceConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadBorderRouterManagementCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/ThreadNetworkDiagnosticsCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/TimeFormatLocalizationCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/clusters/TimerCluster.kt", diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt new file mode 100644 index 00000000000000..daff3dd5bb484e --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterChildTableStruct.kt @@ -0,0 +1,67 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.structs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterChildTableStruct( + val rloc16: UShort, + val linkQuality: UByte, + val routingRole: UByte +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterChildTableStruct {\n") + append("\trloc16 : $rloc16\n") + append("\tlinkQuality : $linkQuality\n") + append("\troutingRole : $routingRole\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + put(ContextSpecificTag(TAG_LINK_QUALITY), linkQuality) + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + endStructure() + } + } + + companion object { + private const val TAG_RLOC16 = 0 + private const val TAG_LINK_QUALITY = 1 + private const val TAG_ROUTING_ROLE = 2 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterChildTableStruct { + tlvReader.enterStructure(tlvTag) + val rloc16 = tlvReader.getUShort(ContextSpecificTag(TAG_RLOC16)) + val linkQuality = tlvReader.getUByte(ContextSpecificTag(TAG_LINK_QUALITY)) + val routingRole = tlvReader.getUByte(ContextSpecificTag(TAG_ROUTING_ROLE)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterChildTableStruct(rloc16, linkQuality, routingRole) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt new file mode 100644 index 00000000000000..b2544366c2e29e --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterNeiborTableStruct.kt @@ -0,0 +1,109 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.structs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterNeiborTableStruct( + val extAddress: ULong, + val age: UInt, + val rloc16: UShort, + val averageRssi: Byte?, + val lastRssi: Byte?, + val routingRole: UByte +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterNeiborTableStruct {\n") + append("\textAddress : $extAddress\n") + append("\tage : $age\n") + append("\trloc16 : $rloc16\n") + append("\taverageRssi : $averageRssi\n") + append("\tlastRssi : $lastRssi\n") + append("\troutingRole : $routingRole\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_EXT_ADDRESS), extAddress) + put(ContextSpecificTag(TAG_AGE), age) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + if (averageRssi != null) { + put(ContextSpecificTag(TAG_AVERAGE_RSSI), averageRssi) + } else { + putNull(ContextSpecificTag(TAG_AVERAGE_RSSI)) + } + if (lastRssi != null) { + put(ContextSpecificTag(TAG_LAST_RSSI), lastRssi) + } else { + putNull(ContextSpecificTag(TAG_LAST_RSSI)) + } + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + endStructure() + } + } + + companion object { + private const val TAG_EXT_ADDRESS = 0 + private const val TAG_AGE = 1 + private const val TAG_RLOC16 = 2 + private const val TAG_AVERAGE_RSSI = 3 + private const val TAG_LAST_RSSI = 4 + private const val TAG_ROUTING_ROLE = 5 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterNeiborTableStruct { + tlvReader.enterStructure(tlvTag) + val extAddress = tlvReader.getULong(ContextSpecificTag(TAG_EXT_ADDRESS)) + val age = tlvReader.getUInt(ContextSpecificTag(TAG_AGE)) + val rloc16 = tlvReader.getUShort(ContextSpecificTag(TAG_RLOC16)) + val averageRssi = + if (!tlvReader.isNull()) { + tlvReader.getByte(ContextSpecificTag(TAG_AVERAGE_RSSI)) + } else { + tlvReader.getNull(ContextSpecificTag(TAG_AVERAGE_RSSI)) + null + } + val lastRssi = + if (!tlvReader.isNull()) { + tlvReader.getByte(ContextSpecificTag(TAG_LAST_RSSI)) + } else { + tlvReader.getNull(ContextSpecificTag(TAG_LAST_RSSI)) + null + } + val routingRole = tlvReader.getUByte(ContextSpecificTag(TAG_ROUTING_ROLE)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterNeiborTableStruct( + extAddress, + age, + rloc16, + averageRssi, + lastRssi, + routingRole + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt new file mode 100644 index 00000000000000..d6f352f3db8be2 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterRouteTableStruct.kt @@ -0,0 +1,72 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.structs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterRouteTableStruct( + val routerId: UByte, + val pathCost: UByte, + val LQIIn: UByte, + val LQIOut: UByte +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterRouteTableStruct {\n") + append("\trouterId : $routerId\n") + append("\tpathCost : $pathCost\n") + append("\tLQIIn : $LQIIn\n") + append("\tLQIOut : $LQIOut\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ROUTER_ID), routerId) + put(ContextSpecificTag(TAG_PATH_COST), pathCost) + put(ContextSpecificTag(TAG_L_Q_I_IN), LQIIn) + put(ContextSpecificTag(TAG_L_Q_I_OUT), LQIOut) + endStructure() + } + } + + companion object { + private const val TAG_ROUTER_ID = 0 + private const val TAG_PATH_COST = 1 + private const val TAG_L_Q_I_IN = 2 + private const val TAG_L_Q_I_OUT = 3 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterRouteTableStruct { + tlvReader.enterStructure(tlvTag) + val routerId = tlvReader.getUByte(ContextSpecificTag(TAG_ROUTER_ID)) + val pathCost = tlvReader.getUByte(ContextSpecificTag(TAG_PATH_COST)) + val LQIIn = tlvReader.getUByte(ContextSpecificTag(TAG_L_Q_I_IN)) + val LQIOut = tlvReader.getUByte(ContextSpecificTag(TAG_L_Q_I_OUT)) + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterRouteTableStruct(routerId, pathCost, LQIIn, LQIOut) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt new file mode 100644 index 00000000000000..27bdec40817eba --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/ThreadBorderRouterManagementClusterThreadNodeStruct.kt @@ -0,0 +1,127 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.structs + +import matter.controller.cluster.* +import matter.tlv.AnonymousTag +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThreadBorderRouterManagementClusterThreadNodeStruct( + val extAddress: ULong, + val rloc16: UShort, + val IPv6s: List, + val routingRole: UByte, + val routeTable: List, + val childTable: List +) { + override fun toString(): String = buildString { + append("ThreadBorderRouterManagementClusterThreadNodeStruct {\n") + append("\textAddress : $extAddress\n") + append("\trloc16 : $rloc16\n") + append("\tIPv6s : $IPv6s\n") + append("\troutingRole : $routingRole\n") + append("\trouteTable : $routeTable\n") + append("\tchildTable : $childTable\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_EXT_ADDRESS), extAddress) + put(ContextSpecificTag(TAG_RLOC16), rloc16) + startArray(ContextSpecificTag(TAG_I_PV6S)) + for (item in IPv6s.iterator()) { + put(AnonymousTag, item) + } + endArray() + put(ContextSpecificTag(TAG_ROUTING_ROLE), routingRole) + startArray(ContextSpecificTag(TAG_ROUTE_TABLE)) + for (item in routeTable.iterator()) { + item.toTlv(AnonymousTag, this) + } + endArray() + startArray(ContextSpecificTag(TAG_CHILD_TABLE)) + for (item in childTable.iterator()) { + item.toTlv(AnonymousTag, this) + } + endArray() + endStructure() + } + } + + companion object { + private const val TAG_EXT_ADDRESS = 0 + private const val TAG_RLOC16 = 1 + private const val TAG_I_PV6S = 2 + private const val TAG_ROUTING_ROLE = 3 + private const val TAG_ROUTE_TABLE = 4 + private const val TAG_CHILD_TABLE = 5 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ThreadBorderRouterManagementClusterThreadNodeStruct { + tlvReader.enterStructure(tlvTag) + val extAddress = tlvReader.getULong(ContextSpecificTag(TAG_EXT_ADDRESS)) + val rloc16 = tlvReader.getUShort(ContextSpecificTag(TAG_RLOC16)) + val IPv6s = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_I_PV6S)) + while (!tlvReader.isEndOfContainer()) { + add(tlvReader.getByteArray(AnonymousTag)) + } + tlvReader.exitContainer() + } + val routingRole = tlvReader.getUByte(ContextSpecificTag(TAG_ROUTING_ROLE)) + val routeTable = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_ROUTE_TABLE)) + while (!tlvReader.isEndOfContainer()) { + add( + ThreadBorderRouterManagementClusterRouteTableStruct.fromTlv(AnonymousTag, tlvReader) + ) + } + tlvReader.exitContainer() + } + val childTable = + buildList { + tlvReader.enterArray(ContextSpecificTag(TAG_CHILD_TABLE)) + while (!tlvReader.isEndOfContainer()) { + add( + ThreadBorderRouterManagementClusterChildTableStruct.fromTlv(AnonymousTag, tlvReader) + ) + } + tlvReader.exitContainer() + } + + tlvReader.exitContainer() + + return ThreadBorderRouterManagementClusterThreadNodeStruct( + extAddress, + rloc16, + IPv6s, + routingRole, + routeTable, + childTable + ) + } + } +} diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp index 2400ba818c7cb9..4d8e0ef8af6d9a 100644 --- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp @@ -37156,6 +37156,414 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR } break; } + case app::Clusters::ThreadBorderRouterManagement::Id: { + using namespace app::Clusters::ThreadBorderRouterManagement; + switch (aPath.mAttributeId) + { + case Attributes::BorderRouterName::Id: { + using TypeInfo = Attributes::BorderRouterName::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(cppValue, value)); + return value; + } + case Attributes::BorderAgentId::Id: { + using TypeInfo = Attributes::BorderAgentId::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + jbyteArray valueByteArray = env->NewByteArray(static_cast(cppValue.size())); + env->SetByteArrayRegion(valueByteArray, 0, static_cast(cppValue.size()), + reinterpret_cast(cppValue.data())); + value = valueByteArray; + return value; + } + case Attributes::ThreadVersion::Id: { + using TypeInfo = Attributes::ThreadVersion::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::InterfaceEnabled::Id: { + using TypeInfo = Attributes::InterfaceEnabled::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Boolean"; + std::string valueCtorSignature = "(Z)V"; + jboolean jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + return value; + } + case Attributes::ThreadNode::Id: { + using TypeInfo = Attributes::ThreadNode::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + jobject value_extAddress; + std::string value_extAddressClassName = "java/lang/Long"; + std::string value_extAddressCtorSignature = "(J)V"; + jlong jnivalue_extAddress = static_cast(cppValue.extAddress); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_extAddressClassName.c_str(), value_extAddressCtorSignature.c_str(), jnivalue_extAddress, value_extAddress); + jobject value_rloc16; + std::string value_rloc16ClassName = "java/lang/Integer"; + std::string value_rloc16CtorSignature = "(I)V"; + jint jnivalue_rloc16 = static_cast(cppValue.rloc16); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_rloc16ClassName.c_str(), value_rloc16CtorSignature.c_str(), jnivalue_rloc16, value_rloc16); + jobject value_IPv6s; + chip::JniReferences::GetInstance().CreateArrayList(value_IPv6s); + + auto iter_value_IPv6s_1 = cppValue.IPv6s.begin(); + while (iter_value_IPv6s_1.Next()) + { + auto & entry_1 = iter_value_IPv6s_1.GetValue(); + jobject newElement_1; + jbyteArray newElement_1ByteArray = env->NewByteArray(static_cast(entry_1.size())); + env->SetByteArrayRegion(newElement_1ByteArray, 0, static_cast(entry_1.size()), + reinterpret_cast(entry_1.data())); + newElement_1 = newElement_1ByteArray; + chip::JniReferences::GetInstance().AddToList(value_IPv6s, newElement_1); + } + jobject value_routingRole; + std::string value_routingRoleClassName = "java/lang/Integer"; + std::string value_routingRoleCtorSignature = "(I)V"; + jint jnivalue_routingRole = static_cast(cppValue.routingRole); + chip::JniReferences::GetInstance().CreateBoxedObject(value_routingRoleClassName.c_str(), + value_routingRoleCtorSignature.c_str(), jnivalue_routingRole, + value_routingRole); + jobject value_routeTable; + chip::JniReferences::GetInstance().CreateArrayList(value_routeTable); + + auto iter_value_routeTable_1 = cppValue.routeTable.begin(); + while (iter_value_routeTable_1.Next()) + { + auto & entry_1 = iter_value_routeTable_1.GetValue(); + jobject newElement_1; + jobject newElement_1_routerId; + std::string newElement_1_routerIdClassName = "java/lang/Integer"; + std::string newElement_1_routerIdCtorSignature = "(I)V"; + jint jninewElement_1_routerId = static_cast(entry_1.routerId); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_routerIdClassName.c_str(), + newElement_1_routerIdCtorSignature.c_str(), + jninewElement_1_routerId, newElement_1_routerId); + jobject newElement_1_pathCost; + std::string newElement_1_pathCostClassName = "java/lang/Integer"; + std::string newElement_1_pathCostCtorSignature = "(I)V"; + jint jninewElement_1_pathCost = static_cast(entry_1.pathCost); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_pathCostClassName.c_str(), + newElement_1_pathCostCtorSignature.c_str(), + jninewElement_1_pathCost, newElement_1_pathCost); + jobject newElement_1_LQIIn; + std::string newElement_1_LQIInClassName = "java/lang/Integer"; + std::string newElement_1_LQIInCtorSignature = "(I)V"; + jint jninewElement_1_LQIIn = static_cast(entry_1.LQIIn); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_LQIInClassName.c_str(), + newElement_1_LQIInCtorSignature.c_str(), + jninewElement_1_LQIIn, newElement_1_LQIIn); + jobject newElement_1_LQIOut; + std::string newElement_1_LQIOutClassName = "java/lang/Integer"; + std::string newElement_1_LQIOutCtorSignature = "(I)V"; + jint jninewElement_1_LQIOut = static_cast(entry_1.LQIOut); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_LQIOutClassName.c_str(), + newElement_1_LQIOutCtorSignature.c_str(), + jninewElement_1_LQIOut, newElement_1_LQIOut); + + jclass routeTableStructStructClass_2; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipStructs$ThreadBorderRouterManagementClusterRouteTableStruct", + routeTableStructStructClass_2); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipStructs$ThreadBorderRouterManagementClusterRouteTableStruct"); + return nullptr; + } + + jmethodID routeTableStructStructCtor_2; + err = chip::JniReferences::GetInstance().FindMethod( + env, routeTableStructStructClass_2, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", + &routeTableStructStructCtor_2); + if (err != CHIP_NO_ERROR || routeTableStructStructCtor_2 == nullptr) + { + ChipLogError(Zcl, "Could not find ChipStructs$ThreadBorderRouterManagementClusterRouteTableStruct constructor"); + return nullptr; + } + + newElement_1 = env->NewObject(routeTableStructStructClass_2, routeTableStructStructCtor_2, newElement_1_routerId, + newElement_1_pathCost, newElement_1_LQIIn, newElement_1_LQIOut); + chip::JniReferences::GetInstance().AddToList(value_routeTable, newElement_1); + } + jobject value_childTable; + chip::JniReferences::GetInstance().CreateArrayList(value_childTable); + + auto iter_value_childTable_1 = cppValue.childTable.begin(); + while (iter_value_childTable_1.Next()) + { + auto & entry_1 = iter_value_childTable_1.GetValue(); + jobject newElement_1; + jobject newElement_1_rloc16; + std::string newElement_1_rloc16ClassName = "java/lang/Integer"; + std::string newElement_1_rloc16CtorSignature = "(I)V"; + jint jninewElement_1_rloc16 = static_cast(entry_1.rloc16); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_rloc16ClassName.c_str(), + newElement_1_rloc16CtorSignature.c_str(), + jninewElement_1_rloc16, newElement_1_rloc16); + jobject newElement_1_linkQuality; + std::string newElement_1_linkQualityClassName = "java/lang/Integer"; + std::string newElement_1_linkQualityCtorSignature = "(I)V"; + jint jninewElement_1_linkQuality = static_cast(entry_1.linkQuality); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_linkQualityClassName.c_str(), + newElement_1_linkQualityCtorSignature.c_str(), + jninewElement_1_linkQuality, newElement_1_linkQuality); + jobject newElement_1_routingRole; + std::string newElement_1_routingRoleClassName = "java/lang/Integer"; + std::string newElement_1_routingRoleCtorSignature = "(I)V"; + jint jninewElement_1_routingRole = static_cast(entry_1.routingRole); + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_1_routingRoleClassName.c_str(), + newElement_1_routingRoleCtorSignature.c_str(), + jninewElement_1_routingRole, newElement_1_routingRole); + + jclass childTableStructStructClass_2; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipStructs$ThreadBorderRouterManagementClusterChildTableStruct", + childTableStructStructClass_2); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipStructs$ThreadBorderRouterManagementClusterChildTableStruct"); + return nullptr; + } + + jmethodID childTableStructStructCtor_2; + err = chip::JniReferences::GetInstance().FindMethod(env, childTableStructStructClass_2, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", + &childTableStructStructCtor_2); + if (err != CHIP_NO_ERROR || childTableStructStructCtor_2 == nullptr) + { + ChipLogError(Zcl, "Could not find ChipStructs$ThreadBorderRouterManagementClusterChildTableStruct constructor"); + return nullptr; + } + + newElement_1 = env->NewObject(childTableStructStructClass_2, childTableStructStructCtor_2, newElement_1_rloc16, + newElement_1_linkQuality, newElement_1_routingRole); + chip::JniReferences::GetInstance().AddToList(value_childTable, newElement_1); + } + + jclass threadNodeStructStructClass_0; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipStructs$ThreadBorderRouterManagementClusterThreadNodeStruct", + threadNodeStructStructClass_0); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipStructs$ThreadBorderRouterManagementClusterThreadNodeStruct"); + return nullptr; + } + + jmethodID threadNodeStructStructCtor_0; + err = chip::JniReferences::GetInstance().FindMethod(env, threadNodeStructStructClass_0, "", + "(Ljava/lang/Long;Ljava/lang/Integer;Ljava/util/ArrayList;Ljava/" + "lang/Integer;Ljava/util/ArrayList;Ljava/util/ArrayList;)V", + &threadNodeStructStructCtor_0); + if (err != CHIP_NO_ERROR || threadNodeStructStructCtor_0 == nullptr) + { + ChipLogError(Zcl, "Could not find ChipStructs$ThreadBorderRouterManagementClusterThreadNodeStruct constructor"); + return nullptr; + } + + value = env->NewObject(threadNodeStructStructClass_0, threadNodeStructStructCtor_0, value_extAddress, value_rloc16, + value_IPv6s, value_routingRole, value_routeTable, value_childTable); + return value; + } + case Attributes::ActiveDatasetTimestamp::Id: { + using TypeInfo = Attributes::ActiveDatasetTimestamp::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::GeneratedCommandList::Id: { + using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AcceptedCommandList::Id: { + using TypeInfo = Attributes::AcceptedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::EventList::Id: { + using TypeInfo = Attributes::EventList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AttributeList::Id: { + using TypeInfo = Attributes::AttributeList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::FeatureMap::Id: { + using TypeInfo = Attributes::FeatureMap::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + return value; + } + case Attributes::ClusterRevision::Id: { + using TypeInfo = Attributes::ClusterRevision::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + break; + } + break; + } case app::Clusters::WakeOnLan::Id: { using namespace app::Clusters::WakeOnLan; switch (aPath.mAttributeId) diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index 370e510894c121..ed9d52786d8781 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -7389,6 +7389,16 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } + case app::Clusters::ThreadBorderRouterManagement::Id: { + using namespace app::Clusters::ThreadBorderRouterManagement; + switch (aPath.mEventId) + { + default: + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + break; + } + break; + } case app::Clusters::WakeOnLan::Id: { using namespace app::Clusters::WakeOnLan; switch (aPath.mEventId) diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 3bc715829f27db..3c15bd23de9724 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -11535,6 +11535,122 @@ class ChipClusters: }, }, } + _THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER_INFO = { + "clusterName": "ThreadBorderRouterManagement", + "clusterId": 0x00000452, + "commands": { + 0x00000000: { + "commandId": 0x00000000, + "commandName": "GetActiveDatasetRequest", + "args": { + }, + }, + 0x00000001: { + "commandId": 0x00000001, + "commandName": "GetPendingDatasetRequest", + "args": { + }, + }, + 0x00000003: { + "commandId": 0x00000003, + "commandName": "SetActiveDatasetRequest", + "args": { + "activeDataset": "bytes", + "breadcrumb": "int", + }, + }, + 0x00000004: { + "commandId": 0x00000004, + "commandName": "SetPendingDatasetRequest", + "args": { + "pendingDataset": "bytes", + }, + }, + 0x00000005: { + "commandId": 0x00000005, + "commandName": "TopologyRequest", + "args": { + "count": "int", + "startIndex": "int", + "snapshot": "int", + }, + }, + }, + "attributes": { + 0x00000000: { + "attributeName": "BorderRouterName", + "attributeId": 0x00000000, + "type": "str", + "reportable": True, + }, + 0x00000001: { + "attributeName": "BorderAgentId", + "attributeId": 0x00000001, + "type": "bytes", + "reportable": True, + }, + 0x00000002: { + "attributeName": "ThreadVersion", + "attributeId": 0x00000002, + "type": "int", + "reportable": True, + }, + 0x00000003: { + "attributeName": "InterfaceEnabled", + "attributeId": 0x00000003, + "type": "bool", + "reportable": True, + }, + 0x00000004: { + "attributeName": "ThreadNode", + "attributeId": 0x00000004, + "type": "", + "reportable": True, + }, + 0x00000005: { + "attributeName": "ActiveDatasetTimestamp", + "attributeId": 0x00000005, + "type": "int", + "reportable": True, + }, + 0x0000FFF8: { + "attributeName": "GeneratedCommandList", + "attributeId": 0x0000FFF8, + "type": "int", + "reportable": True, + }, + 0x0000FFF9: { + "attributeName": "AcceptedCommandList", + "attributeId": 0x0000FFF9, + "type": "int", + "reportable": True, + }, + 0x0000FFFA: { + "attributeName": "EventList", + "attributeId": 0x0000FFFA, + "type": "int", + "reportable": True, + }, + 0x0000FFFB: { + "attributeName": "AttributeList", + "attributeId": 0x0000FFFB, + "type": "int", + "reportable": True, + }, + 0x0000FFFC: { + "attributeName": "FeatureMap", + "attributeId": 0x0000FFFC, + "type": "int", + "reportable": True, + }, + 0x0000FFFD: { + "attributeName": "ClusterRevision", + "attributeId": 0x0000FFFD, + "type": "int", + "reportable": True, + }, + }, + } _WAKE_ON_LAN_CLUSTER_INFO = { "clusterName": "WakeOnLan", "clusterId": 0x00000503, @@ -14638,6 +14754,7 @@ class ChipClusters: 0x0000042D: _PM10_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, 0x0000042E: _TOTAL_VOLATILE_ORGANIC_COMPOUNDS_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, 0x0000042F: _RADON_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, + 0x00000452: _THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER_INFO, 0x00000503: _WAKE_ON_LAN_CLUSTER_INFO, 0x00000504: _CHANNEL_CLUSTER_INFO, 0x00000505: _TARGET_NAVIGATOR_CLUSTER_INFO, @@ -14759,6 +14876,7 @@ class ChipClusters: "Pm10ConcentrationMeasurement": _PM10_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, "TotalVolatileOrganicCompoundsConcentrationMeasurement": _TOTAL_VOLATILE_ORGANIC_COMPOUNDS_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, "RadonConcentrationMeasurement": _RADON_CONCENTRATION_MEASUREMENT_CLUSTER_INFO, + "ThreadBorderRouterManagement": _THREAD_BORDER_ROUTER_MANAGEMENT_CLUSTER_INFO, "WakeOnLan": _WAKE_ON_LAN_CLUSTER_INFO, "Channel": _CHANNEL_CLUSTER_INFO, "TargetNavigator": _TARGET_NAVIGATOR_CLUSTER_INFO, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index cd411b93d43301..747db4dd92cf79 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -40230,6 +40230,448 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = 0 +@dataclass +class ThreadBorderRouterManagement(Cluster): + id: typing.ClassVar[int] = 0x00000452 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="borderRouterName", Tag=0x00000000, Type=str), + ClusterObjectFieldDescriptor(Label="borderAgentId", Tag=0x00000001, Type=bytes), + ClusterObjectFieldDescriptor(Label="threadVersion", Tag=0x00000002, Type=uint), + ClusterObjectFieldDescriptor(Label="interfaceEnabled", Tag=0x00000003, Type=bool), + ClusterObjectFieldDescriptor(Label="threadNode", Tag=0x00000004, Type=ThreadBorderRouterManagement.Structs.ThreadNodeStruct), + ClusterObjectFieldDescriptor(Label="activeDatasetTimestamp", Tag=0x00000005, Type=typing.Union[Nullable, uint]), + ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint), + ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint), + ]) + + borderRouterName: 'str' = None + borderAgentId: 'bytes' = None + threadVersion: 'uint' = None + interfaceEnabled: 'bool' = None + threadNode: 'ThreadBorderRouterManagement.Structs.ThreadNodeStruct' = None + activeDatasetTimestamp: 'typing.Union[Nullable, uint]' = None + generatedCommandList: 'typing.List[uint]' = None + acceptedCommandList: 'typing.List[uint]' = None + eventList: 'typing.List[uint]' = None + attributeList: 'typing.List[uint]' = None + featureMap: 'uint' = None + clusterRevision: 'uint' = None + + class Enums: + class RoutingRoleEnum(MatterIntEnum): + kUnspecified = 0x00 + kUnassigned = 0x01 + kSleepyEndDevice = 0x02 + kEndDevice = 0x03 + kReed = 0x04 + kRouter = 0x05 + kLeader = 0x06 + # All received enum values that are not listed above will be mapped + # to kUnknownEnumValue. This is a helper enum value that should only + # be used by code to process how it handles receiving and unknown + # enum value. This specific should never be transmitted. + kUnknownEnumValue = 7, + + class Bitmaps: + class Feature(IntFlag): + kPANChange = 0x1 + + class Structs: + @dataclass + class ChildTableStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="rloc16", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="linkQuality", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="routingRole", Tag=2, Type=ThreadBorderRouterManagement.Enums.RoutingRoleEnum), + ]) + + rloc16: 'uint' = 0 + linkQuality: 'uint' = 0 + routingRole: 'ThreadBorderRouterManagement.Enums.RoutingRoleEnum' = 0 + + @dataclass + class RouteTableStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="routerId", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="pathCost", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="LQIIn", Tag=2, Type=uint), + ClusterObjectFieldDescriptor(Label="LQIOut", Tag=3, Type=uint), + ]) + + routerId: 'uint' = 0 + pathCost: 'uint' = 0 + LQIIn: 'uint' = 0 + LQIOut: 'uint' = 0 + + @dataclass + class ThreadNodeStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="extAddress", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="rloc16", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="IPv6s", Tag=2, Type=typing.List[bytes]), + ClusterObjectFieldDescriptor(Label="routingRole", Tag=3, Type=ThreadBorderRouterManagement.Enums.RoutingRoleEnum), + ClusterObjectFieldDescriptor(Label="routeTable", Tag=4, Type=typing.List[ThreadBorderRouterManagement.Structs.RouteTableStruct]), + ClusterObjectFieldDescriptor(Label="childTable", Tag=5, Type=typing.List[ThreadBorderRouterManagement.Structs.ChildTableStruct]), + ]) + + extAddress: 'uint' = 0 + rloc16: 'uint' = 0 + IPv6s: 'typing.List[bytes]' = field(default_factory=lambda: []) + routingRole: 'ThreadBorderRouterManagement.Enums.RoutingRoleEnum' = 0 + routeTable: 'typing.List[ThreadBorderRouterManagement.Structs.RouteTableStruct]' = field(default_factory=lambda: []) + childTable: 'typing.List[ThreadBorderRouterManagement.Structs.ChildTableStruct]' = field(default_factory=lambda: []) + + @dataclass + class NeiborTableStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="extAddress", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="age", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="rloc16", Tag=2, Type=uint), + ClusterObjectFieldDescriptor(Label="averageRssi", Tag=3, Type=typing.Union[Nullable, int]), + ClusterObjectFieldDescriptor(Label="lastRssi", Tag=4, Type=typing.Union[Nullable, int]), + ClusterObjectFieldDescriptor(Label="routingRole", Tag=5, Type=ThreadBorderRouterManagement.Enums.RoutingRoleEnum), + ]) + + extAddress: 'uint' = 0 + age: 'uint' = 0 + rloc16: 'uint' = 0 + averageRssi: 'typing.Union[Nullable, int]' = NullValue + lastRssi: 'typing.Union[Nullable, int]' = NullValue + routingRole: 'ThreadBorderRouterManagement.Enums.RoutingRoleEnum' = 0 + + class Commands: + @dataclass + class GetActiveDatasetRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000000 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = 'DatasetResponse' + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + @dataclass + class GetPendingDatasetRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000001 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = 'DatasetResponse' + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + @dataclass + class DatasetResponse(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000002 + is_client: typing.ClassVar[bool] = False + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="dataset", Tag=0, Type=bytes), + ]) + + dataset: 'bytes' = b"" + + @dataclass + class SetActiveDatasetRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000003 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="activeDataset", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="breadcrumb", Tag=1, Type=uint), + ]) + + activeDataset: 'bytes' = b"" + breadcrumb: 'uint' = 0 + + @dataclass + class SetPendingDatasetRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000004 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="pendingDataset", Tag=0, Type=bytes), + ]) + + pendingDataset: 'bytes' = b"" + + @dataclass + class TopologyRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000005 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = 'TopologyResponse' + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="count", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="startIndex", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="snapshot", Tag=2, Type=uint), + ]) + + count: 'uint' = 0 + startIndex: 'uint' = 0 + snapshot: 'uint' = 0 + + @dataclass + class TopologyResponse(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000452 + command_id: typing.ClassVar[int] = 0x00000006 + is_client: typing.ClassVar[bool] = False + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="status", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="snapshot", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="numberOfDevices", Tag=2, Type=uint), + ClusterObjectFieldDescriptor(Label="threadTopology", Tag=3, Type=typing.List[ThreadBorderRouterManagement.Structs.ThreadNodeStruct]), + ]) + + status: 'uint' = 0 + snapshot: 'uint' = 0 + numberOfDevices: 'uint' = 0 + threadTopology: 'typing.List[ThreadBorderRouterManagement.Structs.ThreadNodeStruct]' = field(default_factory=lambda: []) + + class Attributes: + @dataclass + class BorderRouterName(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=str) + + value: 'str' = "" + + @dataclass + class BorderAgentId(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=bytes) + + value: 'bytes' = b"" + + @dataclass + class ThreadVersion(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class InterfaceEnabled(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=bool) + + value: 'bool' = False + + @dataclass + class ThreadNode(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000004 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=ThreadBorderRouterManagement.Structs.ThreadNodeStruct) + + value: 'ThreadBorderRouterManagement.Structs.ThreadNodeStruct' = field(default_factory=lambda: ThreadBorderRouterManagement.Structs.ThreadNodeStruct()) + + @dataclass + class ActiveDatasetTimestamp(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000005 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = NullValue + + @dataclass + class GeneratedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF8 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AcceptedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF9 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class EventList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFA + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AttributeList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFB + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class FeatureMap(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFC + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class ClusterRevision(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000452 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFD + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass class WakeOnLan(Cluster): id: typing.ClassVar[int] = 0x00000503 diff --git a/src/controller/python/chip/clusters/__init__.py b/src/controller/python/chip/clusters/__init__.py index 44d9910c670098..be307d1c9c34e3 100644 --- a/src/controller/python/chip/clusters/__init__.py +++ b/src/controller/python/chip/clusters/__init__.py @@ -43,8 +43,8 @@ RadonConcentrationMeasurement, RefrigeratorAlarm, RefrigeratorAndTemperatureControlledCabinetMode, RelativeHumidityMeasurement, RvcCleanMode, RvcOperationalState, RvcRunMode, ScenesManagement, SmokeCoAlarm, SoftwareDiagnostics, Switch, TargetNavigator, TemperatureControl, TemperatureMeasurement, Thermostat, - ThermostatUserInterfaceConfiguration, ThreadNetworkDiagnostics, TimeFormatLocalization, TimeSynchronization, - TotalVolatileOrganicCompoundsConcentrationMeasurement, UnitLocalization, UnitTesting, UserLabel, + ThermostatUserInterfaceConfiguration, ThreadBorderRouterManagement, ThreadNetworkDiagnostics, TimeFormatLocalization, + TimeSynchronization, TotalVolatileOrganicCompoundsConcentrationMeasurement, UnitLocalization, UnitTesting, UserLabel, ValveConfigurationAndControl, WakeOnLan, WiFiNetworkDiagnostics, WindowCovering) __all__ = [Attribute, CHIPClusters, Command, AccessControl, AccountLogin, Actions, ActivatedCarbonFilterMonitoring, AdministratorCommissioning, AirQuality, @@ -66,6 +66,6 @@ RefrigeratorAlarm, RefrigeratorAndTemperatureControlledCabinetMode, RelativeHumidityMeasurement, RvcCleanMode, RvcOperationalState, RvcRunMode, ScenesManagement, SmokeCoAlarm, SoftwareDiagnostics, Switch, TargetNavigator, TemperatureControl, TemperatureMeasurement, Thermostat, ThermostatUserInterfaceConfiguration, - ThreadNetworkDiagnostics, TimeFormatLocalization, TimeSynchronization, + ThreadBorderRouterManagement, ThreadNetworkDiagnostics, TimeFormatLocalization, TimeSynchronization, TotalVolatileOrganicCompoundsConcentrationMeasurement, UnitLocalization, UnitTesting, UserLabel, ValveConfigurationAndControl, WakeOnLan, WiFiNetworkDiagnostics, WindowCovering] diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index cb98d807f3495d..2b4e1b7459d342 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -5288,6 +5288,51 @@ static BOOL AttributeIsSpecifiedInRadonConcentrationMeasurementCluster(Attribute } } } +static BOOL AttributeIsSpecifiedInThreadBorderRouterManagementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ThreadBorderRouterManagement; + switch (aAttributeId) { + case Attributes::BorderRouterName::Id: { + return YES; + } + case Attributes::BorderAgentId::Id: { + return YES; + } + case Attributes::ThreadVersion::Id: { + return YES; + } + case Attributes::InterfaceEnabled::Id: { + return YES; + } + case Attributes::ThreadNode::Id: { + return YES; + } + case Attributes::ActiveDatasetTimestamp::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} static BOOL AttributeIsSpecifiedInWakeOnLANCluster(AttributeId aAttributeId) { using namespace Clusters::WakeOnLan; @@ -6804,6 +6849,9 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId) case Clusters::RadonConcentrationMeasurement::Id: { return AttributeIsSpecifiedInRadonConcentrationMeasurementCluster(aAttributeId); } + case Clusters::ThreadBorderRouterManagement::Id: { + return AttributeIsSpecifiedInThreadBorderRouterManagementCluster(aAttributeId); + } case Clusters::WakeOnLan::Id: { return AttributeIsSpecifiedInWakeOnLANCluster(aAttributeId); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index bae1643f3beb39..87a96d160a7f5b 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -15219,6 +15219,151 @@ static id _Nullable DecodeAttributeValueForRadonConcentrationMeasurementCluster( *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; return nil; } +static id _Nullable DecodeAttributeValueForThreadBorderRouterManagementCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::ThreadBorderRouterManagement; + switch (aAttributeId) { + case Attributes::BorderRouterName::Id: { + using TypeInfo = Attributes::BorderRouterName::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSString * _Nonnull value; + value = AsString(cppValue); + if (value == nil) { + CHIP_ERROR err = CHIP_ERROR_INVALID_ARGUMENT; + *aError = err; + return nil; + } + return value; + } + case Attributes::BorderAgentId::Id: { + using TypeInfo = Attributes::BorderAgentId::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSData * _Nonnull value; + value = AsData(cppValue); + return value; + } + case Attributes::ThreadVersion::Id: { + using TypeInfo = Attributes::ThreadVersion::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedShort:cppValue]; + return value; + } + case Attributes::InterfaceEnabled::Id: { + using TypeInfo = Attributes::InterfaceEnabled::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithBool:cppValue]; + return value; + } + case Attributes::ThreadNode::Id: { + using TypeInfo = Attributes::ThreadNode::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nonnull value; + value = [MTRThreadBorderRouterManagementClusterThreadNodeStruct new]; + value.extAddress = [NSNumber numberWithUnsignedLongLong:cppValue.extAddress]; + value.rloc16 = [NSNumber numberWithUnsignedShort:cppValue.rloc16]; + { // Scope for our temporary variables + auto * array_1 = [NSMutableArray new]; + auto iter_1 = cppValue.IPv6s.begin(); + while (iter_1.Next()) { + auto & entry_1 = iter_1.GetValue(); + NSData * newElement_1; + newElement_1 = AsData(entry_1); + [array_1 addObject:newElement_1]; + } + CHIP_ERROR err = iter_1.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value.iPv6s = array_1; + } + value.routingRole = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.routingRole)]; + { // Scope for our temporary variables + auto * array_1 = [NSMutableArray new]; + auto iter_1 = cppValue.routeTable.begin(); + while (iter_1.Next()) { + auto & entry_1 = iter_1.GetValue(); + MTRThreadBorderRouterManagementClusterRouteTableStruct * newElement_1; + newElement_1 = [MTRThreadBorderRouterManagementClusterRouteTableStruct new]; + newElement_1.routerId = [NSNumber numberWithUnsignedChar:entry_1.routerId]; + newElement_1.pathCost = [NSNumber numberWithUnsignedChar:entry_1.pathCost]; + newElement_1.lqiIn = [NSNumber numberWithUnsignedChar:entry_1.LQIIn]; + newElement_1.lqiOut = [NSNumber numberWithUnsignedChar:entry_1.LQIOut]; + [array_1 addObject:newElement_1]; + } + CHIP_ERROR err = iter_1.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value.routeTable = array_1; + } + { // Scope for our temporary variables + auto * array_1 = [NSMutableArray new]; + auto iter_1 = cppValue.childTable.begin(); + while (iter_1.Next()) { + auto & entry_1 = iter_1.GetValue(); + MTRThreadBorderRouterManagementClusterChildTableStruct * newElement_1; + newElement_1 = [MTRThreadBorderRouterManagementClusterChildTableStruct new]; + newElement_1.rloc16 = [NSNumber numberWithUnsignedShort:entry_1.rloc16]; + newElement_1.linkQuality = [NSNumber numberWithUnsignedChar:entry_1.linkQuality]; + newElement_1.routingRole = [NSNumber numberWithUnsignedChar:chip::to_underlying(entry_1.routingRole)]; + [array_1 addObject:newElement_1]; + } + CHIP_ERROR err = iter_1.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value.childTable = array_1; + } + return value; + } + case Attributes::ActiveDatasetTimestamp::Id: { + using TypeInfo = Attributes::ActiveDatasetTimestamp::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedLongLong:cppValue.Value()]; + } + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + return nil; +} static id _Nullable DecodeAttributeValueForWakeOnLANCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::WakeOnLan; @@ -19593,6 +19738,9 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T case Clusters::RadonConcentrationMeasurement::Id: { return DecodeAttributeValueForRadonConcentrationMeasurementCluster(aPath.mAttributeId, aReader, aError); } + case Clusters::ThreadBorderRouterManagement::Id: { + return DecodeAttributeValueForThreadBorderRouterManagementCluster(aPath.mAttributeId, aReader, aError); + } case Clusters::WakeOnLan::Id: { return DecodeAttributeValueForWakeOnLANCluster(aPath.mAttributeId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index 3c7624201d0484..a9ba833c07b336 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -12989,6 +12989,138 @@ MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) @end +/** + * Cluster Thread Border Router Management + * + * Thread BR management + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBaseClusterThreadBorderRouterManagement : MTRGenericBaseCluster + +/** + * Command GetActiveDatasetRequest + * + * On receipt of this command, the Thread Border Router will read the active operational dataset of the Thread network that it is connaected to, and send the DatasetResponse as the response. This command must be sent over a valid CASE session + */ +- (void)getActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams * _Nullable)params completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)getActiveDatasetRequestWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion + MTR_PROVISIONALLY_AVAILABLE; +/** + * Command GetPendingDatasetRequest + * + * On receipt of this command, the Thread Border Router will read the pending dataset and send the DatasetResponse as the response. This command must be sent over a valid CASE session + */ +- (void)getPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams * _Nullable)params completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)getPendingDatasetRequestWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion + MTR_PROVISIONALLY_AVAILABLE; +/** + * Command SetActiveDatasetRequest + * + * On receipt of this command, the Thread Border Router will set or update the active Dataset of the Thread network that the Stub Router is connected to. + */ +- (void)setActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams *)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +/** + * Command SetPendingDatasetRequest + * + * On receipt of this command, the Thread Border Router will set or update the pending Dataset + */ +- (void)setPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams *)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +/** + * Command TopologyRequest + * + * On receipt of this command, the Thread Border Router will response the current topology of the Thread network that it is connected to. + */ +- (void)topologyRequestWithParams:(MTRThreadBorderRouterManagementClusterTopologyRequestParams *)params completion:(void (^)(MTRThreadBorderRouterManagementClusterTopologyResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeBorderRouterNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeBorderRouterNameWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeBorderRouterNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeBorderAgentIdWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeBorderAgentIdWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeBorderAgentIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeThreadVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeThreadVersionWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeThreadVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeInterfaceEnabledWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeInterfaceEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeThreadNodeWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeThreadNodeWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeThreadNodeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeActiveDatasetTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeActiveDatasetTimestampWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeActiveDatasetTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRBaseClusterThreadBorderRouterManagement (Availability) + +/** + * For all instance methods (reads, writes, commands) that take a completion, + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRBaseDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + /** * Cluster Wake on LAN * @@ -19483,6 +19615,20 @@ typedef NS_OPTIONS(uint32_t, MTRRadonConcentrationMeasurementFeature) { MTRRadonConcentrationMeasurementFeatureAverageMeasurement MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = 0x20, } MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)); +typedef NS_ENUM(uint8_t, MTRThreadBorderRouterManagementRoutingRole) { + MTRThreadBorderRouterManagementRoutingRoleUnspecified MTR_PROVISIONALLY_AVAILABLE = 0x00, + MTRThreadBorderRouterManagementRoutingRoleUnassigned MTR_PROVISIONALLY_AVAILABLE = 0x01, + MTRThreadBorderRouterManagementRoutingRoleSleepyEndDevice MTR_PROVISIONALLY_AVAILABLE = 0x02, + MTRThreadBorderRouterManagementRoutingRoleEndDevice MTR_PROVISIONALLY_AVAILABLE = 0x03, + MTRThreadBorderRouterManagementRoutingRoleREED MTR_PROVISIONALLY_AVAILABLE = 0x04, + MTRThreadBorderRouterManagementRoutingRoleRouter MTR_PROVISIONALLY_AVAILABLE = 0x05, + MTRThreadBorderRouterManagementRoutingRoleLeader MTR_PROVISIONALLY_AVAILABLE = 0x06, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint32_t, MTRThreadBorderRouterManagementFeature) { + MTRThreadBorderRouterManagementFeaturePANChange MTR_PROVISIONALLY_AVAILABLE = 0x1, +} MTR_PROVISIONALLY_AVAILABLE; + typedef NS_ENUM(uint8_t, MTRChannelType) { MTRChannelTypeSatellite MTR_PROVISIONALLY_AVAILABLE = 0x00, MTRChannelTypeCable MTR_PROVISIONALLY_AVAILABLE = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index b375488f292fc8..e67baae0040e01 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -92894,6 +92894,571 @@ + (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheC @end +@implementation MTRBaseClusterThreadBorderRouterManagement + +- (void)getActiveDatasetRequestWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + [self getActiveDatasetRequestWithParams:nil completion:completion]; +} +- (void)getActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams * _Nullable)params completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterDatasetResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)getPendingDatasetRequestWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + [self getPendingDatasetRequestWithParams:nil completion:completion]; +} +- (void)getPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams * _Nullable)params completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterDatasetResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)setActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams *)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)setPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams *)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)topologyRequestWithParams:(MTRThreadBorderRouterManagementClusterTopologyRequestParams *)params completion:(void (^)(MTRThreadBorderRouterManagementClusterTopologyResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterTopologyRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::TopologyRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterTopologyResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)readAttributeBorderRouterNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderRouterName::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeBorderRouterNameWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderRouterName::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeBorderRouterNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderRouterName::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeBorderAgentIdWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderAgentId::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeBorderAgentIdWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderAgentId::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeBorderAgentIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::BorderAgentId::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeThreadVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadVersion::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeThreadVersionWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadVersion::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeThreadVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadVersion::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::InterfaceEnabled::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeInterfaceEnabledWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::InterfaceEnabled::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeInterfaceEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::InterfaceEnabled::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeThreadNodeWithCompletion:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadNode::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeThreadNodeWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadNode::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeThreadNodeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ThreadNode::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeActiveDatasetTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeActiveDatasetTimestampWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeActiveDatasetTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::GeneratedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::GeneratedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::GeneratedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AcceptedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AcceptedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AcceptedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::EventList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::EventList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::EventList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AttributeList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AttributeList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::AttributeList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::FeatureMap::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::FeatureMap::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::FeatureMap::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ClusterRevision::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ClusterRevision::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ThreadBorderRouterManagement::Attributes::ClusterRevision::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +@end + @implementation MTRBaseClusterWakeOnLAN - (void)readAttributeMACAddressWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 5c3f6a080fdd7b..65203988d929e0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -184,6 +184,7 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) { MTRClusterIDTypePM10ConcentrationMeasurementID MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = 0x0000042D, MTRClusterIDTypeTotalVolatileOrganicCompoundsConcentrationMeasurementID MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = 0x0000042E, MTRClusterIDTypeRadonConcentrationMeasurementID MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = 0x0000042F, + MTRClusterIDTypeThreadBorderRouterManagementID MTR_PROVISIONALLY_AVAILABLE = 0x00000452, MTRClusterIDTypeWakeOnLANID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000503, MTRClusterIDTypeChannelID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000504, MTRClusterIDTypeTargetNavigatorID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000505, @@ -4361,6 +4362,20 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterRadonConcentrationMeasurementAttributeFeatureMapID MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = MTRAttributeIDTypeGlobalAttributeFeatureMapID, MTRAttributeIDTypeClusterRadonConcentrationMeasurementAttributeClusterRevisionID MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster ThreadBorderRouterManagement attributes + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderRouterNameID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderAgentIdID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadVersionID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeInterfaceEnabledID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadNodeID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeActiveDatasetTimestampID MTR_PROVISIONALLY_AVAILABLE = 0x00000005, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeEventListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, + MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster WakeOnLan deprecated attribute names MTRClusterWakeOnLanAttributeMACAddressID MTR_DEPRECATED("Please use MTRAttributeIDTypeClusterWakeOnLANAttributeMACAddressID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) @@ -6575,6 +6590,15 @@ typedef NS_ENUM(uint32_t, MTRCommandIDType) { MTRCommandIDTypeClusterColorControlCommandMoveColorTemperatureID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x0000004B, MTRCommandIDTypeClusterColorControlCommandStepColorTemperatureID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x0000004C, + // Cluster ThreadBorderRouterManagement commands + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandGetActiveDatasetRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandGetPendingDatasetRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandDatasetResponseID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandSetActiveDatasetRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandSetPendingDatasetRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandTopologyRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000005, + MTRCommandIDTypeClusterThreadBorderRouterManagementCommandTopologyResponseID MTR_PROVISIONALLY_AVAILABLE = 0x00000006, + // Cluster Channel deprecated command id names MTRClusterChannelCommandChangeChannelID MTR_DEPRECATED("Please use MTRCommandIDTypeClusterChannelCommandChangeChannelID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm index 474c5cacf47679..1760023379286f 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm @@ -318,6 +318,9 @@ case MTRClusterIDTypeRadonConcentrationMeasurementID: result = @"RadonConcentrationMeasurement"; break; + case MTRClusterIDTypeThreadBorderRouterManagementID: + result = @"ThreadBorderRouterManagement"; + break; case MTRClusterIDTypeWakeOnLANID: result = @"WakeOnLAN"; break; @@ -7212,6 +7215,64 @@ break; } + case MTRClusterIDTypeThreadBorderRouterManagementID: + + switch (attributeID) { + + // Cluster ThreadBorderRouterManagement attributes + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderRouterNameID: + result = @"BorderRouterName"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderAgentIdID: + result = @"BorderAgentId"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadVersionID: + result = @"ThreadVersion"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeInterfaceEnabledID: + result = @"InterfaceEnabled"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadNodeID: + result = @"ThreadNode"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeActiveDatasetTimestampID: + result = @"ActiveDatasetTimestamp"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeGeneratedCommandListID: + result = @"GeneratedCommandList"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAcceptedCommandListID: + result = @"AcceptedCommandList"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeEventListID: + result = @"EventList"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAttributeListID: + result = @"AttributeList"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeFeatureMapID: + result = @"FeatureMap"; + break; + + case MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeClusterRevisionID: + result = @"ClusterRevision"; + break; + + default: + result = [NSString stringWithFormat:@"", attributeID]; + break; + } + case MTRClusterIDTypeWakeOnLANID: switch (attributeID) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index 6e4e0f80b44d00..2e51e22b97690b 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -5993,6 +5993,64 @@ MTR_AVAILABLE(ios(17.6), macos(14.6), watchos(10.6), tvos(17.6)) @end +/** + * Cluster Thread Border Router Management + * Thread BR management + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRClusterThreadBorderRouterManagement : MTRGenericCluster + +- (void)getActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)getActiveDatasetRequestWithExpectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion + MTR_PROVISIONALLY_AVAILABLE; +- (void)getPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)getPendingDatasetRequestWithExpectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion + MTR_PROVISIONALLY_AVAILABLE; +- (void)setActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)setPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)topologyRequestWithParams:(MTRThreadBorderRouterManagementClusterTopologyRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterTopologyResponseParams * _Nullable data, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeBorderRouterNameWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeBorderAgentIdWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeThreadVersionWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeInterfaceEnabledWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeThreadNodeWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeActiveDatasetTimestampWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRClusterThreadBorderRouterManagement (Availability) + +/** + * For all instance methods that take a completion (i.e. command invocations), + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + /** * Cluster Wake on LAN * This cluster provides an interface for managing low power mode on a device that supports the Wake On LAN protocol. diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index db279250cac8bf..a2f8082f0286cf 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -16768,6 +16768,213 @@ @implementation MTRClusterRadonConcentrationMeasurement @end +@implementation MTRClusterThreadBorderRouterManagement + +- (void)getActiveDatasetRequestWithExpectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + [self getActiveDatasetRequestWithParams:nil expectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs completion:completion]; +} +- (void)getActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterDatasetResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)getPendingDatasetRequestWithExpectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + [self getPendingDatasetRequestWithParams:nil expectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs completion:completion]; +} +- (void)getPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterDatasetResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)setActiveDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)setPendingDatasetRequestWithParams:(MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)topologyRequestWithParams:(MTRThreadBorderRouterManagementClusterTopologyRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(void (^)(MTRThreadBorderRouterManagementClusterTopologyResponseParams * _Nullable data, NSError * _Nullable error))completion +{ + if (params == nil) { + params = [[MTRThreadBorderRouterManagementClusterTopologyRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(response, error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ThreadBorderRouterManagement::Commands::TopologyRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:self.endpointID + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:MTRThreadBorderRouterManagementClusterTopologyResponseParams.class + queue:self.callbackQueue + completion:responseHandler]; +} + +- (NSDictionary * _Nullable)readAttributeBorderRouterNameWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderRouterNameID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeBorderAgentIdWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeBorderAgentIdID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeThreadVersionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadVersionID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeInterfaceEnabledWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeInterfaceEnabledID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeThreadNodeWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeThreadNodeID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeActiveDatasetTimestampWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeActiveDatasetTimestampID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeGeneratedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAcceptedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeEventListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeAttributeListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeFeatureMapID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:self.endpointID clusterID:@(MTRClusterIDTypeThreadBorderRouterManagementID) attributeID:@(MTRAttributeIDTypeClusterThreadBorderRouterManagementAttributeClusterRevisionID) params:params]; +} + +@end + @implementation MTRClusterWakeOnLAN - (NSDictionary * _Nullable)readAttributeMACAddressWithParams:(MTRReadParams * _Nullable)params diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h index 1d1552200b5b1c..b47a4fde335ec5 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h @@ -8512,6 +8512,202 @@ MTR_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) @property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams : NSObject +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams : NSObject +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterDatasetResponseParams : NSObject + +@property (nonatomic, copy) NSData * _Nonnull dataset MTR_PROVISIONALLY_AVAILABLE; + +/** + * Initialize an MTRThreadBorderRouterManagementClusterDatasetResponseParams with a response-value dictionary + * of the sort that MTRDeviceResponseHandler would receive. + * + * Will return nil and hand out an error if the response-value dictionary is not + * a command data response or is not the right command response. + * + * Will return nil and hand out an error if the data response does not match the known + * schema for this command. + */ +- (nullable instancetype)initWithResponseValue:(NSDictionary *)responseValue + error:(NSError * __autoreleasing *)error MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams : NSObject + +@property (nonatomic, copy) NSData * _Nonnull activeDataset MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nonnull breadcrumb MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams : NSObject + +@property (nonatomic, copy) NSData * _Nonnull pendingDataset MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterTopologyRequestParams : NSObject + +@property (nonatomic, copy, getter=getCount) NSNumber * _Nonnull count MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nonnull startIndex MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nonnull snapshot MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterTopologyResponseParams : NSObject + +@property (nonatomic, copy) NSNumber * _Nonnull status MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nonnull snapshot MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nonnull numberOfDevices MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSArray * _Nonnull threadTopology MTR_PROVISIONALLY_AVAILABLE; + +/** + * Initialize an MTRThreadBorderRouterManagementClusterTopologyResponseParams with a response-value dictionary + * of the sort that MTRDeviceResponseHandler would receive. + * + * Will return nil and hand out an error if the response-value dictionary is not + * a command data response or is not the right command response. + * + * Will return nil and hand out an error if the data response does not match the known + * schema for this command. + */ +- (nullable instancetype)initWithResponseValue:(NSDictionary *)responseValue + error:(NSError * __autoreleasing *)error MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)) @interface MTRChannelClusterChangeChannelParams : NSObject diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm index 3105c9a9d21f80..86d1edc541c920 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm @@ -23968,6 +23968,652 @@ - (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader } @end +@implementation MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams +- (instancetype)init +{ + if (self = [super init]) { + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams alloc] init]; + + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: >", NSStringFromClass([self class])]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Type encodableStruct; + ListFreer listFreer; + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams +- (instancetype)init +{ + if (self = [super init]) { + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams alloc] init]; + + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: >", NSStringFromClass([self class])]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Type encodableStruct; + ListFreer listFreer; + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRThreadBorderRouterManagementClusterDatasetResponseParams +- (instancetype)init +{ + if (self = [super init]) { + + _dataset = [NSData data]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterDatasetResponseParams alloc] init]; + + other.dataset = self.dataset; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: dataset:%@; >", NSStringFromClass([self class]), [_dataset base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +- (nullable instancetype)initWithResponseValue:(NSDictionary *)responseValue + error:(NSError * __autoreleasing *)error +{ + if (!(self = [super init])) { + return nil; + } + + using DecodableType = chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType; + chip::System::PacketBufferHandle buffer = [MTRBaseDevice _responseDataForCommand:responseValue + clusterID:DecodableType::GetClusterId() + commandID:DecodableType::GetCommandId() + error:error]; + if (buffer.IsNull()) { + return nil; + } + + chip::TLV::TLVReader reader; + reader.Init(buffer->Start(), buffer->DataLength()); + + CHIP_ERROR err = reader.Next(chip::TLV::AnonymousTag()); + if (err == CHIP_NO_ERROR) { + DecodableType decodedStruct; + err = chip::app::DataModel::Decode(reader, decodedStruct); + if (err == CHIP_NO_ERROR) { + err = [self _setFieldsFromDecodableStruct:decodedStruct]; + if (err == CHIP_NO_ERROR) { + return self; + } + } + } + + NSString * errorStr = [NSString stringWithFormat:@"Command payload decoding failed: %s", err.AsString()]; + MTR_LOG_ERROR("%s", errorStr.UTF8String); + if (error != nil) { + NSDictionary * userInfo = @{ NSLocalizedFailureReasonErrorKey : NSLocalizedString(errorStr, nil) }; + *error = [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeSchemaMismatch userInfo:userInfo]; + } + return nil; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterDatasetResponseParams (InternalMethods) + +- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType &)decodableStruct +{ + { + self.dataset = AsData(decodableStruct.dataset); + } + return CHIP_NO_ERROR; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams +- (instancetype)init +{ + if (self = [super init]) { + + _activeDataset = [NSData data]; + + _breadcrumb = @(0); + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams alloc] init]; + + other.activeDataset = self.activeDataset; + other.breadcrumb = self.breadcrumb; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: activeDataset:%@; breadcrumb:%@; >", NSStringFromClass([self class]), [_activeDataset base64EncodedStringWithOptions:0], _breadcrumb]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Type encodableStruct; + ListFreer listFreer; + { + encodableStruct.activeDataset = AsByteSpan(self.activeDataset); + } + { + encodableStruct.breadcrumb = self.breadcrumb.unsignedLongLongValue; + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams +- (instancetype)init +{ + if (self = [super init]) { + + _pendingDataset = [NSData data]; + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams alloc] init]; + + other.pendingDataset = self.pendingDataset; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: pendingDataset:%@; >", NSStringFromClass([self class]), [_pendingDataset base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Type encodableStruct; + ListFreer listFreer; + { + encodableStruct.pendingDataset = AsByteSpan(self.pendingDataset); + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRThreadBorderRouterManagementClusterTopologyRequestParams +- (instancetype)init +{ + if (self = [super init]) { + + _count = @(0); + + _startIndex = @(0); + + _snapshot = @(0); + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterTopologyRequestParams alloc] init]; + + other.count = self.count; + other.startIndex = self.startIndex; + other.snapshot = self.snapshot; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: count:%@; startIndex:%@; snapshot:%@; >", NSStringFromClass([self class]), _count, _startIndex, _snapshot]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterTopologyRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Type encodableStruct; + ListFreer listFreer; + { + encodableStruct.count = self.count.unsignedShortValue; + } + { + encodableStruct.startIndex = self.startIndex.unsignedShortValue; + } + { + encodableStruct.snapshot = self.snapshot.unsignedCharValue; + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRThreadBorderRouterManagementClusterTopologyResponseParams +- (instancetype)init +{ + if (self = [super init]) { + + _status = @(0); + + _snapshot = @(0); + + _numberOfDevices = @(0); + + _threadTopology = [NSArray array]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRThreadBorderRouterManagementClusterTopologyResponseParams alloc] init]; + + other.status = self.status; + other.snapshot = self.snapshot; + other.numberOfDevices = self.numberOfDevices; + other.threadTopology = self.threadTopology; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: status:%@; snapshot:%@; numberOfDevices:%@; threadTopology:%@; >", NSStringFromClass([self class]), _status, _snapshot, _numberOfDevices, _threadTopology]; + return descriptionString; +} + +- (nullable instancetype)initWithResponseValue:(NSDictionary *)responseValue + error:(NSError * __autoreleasing *)error +{ + if (!(self = [super init])) { + return nil; + } + + using DecodableType = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType; + chip::System::PacketBufferHandle buffer = [MTRBaseDevice _responseDataForCommand:responseValue + clusterID:DecodableType::GetClusterId() + commandID:DecodableType::GetCommandId() + error:error]; + if (buffer.IsNull()) { + return nil; + } + + chip::TLV::TLVReader reader; + reader.Init(buffer->Start(), buffer->DataLength()); + + CHIP_ERROR err = reader.Next(chip::TLV::AnonymousTag()); + if (err == CHIP_NO_ERROR) { + DecodableType decodedStruct; + err = chip::app::DataModel::Decode(reader, decodedStruct); + if (err == CHIP_NO_ERROR) { + err = [self _setFieldsFromDecodableStruct:decodedStruct]; + if (err == CHIP_NO_ERROR) { + return self; + } + } + } + + NSString * errorStr = [NSString stringWithFormat:@"Command payload decoding failed: %s", err.AsString()]; + MTR_LOG_ERROR("%s", errorStr.UTF8String); + if (error != nil) { + NSDictionary * userInfo = @{ NSLocalizedFailureReasonErrorKey : NSLocalizedString(errorStr, nil) }; + *error = [NSError errorWithDomain:MTRErrorDomain code:MTRErrorCodeSchemaMismatch userInfo:userInfo]; + } + return nil; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterTopologyResponseParams (InternalMethods) + +- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType &)decodableStruct +{ + { + self.status = [NSNumber numberWithUnsignedChar:decodableStruct.status]; + } + { + self.snapshot = [NSNumber numberWithUnsignedChar:decodableStruct.snapshot]; + } + { + self.numberOfDevices = [NSNumber numberWithUnsignedShort:decodableStruct.numberOfDevices]; + } + { + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = decodableStruct.threadTopology.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + MTRThreadBorderRouterManagementClusterThreadNodeStruct * newElement_0; + newElement_0 = [MTRThreadBorderRouterManagementClusterThreadNodeStruct new]; + newElement_0.extAddress = [NSNumber numberWithUnsignedLongLong:entry_0.extAddress]; + newElement_0.rloc16 = [NSNumber numberWithUnsignedShort:entry_0.rloc16]; + { // Scope for our temporary variables + auto * array_2 = [NSMutableArray new]; + auto iter_2 = entry_0.IPv6s.begin(); + while (iter_2.Next()) { + auto & entry_2 = iter_2.GetValue(); + NSData * newElement_2; + newElement_2 = AsData(entry_2); + [array_2 addObject:newElement_2]; + } + CHIP_ERROR err = iter_2.GetStatus(); + if (err != CHIP_NO_ERROR) { + return err; + } + newElement_0.iPv6s = array_2; + } + newElement_0.routingRole = [NSNumber numberWithUnsignedChar:chip::to_underlying(entry_0.routingRole)]; + { // Scope for our temporary variables + auto * array_2 = [NSMutableArray new]; + auto iter_2 = entry_0.routeTable.begin(); + while (iter_2.Next()) { + auto & entry_2 = iter_2.GetValue(); + MTRThreadBorderRouterManagementClusterRouteTableStruct * newElement_2; + newElement_2 = [MTRThreadBorderRouterManagementClusterRouteTableStruct new]; + newElement_2.routerId = [NSNumber numberWithUnsignedChar:entry_2.routerId]; + newElement_2.pathCost = [NSNumber numberWithUnsignedChar:entry_2.pathCost]; + newElement_2.lqiIn = [NSNumber numberWithUnsignedChar:entry_2.LQIIn]; + newElement_2.lqiOut = [NSNumber numberWithUnsignedChar:entry_2.LQIOut]; + [array_2 addObject:newElement_2]; + } + CHIP_ERROR err = iter_2.GetStatus(); + if (err != CHIP_NO_ERROR) { + return err; + } + newElement_0.routeTable = array_2; + } + { // Scope for our temporary variables + auto * array_2 = [NSMutableArray new]; + auto iter_2 = entry_0.childTable.begin(); + while (iter_2.Next()) { + auto & entry_2 = iter_2.GetValue(); + MTRThreadBorderRouterManagementClusterChildTableStruct * newElement_2; + newElement_2 = [MTRThreadBorderRouterManagementClusterChildTableStruct new]; + newElement_2.rloc16 = [NSNumber numberWithUnsignedShort:entry_2.rloc16]; + newElement_2.linkQuality = [NSNumber numberWithUnsignedChar:entry_2.linkQuality]; + newElement_2.routingRole = [NSNumber numberWithUnsignedChar:chip::to_underlying(entry_2.routingRole)]; + [array_2 addObject:newElement_2]; + } + CHIP_ERROR err = iter_2.GetStatus(); + if (err != CHIP_NO_ERROR) { + return err; + } + newElement_0.childTable = array_2; + } + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + return err; + } + self.threadTopology = array_0; + } + } + return CHIP_NO_ERROR; +} + +@end + @implementation MTRChannelClusterChangeChannelParams - (instancetype)init { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h index 2579d3bc49a9bd..12bc02dff58e8a 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h @@ -1570,6 +1570,48 @@ NS_ASSUME_NONNULL_BEGIN @end +@interface MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRThreadBorderRouterManagementClusterDatasetResponseParams (InternalMethods) + +- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType &)decodableStruct; + +@end + +@interface MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRThreadBorderRouterManagementClusterTopologyRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRThreadBorderRouterManagementClusterTopologyResponseParams (InternalMethods) + +- (CHIP_ERROR)_setFieldsFromDecodableStruct:(const chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType &)decodableStruct; + +@end + @interface MTRChannelClusterChangeChannelParams (InternalMethods) - (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm index 685ca8f4f035a9..ac5ebc3bac0062 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm @@ -956,6 +956,15 @@ static BOOL CommandNeedsTimedInvokeInRadonConcentrationMeasurementCluster(Attrib } } } +static BOOL CommandNeedsTimedInvokeInThreadBorderRouterManagementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ThreadBorderRouterManagement; + switch (aAttributeId) { + default: { + return NO; + } + } +} static BOOL CommandNeedsTimedInvokeInWakeOnLANCluster(AttributeId aAttributeId) { using namespace Clusters::WakeOnLan; @@ -1419,6 +1428,9 @@ BOOL MTRCommandNeedsTimedInvoke(NSNumber * _Nonnull aClusterID, NSNumber * _Nonn case Clusters::RadonConcentrationMeasurement::Id: { return CommandNeedsTimedInvokeInRadonConcentrationMeasurementCluster(commandID); } + case Clusters::ThreadBorderRouterManagement::Id: { + return CommandNeedsTimedInvokeInThreadBorderRouterManagementCluster(commandID); + } case Clusters::WakeOnLan::Id: { return CommandNeedsTimedInvokeInWakeOnLANCluster(commandID); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm b/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm index 46427cba7fab3b..beb091be4ade9e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm @@ -97,6 +97,7 @@ { 0x00000840, DeviceTypeClass::Simple, "Matter Control Bridge" }, { 0x00000850, DeviceTypeClass::Simple, "Matter On/Off Sensor" }, { 0xFFF10010, DeviceTypeClass::Simple, "Matter Network Infrastructure Manager" }, + { 0xFFF10011, DeviceTypeClass::Simple, "Matter Thread Border Router" }, }; static_assert(ExtractVendorFromMEI(0xFFF10001) != 0, "Must have class defined for \"Matter Orphan Clusters\" if it's a standard device type"); diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 3e36773ffebd99..def29aa4b7fa1e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -4035,6 +4035,18 @@ static id _Nullable DecodeEventPayloadForRadonConcentrationMeasurementCluster(Ev *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; return nil; } +static id _Nullable DecodeEventPayloadForThreadBorderRouterManagementCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::ThreadBorderRouterManagement; + switch (aEventId) { + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + return nil; +} static id _Nullable DecodeEventPayloadForWakeOnLANCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::WakeOnLan; @@ -4836,6 +4848,9 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead case Clusters::RadonConcentrationMeasurement::Id: { return DecodeEventPayloadForRadonConcentrationMeasurementCluster(aPath.mEventId, aReader, aError); } + case Clusters::ThreadBorderRouterManagement::Id: { + return DecodeEventPayloadForThreadBorderRouterManagementCluster(aPath.mEventId, aReader, aError); + } case Clusters::WakeOnLan::Id: { return DecodeEventPayloadForWakeOnLANCluster(aPath.mEventId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index 92bd095b954393..a47b709bcd6db0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1637,6 +1637,41 @@ MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", @property (nonatomic, copy) NSNumber * _Nullable coolSetpoint MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", ios(16.1, 17.4), macos(13.0, 14.4), watchos(9.1, 10.4), tvos(16.1, 17.4)); @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterChildTableStruct : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull rloc16 MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull linkQuality MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull routingRole MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterRouteTableStruct : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull routerId MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull pathCost MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull lqiIn MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull lqiOut MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterThreadNodeStruct : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull extAddress MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull rloc16 MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSArray * _Nonnull iPv6s MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull routingRole MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSArray * _Nonnull routeTable MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSArray * _Nonnull childTable MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThreadBorderRouterManagementClusterNeiborTableStruct : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull extAddress MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull age MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull rloc16 MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable averageRssi MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable lastRssi MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull routingRole MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_PROVISIONALLY_AVAILABLE @interface MTRChannelClusterProgramCastStruct : NSObject @property (nonatomic, copy) NSString * _Nonnull name MTR_PROVISIONALLY_AVAILABLE; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index c9c38c72710756..8004395e2b70ca 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -6884,6 +6884,159 @@ @implementation MTRThermostatClusterThermostatScheduleTransition : MTRThermostat @dynamic coolSetpoint; @end +@implementation MTRThreadBorderRouterManagementClusterChildTableStruct +- (instancetype)init +{ + if (self = [super init]) { + + _rloc16 = @(0); + + _linkQuality = @(0); + + _routingRole = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThreadBorderRouterManagementClusterChildTableStruct alloc] init]; + + other.rloc16 = self.rloc16; + other.linkQuality = self.linkQuality; + other.routingRole = self.routingRole; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: rloc16:%@; linkQuality:%@; routingRole:%@; >", NSStringFromClass([self class]), _rloc16, _linkQuality, _routingRole]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterRouteTableStruct +- (instancetype)init +{ + if (self = [super init]) { + + _routerId = @(0); + + _pathCost = @(0); + + _lqiIn = @(0); + + _lqiOut = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThreadBorderRouterManagementClusterRouteTableStruct alloc] init]; + + other.routerId = self.routerId; + other.pathCost = self.pathCost; + other.lqiIn = self.lqiIn; + other.lqiOut = self.lqiOut; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: routerId:%@; pathCost:%@; lqiIn:%@; lqiOut:%@; >", NSStringFromClass([self class]), _routerId, _pathCost, _lqiIn, _lqiOut]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterThreadNodeStruct +- (instancetype)init +{ + if (self = [super init]) { + + _extAddress = @(0); + + _rloc16 = @(0); + + _iPv6s = [NSArray array]; + + _routingRole = @(0); + + _routeTable = [NSArray array]; + + _childTable = [NSArray array]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThreadBorderRouterManagementClusterThreadNodeStruct alloc] init]; + + other.extAddress = self.extAddress; + other.rloc16 = self.rloc16; + other.iPv6s = self.iPv6s; + other.routingRole = self.routingRole; + other.routeTable = self.routeTable; + other.childTable = self.childTable; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: extAddress:%@; rloc16:%@; iPv6s:%@; routingRole:%@; routeTable:%@; childTable:%@; >", NSStringFromClass([self class]), _extAddress, _rloc16, _iPv6s, _routingRole, _routeTable, _childTable]; + return descriptionString; +} + +@end + +@implementation MTRThreadBorderRouterManagementClusterNeiborTableStruct +- (instancetype)init +{ + if (self = [super init]) { + + _extAddress = @(0); + + _age = @(0); + + _rloc16 = @(0); + + _averageRssi = nil; + + _lastRssi = nil; + + _routingRole = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThreadBorderRouterManagementClusterNeiborTableStruct alloc] init]; + + other.extAddress = self.extAddress; + other.age = self.age; + other.rloc16 = self.rloc16; + other.averageRssi = self.averageRssi; + other.lastRssi = self.lastRssi; + other.routingRole = self.routingRole; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: extAddress:%@; age:%@; rloc16:%@; averageRssi:%@; lastRssi:%@; routingRole:%@; >", NSStringFromClass([self class]), _extAddress, _age, _rloc16, _averageRssi, _lastRssi, _routingRole]; + return descriptionString; +} + +@end + @implementation MTRChannelClusterProgramCastStruct - (instancetype)init { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp index 78c93070ca6d03..7e38797b5a877b 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp @@ -34570,6 +34570,59 @@ Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t valu } // namespace Attributes } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +namespace Attributes { + +namespace ClusterRevision { + +Protocols::InteractionModel::Status Get(chip::EndpointId endpoint, uint16_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + Protocols::InteractionModel::Status status = + emberAfReadAttribute(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return Protocols::InteractionModel::Status::ConstraintError; + } + *value = Traits::StorageToWorking(temp); + return status; +} + +Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return Protocols::InteractionModel::Status::ConstraintError; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE, + markDirty); +} + +Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return Protocols::InteractionModel::Status::ConstraintError; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ThreadBorderRouterManagement::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ThreadBorderRouterManagement + namespace WakeOnLan { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h index e51fb1999e9ce8..807d12a8226c96 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h @@ -5316,6 +5316,18 @@ Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t valu } // namespace Attributes } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +namespace Attributes { + +namespace ClusterRevision { +Protocols::InteractionModel::Status Get(chip::EndpointId endpoint, uint16_t * value); // int16u +Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t value); +Protocols::InteractionModel::Status Set(chip::EndpointId endpoint, uint16_t value, MarkAttributeDirty markDirty); +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ThreadBorderRouterManagement + namespace WakeOnLan { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h index 350190a22e5762..47d94f00794d51 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -533,6 +533,11 @@ void emberAfTotalVolatileOrganicCompoundsConcentrationMeasurementClusterInitCall */ void emberAfRadonConcentrationMeasurementClusterInitCallback(chip::EndpointId endpoint); +/** + * @param endpoint Endpoint that is being initialized + */ +void emberAfThreadBorderRouterManagementClusterInitCallback(chip::EndpointId endpoint); + /** * @param endpoint Endpoint that is being initialized */ @@ -4488,6 +4493,45 @@ chip::Protocols::InteractionModel::Status MatterRadonConcentrationMeasurementClu */ void emberAfRadonConcentrationMeasurementClusterServerTickCallback(chip::EndpointId endpoint); +// +// Thread Border Router Management Cluster +// + +/** + * @param endpoint Endpoint that is being initialized + */ +void emberAfThreadBorderRouterManagementClusterServerInitCallback(chip::EndpointId endpoint); + +/** + * @param endpoint Endpoint that is being shutdown + */ +void MatterThreadBorderRouterManagementClusterServerShutdownCallback(chip::EndpointId endpoint); + +/** + * @param endpoint Endpoint that is being initialized + */ +void emberAfThreadBorderRouterManagementClusterClientInitCallback(chip::EndpointId endpoint); + +/** + * @param attributePath Concrete attribute path that changed + */ +void MatterThreadBorderRouterManagementClusterServerAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath); + +/** + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status MatterThreadBorderRouterManagementClusterServerPreAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** + * @param endpoint Endpoint that is being served + */ +void emberAfThreadBorderRouterManagementClusterServerTickCallback(chip::EndpointId endpoint); + // // Wake on LAN Cluster // diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h index ca25c08c748e0c..e31991b523fbcd 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h @@ -2707,6 +2707,24 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(OccupancySensing::Occup } } +static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadBorderRouterManagement::RoutingRoleEnum val) +{ + using EnumType = ThreadBorderRouterManagement::RoutingRoleEnum; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kUnassigned: + case EnumType::kSleepyEndDevice: + case EnumType::kEndDevice: + case EnumType::kReed: + case EnumType::kRouter: + case EnumType::kLeader: + return val; + default: + return EnumType::kUnknownEnumValue; + } +} + static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::ChannelTypeEnum val) { using EnumType = Channel::ChannelTypeEnum; diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index 42a54b95ee944f..9dc0cd7335e5ec 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -4309,6 +4309,32 @@ enum class Feature : uint32_t }; } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { + +// Enum for RoutingRoleEnum +enum class RoutingRoleEnum : uint8_t +{ + kUnspecified = 0x00, + kUnassigned = 0x01, + kSleepyEndDevice = 0x02, + kEndDevice = 0x03, + kReed = 0x04, + kRouter = 0x05, + kLeader = 0x06, + // All received enum values that are not listed above will be mapped + // to kUnknownEnumValue. This is a helper enum value that should only + // be used by code to process how it handles receiving and unknown + // enum value. This specific should never be transmitted. + kUnknownEnumValue = 7, +}; + +// Bitmap for Feature +enum class Feature : uint32_t +{ + kPANChange = 0x1, +}; +} // namespace ThreadBorderRouterManagement + namespace WakeOnLan {} // namespace WakeOnLan namespace Channel { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 32b62631ed30fd..71ee814ed0298a 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -22865,6 +22865,510 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre namespace Events {} // namespace Events } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +namespace Structs { + +namespace ChildTableStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kRloc16), rloc16); + encoder.Encode(to_underlying(Fields::kLinkQuality), linkQuality); + encoder.Encode(to_underlying(Fields::kRoutingRole), routingRole); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kRloc16)) + { + err = DataModel::Decode(reader, rloc16); + } + else if (__context_tag == to_underlying(Fields::kLinkQuality)) + { + err = DataModel::Decode(reader, linkQuality); + } + else if (__context_tag == to_underlying(Fields::kRoutingRole)) + { + err = DataModel::Decode(reader, routingRole); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} + +} // namespace ChildTableStruct + +namespace RouteTableStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kRouterId), routerId); + encoder.Encode(to_underlying(Fields::kPathCost), pathCost); + encoder.Encode(to_underlying(Fields::kLQIIn), LQIIn); + encoder.Encode(to_underlying(Fields::kLQIOut), LQIOut); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kRouterId)) + { + err = DataModel::Decode(reader, routerId); + } + else if (__context_tag == to_underlying(Fields::kPathCost)) + { + err = DataModel::Decode(reader, pathCost); + } + else if (__context_tag == to_underlying(Fields::kLQIIn)) + { + err = DataModel::Decode(reader, LQIIn); + } + else if (__context_tag == to_underlying(Fields::kLQIOut)) + { + err = DataModel::Decode(reader, LQIOut); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} + +} // namespace RouteTableStruct + +namespace ThreadNodeStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kExtAddress), extAddress); + encoder.Encode(to_underlying(Fields::kRloc16), rloc16); + encoder.Encode(to_underlying(Fields::kIPv6s), IPv6s); + encoder.Encode(to_underlying(Fields::kRoutingRole), routingRole); + encoder.Encode(to_underlying(Fields::kRouteTable), routeTable); + encoder.Encode(to_underlying(Fields::kChildTable), childTable); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kExtAddress)) + { + err = DataModel::Decode(reader, extAddress); + } + else if (__context_tag == to_underlying(Fields::kRloc16)) + { + err = DataModel::Decode(reader, rloc16); + } + else if (__context_tag == to_underlying(Fields::kIPv6s)) + { + err = DataModel::Decode(reader, IPv6s); + } + else if (__context_tag == to_underlying(Fields::kRoutingRole)) + { + err = DataModel::Decode(reader, routingRole); + } + else if (__context_tag == to_underlying(Fields::kRouteTable)) + { + err = DataModel::Decode(reader, routeTable); + } + else if (__context_tag == to_underlying(Fields::kChildTable)) + { + err = DataModel::Decode(reader, childTable); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} + +} // namespace ThreadNodeStruct + +namespace NeiborTableStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kExtAddress), extAddress); + encoder.Encode(to_underlying(Fields::kAge), age); + encoder.Encode(to_underlying(Fields::kRloc16), rloc16); + encoder.Encode(to_underlying(Fields::kAverageRssi), averageRssi); + encoder.Encode(to_underlying(Fields::kLastRssi), lastRssi); + encoder.Encode(to_underlying(Fields::kRoutingRole), routingRole); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kExtAddress)) + { + err = DataModel::Decode(reader, extAddress); + } + else if (__context_tag == to_underlying(Fields::kAge)) + { + err = DataModel::Decode(reader, age); + } + else if (__context_tag == to_underlying(Fields::kRloc16)) + { + err = DataModel::Decode(reader, rloc16); + } + else if (__context_tag == to_underlying(Fields::kAverageRssi)) + { + err = DataModel::Decode(reader, averageRssi); + } + else if (__context_tag == to_underlying(Fields::kLastRssi)) + { + err = DataModel::Decode(reader, lastRssi); + } + else if (__context_tag == to_underlying(Fields::kRoutingRole)) + { + err = DataModel::Decode(reader, routingRole); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} + +} // namespace NeiborTableStruct +} // namespace Structs + +namespace Commands { +namespace GetActiveDatasetRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + } +} +} // namespace GetActiveDatasetRequest. +namespace GetPendingDatasetRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + } +} +} // namespace GetPendingDatasetRequest. +namespace DatasetResponse { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kDataset), dataset); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kDataset)) + { + err = DataModel::Decode(reader, dataset); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace DatasetResponse. +namespace SetActiveDatasetRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kActiveDataset), activeDataset); + encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kActiveDataset)) + { + err = DataModel::Decode(reader, activeDataset); + } + else if (__context_tag == to_underlying(Fields::kBreadcrumb)) + { + err = DataModel::Decode(reader, breadcrumb); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SetActiveDatasetRequest. +namespace SetPendingDatasetRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kPendingDataset), pendingDataset); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPendingDataset)) + { + err = DataModel::Decode(reader, pendingDataset); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SetPendingDatasetRequest. +namespace TopologyRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kCount), count); + encoder.Encode(to_underlying(Fields::kStartIndex), startIndex); + encoder.Encode(to_underlying(Fields::kSnapshot), snapshot); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kCount)) + { + err = DataModel::Decode(reader, count); + } + else if (__context_tag == to_underlying(Fields::kStartIndex)) + { + err = DataModel::Decode(reader, startIndex); + } + else if (__context_tag == to_underlying(Fields::kSnapshot)) + { + err = DataModel::Decode(reader, snapshot); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace TopologyRequest. +namespace TopologyResponse { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kStatus), status); + encoder.Encode(to_underlying(Fields::kSnapshot), snapshot); + encoder.Encode(to_underlying(Fields::kNumberOfDevices), numberOfDevices); + encoder.Encode(to_underlying(Fields::kThreadTopology), threadTopology); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kStatus)) + { + err = DataModel::Decode(reader, status); + } + else if (__context_tag == to_underlying(Fields::kSnapshot)) + { + err = DataModel::Decode(reader, snapshot); + } + else if (__context_tag == to_underlying(Fields::kNumberOfDevices)) + { + err = DataModel::Decode(reader, numberOfDevices); + } + else if (__context_tag == to_underlying(Fields::kThreadTopology)) + { + err = DataModel::Decode(reader, threadTopology); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace TopologyResponse. +} // namespace Commands + +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::BorderRouterName::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, borderRouterName); + case Attributes::BorderAgentId::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, borderAgentId); + case Attributes::ThreadVersion::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, threadVersion); + case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, interfaceEnabled); + case Attributes::ThreadNode::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, threadNode); + case Attributes::ActiveDatasetTimestamp::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, activeDatasetTimestamp); + case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, generatedCommandList); + case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, acceptedCommandList); + case Attributes::EventList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, eventList); + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, attributeList); + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, featureMap); + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, clusterRevision); + default: + return CHIP_NO_ERROR; + } +} +} // namespace Attributes + +namespace Events {} // namespace Events + +} // namespace ThreadBorderRouterManagement namespace WakeOnLan { namespace Commands {} // namespace Commands @@ -30345,6 +30849,13 @@ bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand) return false; } } + case Clusters::ThreadBorderRouterManagement::Id: { + switch (aCommand) + { + default: + return false; + } + } case Clusters::Channel::Id: { switch (aCommand) { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 89c36f3c6f147d..aa6c87f57db321 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -34846,6 +34846,549 @@ struct TypeInfo }; } // namespace Attributes } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +namespace Structs { +namespace ChildTableStruct { +enum class Fields : uint8_t +{ + kRloc16 = 0, + kLinkQuality = 1, + kRoutingRole = 2, +}; + +struct Type +{ +public: + uint16_t rloc16 = static_cast(0); + uint8_t linkQuality = static_cast(0); + RoutingRoleEnum routingRole = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +using DecodableType = Type; + +} // namespace ChildTableStruct +namespace RouteTableStruct { +enum class Fields : uint8_t +{ + kRouterId = 0, + kPathCost = 1, + kLQIIn = 2, + kLQIOut = 3, +}; + +struct Type +{ +public: + uint8_t routerId = static_cast(0); + uint8_t pathCost = static_cast(0); + uint8_t LQIIn = static_cast(0); + uint8_t LQIOut = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +using DecodableType = Type; + +} // namespace RouteTableStruct +namespace ThreadNodeStruct { +enum class Fields : uint8_t +{ + kExtAddress = 0, + kRloc16 = 1, + kIPv6s = 2, + kRoutingRole = 3, + kRouteTable = 4, + kChildTable = 5, +}; + +struct Type +{ +public: + uint64_t extAddress = static_cast(0); + uint16_t rloc16 = static_cast(0); + DataModel::List IPv6s; + RoutingRoleEnum routingRole = static_cast(0); + DataModel::List routeTable; + DataModel::List childTable; + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + uint64_t extAddress = static_cast(0); + uint16_t rloc16 = static_cast(0); + DataModel::DecodableList IPv6s; + RoutingRoleEnum routingRole = static_cast(0); + DataModel::DecodableList routeTable; + DataModel::DecodableList childTable; + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; +}; + +} // namespace ThreadNodeStruct +namespace NeiborTableStruct { +enum class Fields : uint8_t +{ + kExtAddress = 0, + kAge = 1, + kRloc16 = 2, + kAverageRssi = 3, + kLastRssi = 4, + kRoutingRole = 5, +}; + +struct Type +{ +public: + uint64_t extAddress = static_cast(0); + uint32_t age = static_cast(0); + uint16_t rloc16 = static_cast(0); + DataModel::Nullable averageRssi; + DataModel::Nullable lastRssi; + RoutingRoleEnum routingRole = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +using DecodableType = Type; + +} // namespace NeiborTableStruct +} // namespace Structs + +namespace Commands { +// Forward-declarations so we can reference these later. + +namespace GetActiveDatasetRequest { +struct Type; +struct DecodableType; +} // namespace GetActiveDatasetRequest + +namespace GetPendingDatasetRequest { +struct Type; +struct DecodableType; +} // namespace GetPendingDatasetRequest + +namespace DatasetResponse { +struct Type; +struct DecodableType; +} // namespace DatasetResponse + +namespace SetActiveDatasetRequest { +struct Type; +struct DecodableType; +} // namespace SetActiveDatasetRequest + +namespace SetPendingDatasetRequest { +struct Type; +struct DecodableType; +} // namespace SetPendingDatasetRequest + +namespace TopologyRequest { +struct Type; +struct DecodableType; +} // namespace TopologyRequest + +namespace TopologyResponse { +struct Type; +struct DecodableType; +} // namespace TopologyResponse + +} // namespace Commands + +namespace Commands { +namespace GetActiveDatasetRequest { +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::GetActiveDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::GetActiveDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace GetActiveDatasetRequest +namespace GetPendingDatasetRequest { +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::GetPendingDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::GetPendingDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace GetPendingDatasetRequest +namespace DatasetResponse { +enum class Fields : uint8_t +{ + kDataset = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::DatasetResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan dataset; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::DatasetResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan dataset; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace DatasetResponse +namespace SetActiveDatasetRequest { +enum class Fields : uint8_t +{ + kActiveDataset = 0, + kBreadcrumb = 1, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetActiveDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan activeDataset; + uint64_t breadcrumb = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SetActiveDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan activeDataset; + uint64_t breadcrumb = static_cast(0); + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetActiveDatasetRequest +namespace SetPendingDatasetRequest { +enum class Fields : uint8_t +{ + kPendingDataset = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetPendingDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan pendingDataset; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SetPendingDatasetRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + chip::ByteSpan pendingDataset; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetPendingDatasetRequest +namespace TopologyRequest { +enum class Fields : uint8_t +{ + kCount = 0, + kStartIndex = 1, + kSnapshot = 2, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::TopologyRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + uint16_t count = static_cast(0); + uint16_t startIndex = static_cast(0); + uint8_t snapshot = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::TopologyRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + uint16_t count = static_cast(0); + uint16_t startIndex = static_cast(0); + uint8_t snapshot = static_cast(0); + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace TopologyRequest +namespace TopologyResponse { +enum class Fields : uint8_t +{ + kStatus = 0, + kSnapshot = 1, + kNumberOfDevices = 2, + kThreadTopology = 3, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::TopologyResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + uint8_t status = static_cast(0); + uint8_t snapshot = static_cast(0); + uint16_t numberOfDevices = static_cast(0); + DataModel::List threadTopology; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::TopologyResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + uint8_t status = static_cast(0); + uint8_t snapshot = static_cast(0); + uint16_t numberOfDevices = static_cast(0); + DataModel::DecodableList threadTopology; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace TopologyResponse +} // namespace Commands + +namespace Attributes { + +namespace BorderRouterName { +struct TypeInfo +{ + using Type = chip::CharSpan; + using DecodableType = chip::CharSpan; + using DecodableArgType = chip::CharSpan; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::BorderRouterName::Id; } + static constexpr bool MustUseTimedWrite() { return false; } + static constexpr size_t MaxLength() { return 63; } +}; +} // namespace BorderRouterName +namespace BorderAgentId { +struct TypeInfo +{ + using Type = chip::ByteSpan; + using DecodableType = chip::ByteSpan; + using DecodableArgType = chip::ByteSpan; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::BorderAgentId::Id; } + static constexpr bool MustUseTimedWrite() { return false; } + static constexpr size_t MaxLength() { return 16; } +}; +} // namespace BorderAgentId +namespace ThreadVersion { +struct TypeInfo +{ + using Type = uint16_t; + using DecodableType = uint16_t; + using DecodableArgType = uint16_t; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::ThreadVersion::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace ThreadVersion +namespace InterfaceEnabled { +struct TypeInfo +{ + using Type = bool; + using DecodableType = bool; + using DecodableArgType = bool; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::InterfaceEnabled::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace InterfaceEnabled +namespace ThreadNode { +struct TypeInfo +{ + using Type = chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::Type; + using DecodableType = chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::DecodableType; + using DecodableArgType = const chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::DecodableType &; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::ThreadNode::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace ThreadNode +namespace ActiveDatasetTimestamp { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::ActiveDatasetTimestamp::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace ActiveDatasetTimestamp +namespace GeneratedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace GeneratedCommandList +namespace AcceptedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace AcceptedCommandList +namespace EventList { +struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace EventList +namespace AttributeList { +struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace AttributeList +namespace FeatureMap { +struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace FeatureMap +namespace ClusterRevision { +struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } +}; +} // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ThreadBorderRouterManagement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::BorderRouterName::TypeInfo::DecodableType borderRouterName; + Attributes::BorderAgentId::TypeInfo::DecodableType borderAgentId; + Attributes::ThreadVersion::TypeInfo::DecodableType threadVersion = static_cast(0); + Attributes::InterfaceEnabled::TypeInfo::DecodableType interfaceEnabled = static_cast(0); + Attributes::ThreadNode::TypeInfo::DecodableType threadNode; + Attributes::ActiveDatasetTimestamp::TypeInfo::DecodableType activeDatasetTimestamp; + Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; + Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; + Attributes::EventList::TypeInfo::DecodableType eventList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast(0); + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast(0); + }; +}; +} // namespace Attributes +} // namespace ThreadBorderRouterManagement namespace WakeOnLan { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h index 8ff6313abe5940..246e3b9beae44e 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h @@ -6583,6 +6583,60 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; } // namespace Attributes } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +namespace Attributes { + +namespace BorderRouterName { +static constexpr AttributeId Id = 0x00000000; +} // namespace BorderRouterName + +namespace BorderAgentId { +static constexpr AttributeId Id = 0x00000001; +} // namespace BorderAgentId + +namespace ThreadVersion { +static constexpr AttributeId Id = 0x00000002; +} // namespace ThreadVersion + +namespace InterfaceEnabled { +static constexpr AttributeId Id = 0x00000003; +} // namespace InterfaceEnabled + +namespace ThreadNode { +static constexpr AttributeId Id = 0x00000004; +} // namespace ThreadNode + +namespace ActiveDatasetTimestamp { +static constexpr AttributeId Id = 0x00000005; +} // namespace ActiveDatasetTimestamp + +namespace GeneratedCommandList { +static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; +} // namespace GeneratedCommandList + +namespace AcceptedCommandList { +static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id; +} // namespace AcceptedCommandList + +namespace EventList { +static constexpr AttributeId Id = Globals::Attributes::EventList::Id; +} // namespace EventList + +namespace AttributeList { +static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id; +} // namespace AttributeList + +namespace FeatureMap { +static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id; +} // namespace FeatureMap + +namespace ClusterRevision { +static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ThreadBorderRouterManagement + namespace WakeOnLan { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h index f457887220abad..2d99611551338f 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h @@ -325,6 +325,9 @@ static constexpr ClusterId Id = 0x0000042E; namespace RadonConcentrationMeasurement { static constexpr ClusterId Id = 0x0000042F; } // namespace RadonConcentrationMeasurement +namespace ThreadBorderRouterManagement { +static constexpr ClusterId Id = 0x00000452; +} // namespace ThreadBorderRouterManagement namespace WakeOnLan { static constexpr ClusterId Id = 0x00000503; } // namespace WakeOnLan diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h index da8b04c98c1963..5f84fd5d51f493 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h @@ -1381,6 +1381,40 @@ static constexpr CommandId Id = 0x0000004C; } // namespace Commands } // namespace ColorControl +namespace ThreadBorderRouterManagement { +namespace Commands { + +namespace GetActiveDatasetRequest { +static constexpr CommandId Id = 0x00000000; +} // namespace GetActiveDatasetRequest + +namespace GetPendingDatasetRequest { +static constexpr CommandId Id = 0x00000001; +} // namespace GetPendingDatasetRequest + +namespace DatasetResponse { +static constexpr CommandId Id = 0x00000002; +} // namespace DatasetResponse + +namespace SetActiveDatasetRequest { +static constexpr CommandId Id = 0x00000003; +} // namespace SetActiveDatasetRequest + +namespace SetPendingDatasetRequest { +static constexpr CommandId Id = 0x00000004; +} // namespace SetPendingDatasetRequest + +namespace TopologyRequest { +static constexpr CommandId Id = 0x00000005; +} // namespace TopologyRequest + +namespace TopologyResponse { +static constexpr CommandId Id = 0x00000006; +} // namespace TopologyResponse + +} // namespace Commands +} // namespace ThreadBorderRouterManagement + namespace Channel { namespace Commands { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 8a3081edc0dc1b..66336d1451232f 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -135,6 +135,7 @@ | Pm10ConcentrationMeasurement | 0x042D | | TotalVolatileOrganicCompoundsConcentrationMeasurement | 0x042E | | RadonConcentrationMeasurement | 0x042F | +| ThreadBorderRouterManagement | 0x0452 | | WakeOnLan | 0x0503 | | Channel | 0x0504 | | TargetNavigator | 0x0505 | @@ -11017,6 +11018,232 @@ class ColorControlStepColorTemperature : public ClusterCommand | Events: | | \*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*\ +| Cluster ThreadBorderRouterManagement | 0x0452 | +|------------------------------------------------------------------------------| +| Commands: | | +| * GetActiveDatasetRequest | 0x00 | +| * GetPendingDatasetRequest | 0x01 | +| * SetActiveDatasetRequest | 0x03 | +| * SetPendingDatasetRequest | 0x04 | +| * TopologyRequest | 0x05 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * BorderRouterName | 0x0000 | +| * BorderAgentId | 0x0001 | +| * ThreadVersion | 0x0002 | +| * InterfaceEnabled | 0x0003 | +| * ThreadNode | 0x0004 | +| * ActiveDatasetTimestamp | 0x0005 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +\*----------------------------------------------------------------------------*/ + +/* + * Command GetActiveDatasetRequest + */ +class ThreadBorderRouterManagementGetActiveDatasetRequest : public ClusterCommand +{ +public: + ThreadBorderRouterManagementGetActiveDatasetRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("get-active-dataset-request", credsIssuerConfig) + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Type mRequest; +}; + +/* + * Command GetPendingDatasetRequest + */ +class ThreadBorderRouterManagementGetPendingDatasetRequest : public ClusterCommand +{ +public: + ThreadBorderRouterManagementGetPendingDatasetRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("get-pending-dataset-request", credsIssuerConfig) + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Type mRequest; +}; + +/* + * Command SetActiveDatasetRequest + */ +class ThreadBorderRouterManagementSetActiveDatasetRequest : public ClusterCommand +{ +public: + ThreadBorderRouterManagementSetActiveDatasetRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-active-dataset-request", credsIssuerConfig) + { + AddArgument("ActiveDataset", &mRequest.activeDataset); + AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Type mRequest; +}; + +/* + * Command SetPendingDatasetRequest + */ +class ThreadBorderRouterManagementSetPendingDatasetRequest : public ClusterCommand +{ +public: + ThreadBorderRouterManagementSetPendingDatasetRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-pending-dataset-request", credsIssuerConfig) + { + AddArgument("PendingDataset", &mRequest.pendingDataset); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Type mRequest; +}; + +/* + * Command TopologyRequest + */ +class ThreadBorderRouterManagementTopologyRequest : public ClusterCommand +{ +public: + ThreadBorderRouterManagementTopologyRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("topology-request", credsIssuerConfig) + { + AddArgument("Count", 0, UINT16_MAX, &mRequest.count); + AddArgument("StartIndex", 0, UINT16_MAX, &mRequest.startIndex); + AddArgument("Snapshot", 0, UINT8_MAX, &mRequest.snapshot); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Type mRequest; +}; + /*----------------------------------------------------------------------------*\ | Cluster WakeOnLan | 0x0503 | |------------------------------------------------------------------------------| @@ -24507,6 +24734,88 @@ void registerClusterRadonConcentrationMeasurement(Commands & commands, Credentia commands.RegisterCluster(clusterName, clusterCommands); } +void registerClusterThreadBorderRouterManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) +{ + using namespace chip::app::Clusters::ThreadBorderRouterManagement; + + const char * clusterName = "ThreadBorderRouterManagement"; + + commands_list clusterCommands = { + // + // Commands + // + make_unique(Id, credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + // + // Attributes + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "border-router-name", Attributes::BorderRouterName::Id, credsIssuerConfig), // + make_unique(Id, "border-agent-id", Attributes::BorderAgentId::Id, credsIssuerConfig), // + make_unique(Id, "thread-version", Attributes::ThreadVersion::Id, credsIssuerConfig), // + make_unique(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig), // + make_unique(Id, "thread-node", Attributes::ThreadNode::Id, credsIssuerConfig), // + make_unique(Id, "active-dataset-timestamp", Attributes::ActiveDatasetTimestamp::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + make_unique>(Id, credsIssuerConfig), // + make_unique>(Id, "border-router-name", Attributes::BorderRouterName::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "border-agent-id", Attributes::BorderAgentId::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "thread-version", 0, UINT16_MAX, Attributes::ThreadVersion::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "interface-enabled", 0, 1, Attributes::InterfaceEnabled::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>( + Id, "thread-node", Attributes::ThreadNode::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>(Id, "active-dataset-timestamp", 0, UINT64_MAX, + Attributes::ActiveDatasetTimestamp::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>>( + Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "border-router-name", Attributes::BorderRouterName::Id, credsIssuerConfig), // + make_unique(Id, "border-agent-id", Attributes::BorderAgentId::Id, credsIssuerConfig), // + make_unique(Id, "thread-version", Attributes::ThreadVersion::Id, credsIssuerConfig), // + make_unique(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig), // + make_unique(Id, "thread-node", Attributes::ThreadNode::Id, credsIssuerConfig), // + make_unique(Id, "active-dataset-timestamp", Attributes::ActiveDatasetTimestamp::Id, + credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + // + // Events + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +} void registerClusterWakeOnLan(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) { using namespace chip::app::Clusters::WakeOnLan; @@ -26861,6 +27170,7 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue registerClusterPm10ConcentrationMeasurement(commands, credsIssuerConfig); registerClusterTotalVolatileOrganicCompoundsConcentrationMeasurement(commands, credsIssuerConfig); registerClusterRadonConcentrationMeasurement(commands, credsIssuerConfig); + registerClusterThreadBorderRouterManagement(commands, credsIssuerConfig); registerClusterWakeOnLan(commands, credsIssuerConfig); registerClusterChannel(commands, credsIssuerConfig); registerClusterTargetNavigator(commands, credsIssuerConfig); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp index 89f34d0cee3714..e458f2467266a4 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp @@ -3986,6 +3986,208 @@ void ComplexArgumentParser::Finalize(chip::app::Clusters::Thermostat::Structs::W ComplexArgumentParser::Finalize(request.coolSetpoint); } +CHIP_ERROR +ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ChildTableStruct.rloc16", "rloc16", value.isMember("rloc16"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ChildTableStruct.linkQuality", "linkQuality", value.isMember("linkQuality"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ChildTableStruct.routingRole", "routingRole", value.isMember("routingRole"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rloc16"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rloc16, value["rloc16"])); + valueCopy.removeMember("rloc16"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "linkQuality"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.linkQuality, value["linkQuality"])); + valueCopy.removeMember("linkQuality"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routingRole"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routingRole, value["routingRole"])); + valueCopy.removeMember("routingRole"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.rloc16); + ComplexArgumentParser::Finalize(request.linkQuality); + ComplexArgumentParser::Finalize(request.routingRole); +} + +CHIP_ERROR +ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("RouteTableStruct.routerId", "routerId", value.isMember("routerId"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("RouteTableStruct.pathCost", "pathCost", value.isMember("pathCost"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTableStruct.LQIIn", "LQIIn", value.isMember("LQIIn"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTableStruct.LQIOut", "LQIOut", value.isMember("LQIOut"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routerId"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routerId, value["routerId"])); + valueCopy.removeMember("routerId"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "pathCost"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.pathCost, value["pathCost"])); + valueCopy.removeMember("pathCost"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "LQIIn"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.LQIIn, value["LQIIn"])); + valueCopy.removeMember("LQIIn"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "LQIOut"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.LQIOut, value["LQIOut"])); + valueCopy.removeMember("LQIOut"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.routerId); + ComplexArgumentParser::Finalize(request.pathCost); + ComplexArgumentParser::Finalize(request.LQIIn); + ComplexArgumentParser::Finalize(request.LQIOut); +} + +CHIP_ERROR +ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.extAddress", "extAddress", value.isMember("extAddress"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.rloc16", "rloc16", value.isMember("rloc16"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.IPv6s", "IPv6s", value.isMember("IPv6s"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.routingRole", "routingRole", value.isMember("routingRole"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.routeTable", "routeTable", value.isMember("routeTable"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("ThreadNodeStruct.childTable", "childTable", value.isMember("childTable"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extAddress"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extAddress, value["extAddress"])); + valueCopy.removeMember("extAddress"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rloc16"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rloc16, value["rloc16"])); + valueCopy.removeMember("rloc16"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "IPv6s"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.IPv6s, value["IPv6s"])); + valueCopy.removeMember("IPv6s"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routingRole"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routingRole, value["routingRole"])); + valueCopy.removeMember("routingRole"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routeTable"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routeTable, value["routeTable"])); + valueCopy.removeMember("routeTable"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "childTable"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.childTable, value["childTable"])); + valueCopy.removeMember("childTable"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.extAddress); + ComplexArgumentParser::Finalize(request.rloc16); + ComplexArgumentParser::Finalize(request.IPv6s); + ComplexArgumentParser::Finalize(request.routingRole); + ComplexArgumentParser::Finalize(request.routeTable); + ComplexArgumentParser::Finalize(request.childTable); +} + +CHIP_ERROR +ComplexArgumentParser::Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::Type & request, + Json::Value & value) +{ + VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT); + + // Copy to track which members we already processed. + Json::Value valueCopy(value); + + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.extAddress", "extAddress", value.isMember("extAddress"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.age", "age", value.isMember("age"))); + ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.rloc16", "rloc16", value.isMember("rloc16"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.averageRssi", "averageRssi", value.isMember("averageRssi"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.lastRssi", "lastRssi", value.isMember("lastRssi"))); + ReturnErrorOnFailure( + ComplexArgumentParser::EnsureMemberExist("NeiborTableStruct.routingRole", "routingRole", value.isMember("routingRole"))); + + char labelWithMember[kMaxLabelLength]; + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extAddress"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extAddress, value["extAddress"])); + valueCopy.removeMember("extAddress"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "age"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.age, value["age"])); + valueCopy.removeMember("age"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rloc16"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rloc16, value["rloc16"])); + valueCopy.removeMember("rloc16"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "averageRssi"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.averageRssi, value["averageRssi"])); + valueCopy.removeMember("averageRssi"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lastRssi"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lastRssi, value["lastRssi"])); + valueCopy.removeMember("lastRssi"); + + snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routingRole"); + ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routingRole, value["routingRole"])); + valueCopy.removeMember("routingRole"); + + return ComplexArgumentParser::EnsureNoMembersRemaining(label, valueCopy); +} + +void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::Type & request) +{ + ComplexArgumentParser::Finalize(request.extAddress); + ComplexArgumentParser::Finalize(request.age); + ComplexArgumentParser::Finalize(request.rloc16); + ComplexArgumentParser::Finalize(request.averageRssi); + ComplexArgumentParser::Finalize(request.lastRssi); + ComplexArgumentParser::Finalize(request.routingRole); +} + CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::Channel::Structs::ProgramCastStruct::Type & request, Json::Value & value) diff --git a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h index a9ac94c6cecb77..667c2b386fc38f 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.h @@ -455,6 +455,30 @@ static CHIP_ERROR Setup(const char * label, static void Finalize(chip::app::Clusters::Thermostat::Structs::WeeklyScheduleTransitionStruct::Type & request); +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::Type & request); + +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::Type & request); + +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::Type & request); + +static CHIP_ERROR Setup(const char * label, + chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::Type & request, + Json::Value & value); + +static void Finalize(chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::Type & request); + static CHIP_ERROR Setup(const char * label, chip::app::Clusters::Channel::Structs::ProgramCastStruct::Type & request, Json::Value & value); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index fde5089bab8a7c..174c38e36e7ab3 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -3528,6 +3528,198 @@ DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR +DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("Rloc16", indent + 1, value.rloc16); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Rloc16'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("LinkQuality", indent + 1, value.linkQuality); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'LinkQuality'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("RoutingRole", indent + 1, value.routingRole); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'RoutingRole'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR +DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("RouterId", indent + 1, value.routerId); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'RouterId'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("PathCost", indent + 1, value.pathCost); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'PathCost'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("LQIIn", indent + 1, value.LQIIn); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'LQIIn'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("LQIOut", indent + 1, value.LQIOut); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'LQIOut'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR +DataModelLogger::LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("ExtAddress", indent + 1, value.extAddress); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'ExtAddress'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Rloc16", indent + 1, value.rloc16); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Rloc16'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("IPv6s", indent + 1, value.IPv6s); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'IPv6s'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("RoutingRole", indent + 1, value.routingRole); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'RoutingRole'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("RouteTable", indent + 1, value.routeTable); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'RouteTable'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("ChildTable", indent + 1, value.childTable); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'ChildTable'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR DataModelLogger::LogValue( + const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("ExtAddress", indent + 1, value.extAddress); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'ExtAddress'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Age", indent + 1, value.age); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Age'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Rloc16", indent + 1, value.rloc16); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Rloc16'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("AverageRssi", indent + 1, value.averageRssi); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'AverageRssi'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("LastRssi", indent + 1, value.lastRssi); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'LastRssi'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("RoutingRole", indent + 1, value.routingRole); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'RoutingRole'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const chip::app::Clusters::Channel::Structs::ProgramCastStruct::DecodableType & value) { @@ -7719,6 +7911,25 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, DataModelLogger::LogString(indent, "}"); return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + ReturnErrorOnFailure(DataModelLogger::LogValue("dataset", indent + 1, value.dataset)); + DataModelLogger::LogString(indent, "}"); + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + ReturnErrorOnFailure(DataModelLogger::LogValue("status", indent + 1, value.status)); + ReturnErrorOnFailure(DataModelLogger::LogValue("snapshot", indent + 1, value.snapshot)); + ReturnErrorOnFailure(DataModelLogger::LogValue("numberOfDevices", indent + 1, value.numberOfDevices)); + ReturnErrorOnFailure(DataModelLogger::LogValue("threadTopology", indent + 1, value.threadTopology)); + DataModelLogger::LogString(indent, "}"); + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const Channel::Commands::ChangeChannelResponse::DecodableType & value) { @@ -16089,6 +16300,72 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP } break; } + case ThreadBorderRouterManagement::Id: { + switch (path.mAttributeId) + { + case ThreadBorderRouterManagement::Attributes::BorderRouterName::Id: { + chip::CharSpan value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("BorderRouterName", 1, value); + } + case ThreadBorderRouterManagement::Attributes::BorderAgentId::Id: { + chip::ByteSpan value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("BorderAgentId", 1, value); + } + case ThreadBorderRouterManagement::Attributes::ThreadVersion::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ThreadVersion", 1, value); + } + case ThreadBorderRouterManagement::Attributes::InterfaceEnabled::Id: { + bool value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("InterfaceEnabled", 1, value); + } + case ThreadBorderRouterManagement::Attributes::ThreadNode::Id: { + chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ThreadNode", 1, value); + } + case ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ActiveDatasetTimestamp", 1, value); + } + case ThreadBorderRouterManagement::Attributes::GeneratedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("GeneratedCommandList", 1, value); + } + case ThreadBorderRouterManagement::Attributes::AcceptedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AcceptedCommandList", 1, value); + } + case ThreadBorderRouterManagement::Attributes::EventList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EventList", 1, value); + } + case ThreadBorderRouterManagement::Attributes::AttributeList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AttributeList", 1, value); + } + case ThreadBorderRouterManagement::Attributes::FeatureMap::Id: { + uint32_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("FeatureMap", 1, value); + } + case ThreadBorderRouterManagement::Attributes::ClusterRevision::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ClusterRevision", 1, value); + } + } + break; + } case WakeOnLan::Id: { switch (path.mAttributeId) { @@ -18438,6 +18715,22 @@ CHIP_ERROR DataModelLogger::LogCommand(const chip::app::ConcreteCommandPath & pa } break; } + case ThreadBorderRouterManagement::Id: { + switch (path.mCommandId) + { + case ThreadBorderRouterManagement::Commands::DatasetResponse::Id: { + ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("DatasetResponse", 1, value); + } + case ThreadBorderRouterManagement::Commands::TopologyResponse::Id: { + ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("TopologyResponse", 1, value); + } + } + break; + } case Channel::Id: { switch (path.mCommandId) { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h index 1c790b5e002039..673046ff9b01b7 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -284,6 +284,22 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::Thermostat::Structs::WeeklyScheduleTransitionStruct::DecodableType & value); +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::ChildTableStruct::DecodableType & value); + +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::RouteTableStruct::DecodableType & value); + +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::ThreadNodeStruct::DecodableType & value); + +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Structs::NeiborTableStruct::DecodableType & value); + static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::Channel::Structs::ProgramCastStruct::DecodableType & value); @@ -735,6 +751,12 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType & value); +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::DecodableType & value); +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::Channel::Commands::ChangeChannelResponse::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index c3034217db9c05..df6a2a2973a9d4 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -137,6 +137,7 @@ | Pm10ConcentrationMeasurement | 0x042D | | TotalVolatileOrganicCompoundsConcentrationMeasurement | 0x042E | | RadonConcentrationMeasurement | 0x042F | +| ThreadBorderRouterManagement | 0x0452 | | WakeOnLan | 0x0503 | | Channel | 0x0504 | | TargetNavigator | 0x0505 | @@ -143040,6 +143041,1343 @@ class SubscribeAttributeRadonConcentrationMeasurementClusterRevision : public Su } }; +#if MTR_ENABLE_PROVISIONAL +/*----------------------------------------------------------------------------*\ +| Cluster ThreadBorderRouterManagement | 0x0452 | +|------------------------------------------------------------------------------| +| Commands: | | +| * GetActiveDatasetRequest | 0x00 | +| * GetPendingDatasetRequest | 0x01 | +| * SetActiveDatasetRequest | 0x03 | +| * SetPendingDatasetRequest | 0x04 | +| * TopologyRequest | 0x05 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * BorderRouterName | 0x0000 | +| * BorderAgentId | 0x0001 | +| * ThreadVersion | 0x0002 | +| * InterfaceEnabled | 0x0003 | +| * ThreadNode | 0x0004 | +| * ActiveDatasetTimestamp | 0x0005 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +\*----------------------------------------------------------------------------*/ + +#if MTR_ENABLE_PROVISIONAL +/* + * Command GetActiveDatasetRequest + */ +class ThreadBorderRouterManagementGetActiveDatasetRequest : public ClusterCommand { +public: + ThreadBorderRouterManagementGetActiveDatasetRequest() + : ClusterCommand("get-active-dataset-request") + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRThreadBorderRouterManagementClusterGetActiveDatasetRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster getActiveDatasetRequestWithParams:params completion: + ^(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable values, NSError * _Nullable error) { + NSLog(@"Values: %@", values); + if (error == nil) { + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::Id; + RemoteDataModelLogger::LogCommandAsJSON(@(endpointId), @(clusterId), @(responseId), values); + } + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::Id; + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(responseId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command GetPendingDatasetRequest + */ +class ThreadBorderRouterManagementGetPendingDatasetRequest : public ClusterCommand { +public: + ThreadBorderRouterManagementGetPendingDatasetRequest() + : ClusterCommand("get-pending-dataset-request") + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::GetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRThreadBorderRouterManagementClusterGetPendingDatasetRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster getPendingDatasetRequestWithParams:params completion: + ^(MTRThreadBorderRouterManagementClusterDatasetResponseParams * _Nullable values, NSError * _Nullable error) { + NSLog(@"Values: %@", values); + if (error == nil) { + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::Id; + RemoteDataModelLogger::LogCommandAsJSON(@(endpointId), @(clusterId), @(responseId), values); + } + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::DatasetResponse::Id; + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(responseId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command SetActiveDatasetRequest + */ +class ThreadBorderRouterManagementSetActiveDatasetRequest : public ClusterCommand { +public: + ThreadBorderRouterManagementSetActiveDatasetRequest() + : ClusterCommand("set-active-dataset-request") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("ActiveDataset", &mRequest.activeDataset); +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRThreadBorderRouterManagementClusterSetActiveDatasetRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + params.activeDataset = [NSData dataWithBytes:mRequest.activeDataset.data() length:mRequest.activeDataset.size()]; +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + params.breadcrumb = [NSNumber numberWithUnsignedLongLong:mRequest.breadcrumb]; +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster setActiveDatasetRequestWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetActiveDatasetRequest::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command SetPendingDatasetRequest + */ +class ThreadBorderRouterManagementSetPendingDatasetRequest : public ClusterCommand { +public: + ThreadBorderRouterManagementSetPendingDatasetRequest() + : ClusterCommand("set-pending-dataset-request") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("PendingDataset", &mRequest.pendingDataset); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRThreadBorderRouterManagementClusterSetPendingDatasetRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + params.pendingDataset = [NSData dataWithBytes:mRequest.pendingDataset.data() length:mRequest.pendingDataset.size()]; +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster setPendingDatasetRequestWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::SetPendingDatasetRequest::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command TopologyRequest + */ +class ThreadBorderRouterManagementTopologyRequest : public ClusterCommand { +public: + ThreadBorderRouterManagementTopologyRequest() + : ClusterCommand("topology-request") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("Count", 0, UINT16_MAX, &mRequest.count); +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + AddArgument("StartIndex", 0, UINT16_MAX, &mRequest.startIndex); +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + AddArgument("Snapshot", 0, UINT8_MAX, &mRequest.snapshot); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRThreadBorderRouterManagementClusterTopologyRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + params.count = [NSNumber numberWithUnsignedShort:mRequest.count]; +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + params.startIndex = [NSNumber numberWithUnsignedShort:mRequest.startIndex]; +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + params.snapshot = [NSNumber numberWithUnsignedChar:mRequest.snapshot]; +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster topologyRequestWithParams:params completion: + ^(MTRThreadBorderRouterManagementClusterTopologyResponseParams * _Nullable values, NSError * _Nullable error) { + NSLog(@"Values: %@", values); + if (error == nil) { + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::Id; + RemoteDataModelLogger::LogCommandAsJSON(@(endpointId), @(clusterId), @(responseId), values); + } + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + constexpr chip::CommandId responseId = chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyResponse::Id; + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(responseId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::ThreadBorderRouterManagement::Commands::TopologyRequest::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL + +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute BorderRouterName + */ +class ReadThreadBorderRouterManagementBorderRouterName : public ReadAttribute { +public: + ReadThreadBorderRouterManagementBorderRouterName() + : ReadAttribute("border-router-name") + { + } + + ~ReadThreadBorderRouterManagementBorderRouterName() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::BorderRouterName::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeBorderRouterNameWithCompletion:^(NSString * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.BorderRouterName response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement BorderRouterName read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementBorderRouterName : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementBorderRouterName() + : SubscribeAttribute("border-router-name") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementBorderRouterName() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::BorderRouterName::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeBorderRouterNameWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSString * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.BorderRouterName response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute BorderAgentId + */ +class ReadThreadBorderRouterManagementBorderAgentId : public ReadAttribute { +public: + ReadThreadBorderRouterManagementBorderAgentId() + : ReadAttribute("border-agent-id") + { + } + + ~ReadThreadBorderRouterManagementBorderAgentId() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::BorderAgentId::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeBorderAgentIdWithCompletion:^(NSData * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.BorderAgentId response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement BorderAgentId read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementBorderAgentId : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementBorderAgentId() + : SubscribeAttribute("border-agent-id") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementBorderAgentId() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::BorderAgentId::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeBorderAgentIdWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSData * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.BorderAgentId response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ThreadVersion + */ +class ReadThreadBorderRouterManagementThreadVersion : public ReadAttribute { +public: + ReadThreadBorderRouterManagementThreadVersion() + : ReadAttribute("thread-version") + { + } + + ~ReadThreadBorderRouterManagementThreadVersion() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ThreadVersion::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeThreadVersionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ThreadVersion response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement ThreadVersion read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementThreadVersion : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementThreadVersion() + : SubscribeAttribute("thread-version") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementThreadVersion() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ThreadVersion::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeThreadVersionWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ThreadVersion response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute InterfaceEnabled + */ +class ReadThreadBorderRouterManagementInterfaceEnabled : public ReadAttribute { +public: + ReadThreadBorderRouterManagementInterfaceEnabled() + : ReadAttribute("interface-enabled") + { + } + + ~ReadThreadBorderRouterManagementInterfaceEnabled() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::InterfaceEnabled::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeInterfaceEnabledWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.InterfaceEnabled response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement InterfaceEnabled read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementInterfaceEnabled : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementInterfaceEnabled() + : SubscribeAttribute("interface-enabled") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementInterfaceEnabled() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::InterfaceEnabled::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeInterfaceEnabledWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.InterfaceEnabled response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ThreadNode + */ +class ReadThreadBorderRouterManagementThreadNode : public ReadAttribute { +public: + ReadThreadBorderRouterManagementThreadNode() + : ReadAttribute("thread-node") + { + } + + ~ReadThreadBorderRouterManagementThreadNode() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ThreadNode::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeThreadNodeWithCompletion:^(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ThreadNode response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement ThreadNode read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementThreadNode : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementThreadNode() + : SubscribeAttribute("thread-node") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementThreadNode() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ThreadNode::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeThreadNodeWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(MTRThreadBorderRouterManagementClusterThreadNodeStruct * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ThreadNode response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ActiveDatasetTimestamp + */ +class ReadThreadBorderRouterManagementActiveDatasetTimestamp : public ReadAttribute { +public: + ReadThreadBorderRouterManagementActiveDatasetTimestamp() + : ReadAttribute("active-dataset-timestamp") + { + } + + ~ReadThreadBorderRouterManagementActiveDatasetTimestamp() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeActiveDatasetTimestampWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ActiveDatasetTimestamp response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement ActiveDatasetTimestamp read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementActiveDatasetTimestamp : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementActiveDatasetTimestamp() + : SubscribeAttribute("active-dataset-timestamp") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementActiveDatasetTimestamp() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ActiveDatasetTimestamp::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeActiveDatasetTimestampWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ActiveDatasetTimestamp response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute GeneratedCommandList + */ +class ReadThreadBorderRouterManagementGeneratedCommandList : public ReadAttribute { +public: + ReadThreadBorderRouterManagementGeneratedCommandList() + : ReadAttribute("generated-command-list") + { + } + + ~ReadThreadBorderRouterManagementGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement GeneratedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementGeneratedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementGeneratedCommandList() + : SubscribeAttribute("generated-command-list") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeGeneratedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AcceptedCommandList + */ +class ReadThreadBorderRouterManagementAcceptedCommandList : public ReadAttribute { +public: + ReadThreadBorderRouterManagementAcceptedCommandList() + : ReadAttribute("accepted-command-list") + { + } + + ~ReadThreadBorderRouterManagementAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement AcceptedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementAcceptedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementAcceptedCommandList() + : SubscribeAttribute("accepted-command-list") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAcceptedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute EventList + */ +class ReadThreadBorderRouterManagementEventList : public ReadAttribute { +public: + ReadThreadBorderRouterManagementEventList() + : ReadAttribute("event-list") + { + } + + ~ReadThreadBorderRouterManagementEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement EventList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementEventList : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementEventList() + : SubscribeAttribute("event-list") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeEventListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AttributeList + */ +class ReadThreadBorderRouterManagementAttributeList : public ReadAttribute { +public: + ReadThreadBorderRouterManagementAttributeList() + : ReadAttribute("attribute-list") + { + } + + ~ReadThreadBorderRouterManagementAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement AttributeList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementAttributeList : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementAttributeList() + : SubscribeAttribute("attribute-list") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAttributeListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute FeatureMap + */ +class ReadThreadBorderRouterManagementFeatureMap : public ReadAttribute { +public: + ReadThreadBorderRouterManagementFeatureMap() + : ReadAttribute("feature-map") + { + } + + ~ReadThreadBorderRouterManagementFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement FeatureMap read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementFeatureMap : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementFeatureMap() + : SubscribeAttribute("feature-map") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeFeatureMapWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ClusterRevision + */ +class ReadThreadBorderRouterManagementClusterRevision : public ReadAttribute { +public: + ReadThreadBorderRouterManagementClusterRevision() + : ReadAttribute("cluster-revision") + { + } + + ~ReadThreadBorderRouterManagementClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ThreadBorderRouterManagement ClusterRevision read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeThreadBorderRouterManagementClusterRevision : public SubscribeAttribute { +public: + SubscribeAttributeThreadBorderRouterManagementClusterRevision() + : SubscribeAttribute("cluster-revision") + { + } + + ~SubscribeAttributeThreadBorderRouterManagementClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadBorderRouterManagement::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ThreadBorderRouterManagement::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterThreadBorderRouterManagement alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeClusterRevisionWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ThreadBorderRouterManagement.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#endif // MTR_ENABLE_PROVISIONAL /*----------------------------------------------------------------------------*\ | Cluster WakeOnLan | 0x0503 | |------------------------------------------------------------------------------| @@ -187891,6 +189229,86 @@ void registerClusterRadonConcentrationMeasurement(Commands & commands) commands.RegisterCluster(clusterName, clusterCommands); } +void registerClusterThreadBorderRouterManagement(Commands & commands) +{ +#if MTR_ENABLE_PROVISIONAL + using namespace chip::app::Clusters::ThreadBorderRouterManagement; + + const char * clusterName = "ThreadBorderRouterManagement"; + + commands_list clusterCommands = { + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + make_unique(Id), // + make_unique(Id), // + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + }; + + commands.RegisterCluster(clusterName, clusterCommands); +#endif // MTR_ENABLE_PROVISIONAL +} void registerClusterWakeOnLan(Commands & commands) { using namespace chip::app::Clusters::WakeOnLan; @@ -189301,6 +190719,7 @@ void registerClusters(Commands & commands) registerClusterPm10ConcentrationMeasurement(commands); registerClusterTotalVolatileOrganicCompoundsConcentrationMeasurement(commands); registerClusterRadonConcentrationMeasurement(commands); + registerClusterThreadBorderRouterManagement(commands); registerClusterWakeOnLan(commands); registerClusterChannel(commands); registerClusterTargetNavigator(commands); From c57c37311fd934721e906d8e4816fa43943bd479 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Tue, 14 May 2024 19:16:54 +0800 Subject: [PATCH 2/4] Add thread border router mgmt server implement --- .../thread-br-delegate.h | 90 ++++ .../thread-br-mgmt-server.cpp | 430 ++++++++++++++++++ .../thread-br-mgmt-server.h | 84 ++++ 3 files changed, 604 insertions(+) create mode 100644 src/app/clusters/thread-border-router-management-server/thread-br-delegate.h create mode 100644 src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.cpp create mode 100644 src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.h diff --git a/src/app/clusters/thread-border-router-management-server/thread-br-delegate.h b/src/app/clusters/thread-border-router-management-server/thread-br-delegate.h new file mode 100644 index 00000000000000..eb207bced65d23 --- /dev/null +++ b/src/app/clusters/thread-border-router-management-server/thread-br-delegate.h @@ -0,0 +1,90 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { +namespace ThreadBorderRouterManagement { + +constexpr size_t kBorderRouterNameMaxLength = 63; +constexpr size_t kBorderAgentIdLength = 16; + +class Delegate +{ +public: + Delegate() = default; + virtual ~Delegate() = default; + + using RouteTableEntry = Structs::RouteTableStruct::Type; + using ChildTableEntry = Structs::ChildTableStruct::Type; + class ThreadNode : public Structs::ThreadNodeStruct::Type + { + public: + Platform::ScopedMemoryBuffer Ipv6Addresses; + Platform::ScopedMemoryBuffer Ipv6AddressesSpans; + Platform::ScopedMemoryBuffer Routes; + Platform::ScopedMemoryBuffer Children; + }; + class Callback + { + public: + virtual void OnTopologyRequestFinished(Protocols::InteractionModel::Status status, uint8_t snapshot, + const Span & threadNodes) = 0; + + virtual ~Callback() = default; + }; + + virtual CHIP_ERROR Init() = 0; + + virtual CHIP_ERROR GetPanChangeSupported(bool & panChangeSupported) = 0; + + virtual CHIP_ERROR GetBorderRouterName(MutableCharSpan & borderRouterName) = 0; + + virtual CHIP_ERROR GetBorderAgentId(MutableByteSpan & borderAgentId) = 0; + + virtual CHIP_ERROR GetThreadVersion(uint16_t & threadVersion) = 0; + + virtual CHIP_ERROR GetInterfaceEnabled(bool & interfaceEnabled) = 0; + + virtual CHIP_ERROR GetThreadNode(ThreadNode & threadNode) = 0; + + virtual CHIP_ERROR GetActiveDataset(chip::Thread::OperationalDataset & activeDataset) = 0; + + virtual CHIP_ERROR GetPendingDataset(chip::Thread::OperationalDataset & pendingDataset) = 0; + + virtual CHIP_ERROR SetActiveDataset(const chip::Thread::OperationalDataset & activeDataset) = 0; + + virtual CHIP_ERROR SetPendingDataset(const chip::Thread::OperationalDataset & pendingDataset) = 0; + + virtual CHIP_ERROR GetTopology(uint8_t snapshot, Callback * callback) = 0; +}; + +} // namespace ThreadBorderRouterManagement +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.cpp b/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.cpp new file mode 100644 index 00000000000000..aa8b073c54a1be --- /dev/null +++ b/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.cpp @@ -0,0 +1,430 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "thread-br-mgmt-server.h" + +#include "app-common/zap-generated/cluster-objects.h" +#include "app-common/zap-generated/ids/Attributes.h" +#include "app-common/zap-generated/ids/Clusters.h" +#include "app-common/zap-generated/ids/Commands.h" +#include "app/AttributeAccessInterfaceRegistry.h" +#include "app/AttributeValueEncoder.h" +#include "app/CommandHandler.h" +#include "app/CommandHandlerInterface.h" +#include "app/InteractionModelEngine.h" +#include "app/clusters/general-commissioning-server/general-commissioning-server.h" +#include "app/data-model/List.h" +#include "app/data-model/Nullable.h" +#include "app/server/Server.h" +#include "lib/core/CHIPError.h" +#include "lib/support/CodeUtils.h" +#include "lib/support/Span.h" +#include "lib/support/ThreadOperationalDataset.h" +#include "lib/support/TypeTraits.h" +#include "protocols/interaction_model/StatusCode.h" + +namespace chip { +namespace app { +namespace Clusters { +namespace ThreadBorderRouterManagement { + +static Protocols::InteractionModel::Status MapChipErrorToIMStatus(CHIP_ERROR err) +{ + if (err == CHIP_ERROR_NO_MEMORY) + { + return Protocols::InteractionModel::Status::ResourceExhausted; + } + else if (err == CHIP_ERROR_NO_SHARED_TRUSTED_ROOT) + { + return Protocols::InteractionModel::Status::UnsupportedAccess; + } + else if (err == CHIP_ERROR_INVALID_ARGUMENT) + { + return Protocols::InteractionModel::Status::InvalidCommand; + } + else if (err == CHIP_ERROR_INCORRECT_STATE) + { + return Protocols::InteractionModel::Status::InvalidInState; + } + else if (err == CHIP_ERROR_NOT_FOUND) + { + return Protocols::InteractionModel::Status::NotFound; + } + return Protocols::InteractionModel::Status::Failure; +} + +static CHIP_ERROR AddStatusOnError(CommandHandlerInterface::HandlerContext & ctx, CHIP_ERROR err) +{ + if (CHIP_NO_ERROR != err) + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, MapChipErrorToIMStatus(err)); + } + return err; +} + +static bool CheckOverCASESession(CommandHandlerInterface::HandlerContext & ctx) +{ + chip::Messaging::ExchangeContext * exchangeCtx = ctx.mCommandHandler.GetExchangeContext(); + if (!exchangeCtx || !exchangeCtx->HasSessionHandle() || !exchangeCtx->GetSessionHandle()->IsSecureSession() || + exchangeCtx->GetSessionHandle()->AsSecureSession()->GetSecureSessionType() != Transport::SecureSession::Type::kCASE) + { + ChipLogError(Zcl, "This command MUST be over a valid CASE session"); + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::UnsupportedAccess); + return false; + } + return true; +} + +static bool CheckFailSafeArmed(CommandHandlerInterface::HandlerContext & ctx) +{ + auto & failSafeContext = chip::Server::GetInstance().GetFailSafeContext(); + if (failSafeContext.IsFailSafeArmed(ctx.mCommandHandler.GetAccessingFabricIndex())) + { + return true; + } + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::FailsafeRequired); + return false; +} + +void ServerInstance::HandleGetActiveDatasetRequest(HandlerContext & ctx, + const Commands::GetActiveDatasetRequest::DecodableType & req) +{ + VerifyOrReturn(CheckOverCASESession(ctx)); + + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_UNINITIALIZED)); + } + + bool interfaceEnabled; + ReturnOnFailure(AddStatusOnError(ctx, mDelegate->GetInterfaceEnabled(interfaceEnabled))); + if (!interfaceEnabled) + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Success); + return; + } + Commands::DatasetResponse::Type response; + Thread::OperationalDataset activeDataset; + ReturnOnFailure(AddStatusOnError(ctx, mDelegate->GetActiveDataset(activeDataset))); + response.dataset = activeDataset.AsByteSpan(); + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} + +void ServerInstance::HandleGetPendingDatasetRequest(HandlerContext & ctx, + const Commands::GetPendingDatasetRequest::DecodableType & req) +{ + Commands::DatasetResponse::Type response; + VerifyOrReturn(CheckOverCASESession(ctx)); + + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_UNINITIALIZED)); + } + + Thread::OperationalDataset pendingDataset; + ReturnOnFailure(AddStatusOnError(ctx, mDelegate->GetPendingDataset(pendingDataset))); + response.dataset = pendingDataset.AsByteSpan(); + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} + +void ServerInstance::HandleSetActiveDatasetRequest(HandlerContext & ctx, + const Commands::SetActiveDatasetRequest::DecodableType & req) +{ + VerifyOrReturn(CheckOverCASESession(ctx)); + VerifyOrReturn(CheckFailSafeArmed(ctx)); + + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_UNINITIALIZED)); + } + Thread::OperationalDataset activeDataset; + Thread::OperationalDataset currentActiveDataset; + uint64_t currentActiveDatasetTimestamp; + if (activeDataset.Init(req.activeDataset) != CHIP_NO_ERROR) + { + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_INVALID_ARGUMENT)); + } + if (mDelegate->GetActiveDataset(currentActiveDataset) == CHIP_NO_ERROR && + currentActiveDataset.GetActiveTimestamp(currentActiveDatasetTimestamp) == CHIP_NO_ERROR) + { + // When the ActiveDatasetTimestamp attribute is not null, the command SHALL fail with a status + // code of INVALID_IN_STATE + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_INCORRECT_STATE)); + } + if (mDelegate->SetActiveDataset(activeDataset) != CHIP_NO_ERROR) + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Failure); + } + else + { + GeneralCommissioning::SetBreadcrumb(req.breadcrumb); + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Success); + } +} + +void ServerInstance::HandleSetPendingDatasetRequest(HandlerContext & ctx, + const Commands::SetPendingDatasetRequest::DecodableType & req) +{ + VerifyOrReturn(CheckOverCASESession(ctx)); + + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_UNINITIALIZED)); + } + bool panChangeSupported; + if (mDelegate->GetPanChangeSupported(panChangeSupported) != CHIP_NO_ERROR || !panChangeSupported) + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::UnsupportedCommand); + return; + } + Thread::OperationalDataset pendingDataset; + if (pendingDataset.Init(req.pendingDataset) != CHIP_NO_ERROR) + { + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_INVALID_ARGUMENT)); + return; + } + if (mDelegate->SetPendingDataset(pendingDataset) != CHIP_NO_ERROR) + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Failure); + } + else + { + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Success); + } +} + +void ServerInstance::OnTopologyRequestFinished(Protocols::InteractionModel::Status status, uint8_t snapshot, + const Span & threadNodes) +{ + Commands::TopologyResponse::Type response; + auto commandHandleRef = std::move(mAsyncCommandHandle); + auto commandHandle = commandHandleRef.Get(); + if (status != Protocols::InteractionModel::Status::Success) + { + response.status = to_underlying(status); + commandHandle->AddResponse(mCommandPath, response); + return; + } + if (threadNodes.size() < mTopologyReq.startIndex) + { + response.status = to_underlying(Protocols::InteractionModel::Status::ResourceExhausted); + commandHandle->AddResponse(mCommandPath, response); + return; + } + uint16_t threadNodesCount = threadNodes.size() - mTopologyReq.startIndex; + threadNodesCount = threadNodesCount > mTopologyReq.count ? mTopologyReq.count : threadNodesCount; + response.snapshot = snapshot; + response.numberOfDevices = threadNodes.size(); + response.status = to_underlying(Protocols::InteractionModel::Status::Success); + if (threadNodesCount == 0) + { + // return a response with a NULL ThreadTopology + commandHandle->AddResponse(mCommandPath, response); + return; + } + Platform::ScopedMemoryBuffer threadNodesStuctsBuffer; + threadNodesStuctsBuffer.Alloc(threadNodesCount); + if (!threadNodesStuctsBuffer.Get()) + { + response.status = to_underlying(Protocols::InteractionModel::Status::ResourceExhausted); + commandHandle->AddResponse(mCommandPath, response); + return; + } + for (size_t index = 0; index < threadNodesCount; ++index) + { + threadNodesStuctsBuffer[index] = threadNodes[mTopologyReq.startIndex + index]; + } + response.threadTopology = + DataModel::List(threadNodesStuctsBuffer.Get(), threadNodesCount); + commandHandle->AddResponse(mCommandPath, response); +} + +void ServerInstance::HandleTopologyRequest(HandlerContext & ctx, const Commands::TopologyRequest::DecodableType & req) +{ + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + ReturnOnFailure(AddStatusOnError(ctx, CHIP_ERROR_UNINITIALIZED)); + } + mAsyncCommandHandle = CommandHandler::Handle(&ctx.mCommandHandler); + mTopologyReq = req; + ctx.mCommandHandler.FlushAcksRightAwayOnSlowCommand(); + CHIP_ERROR err = mDelegate->GetTopology(req.snapshot, this); + if (err != CHIP_NO_ERROR) + { + OnTopologyRequestFinished(MapChipErrorToIMStatus(err), 0, Span()); + } +} + +void ServerInstance::InvokeCommand(HandlerContext & ctx) +{ + if (mAsyncCommandHandle.Get() != nullptr) + { + // We have a command processing in the backend, reject all incoming commands. + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Protocols::InteractionModel::Status::Busy); + ctx.SetCommandHandled(); + return; + } + mCommandPath = ctx.mRequestPath; + switch (ctx.mRequestPath.mCommandId) + { + case Commands::GetActiveDatasetRequest::Id: + HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandleGetActiveDatasetRequest(ctx, req); }); + return; + case Commands::GetPendingDatasetRequest::Id: + HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandleGetPendingDatasetRequest(ctx, req); }); + return; + case Commands::SetActiveDatasetRequest::Id: + HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandleSetActiveDatasetRequest(ctx, req); }); + return; + case Commands::SetPendingDatasetRequest::Id: + HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandleSetPendingDatasetRequest(ctx, req); }); + return; + case Commands::TopologyRequest::Id: + HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandleTopologyRequest(ctx, req); }); + return; + } +} + +CHIP_ERROR ServerInstance::ReadFeatureMap(AttributeValueEncoder & aEncoder) +{ + BitFlags featureMap; + bool panChangeSupported; + ReturnErrorOnFailure(mDelegate->GetPanChangeSupported(panChangeSupported)); + if (panChangeSupported) + { + featureMap.Set(Feature::kPANChange); + } + return aEncoder.Encode(featureMap); +} + +CHIP_ERROR ServerInstance::ReadBorderRouterName(AttributeValueEncoder & aEncoder) +{ + char borderRouterName[kBorderRouterNameMaxLength]; + MutableCharSpan borderRouterNameSpan(borderRouterName); + ReturnErrorOnFailure(mDelegate->GetBorderRouterName(borderRouterNameSpan)); + return aEncoder.Encode(chip::CharSpan(borderRouterName, borderRouterNameSpan.size())); +} + +CHIP_ERROR ServerInstance::ReadBorderAgentID(AttributeValueEncoder & aEncoder) +{ + uint8_t borderAgentId[kBorderAgentIdLength]; + MutableByteSpan borderAgentIdSpan(borderAgentId); + ReturnErrorOnFailure(mDelegate->GetBorderAgentId(borderAgentIdSpan)); + return aEncoder.Encode(chip::ByteSpan(borderAgentId)); +} + +CHIP_ERROR ServerInstance::ReadThreadVersion(AttributeValueEncoder & aEncoder) +{ + uint16_t threadVersion; + ReturnErrorOnFailure(mDelegate->GetThreadVersion(threadVersion)); + return aEncoder.Encode(threadVersion); +} + +CHIP_ERROR ServerInstance::ReadInterfaceEnabled(AttributeValueEncoder & aEncoder) +{ + bool interfaceEnabled; + ReturnErrorOnFailure(mDelegate->GetInterfaceEnabled(interfaceEnabled)); + return aEncoder.Encode(interfaceEnabled); +} + +CHIP_ERROR ServerInstance::ReadThreadNode(AttributeValueEncoder & aEncoder) +{ + Delegate::ThreadNode threadNode; + ReturnErrorOnFailure(mDelegate->GetThreadNode(threadNode)); + return aEncoder.Encode(threadNode); +} + +CHIP_ERROR ServerInstance::ReadActiveDatasetTimestamp(AttributeValueEncoder & aEncoder) +{ + Thread::OperationalDataset activeDataset; + uint64_t activeDatasetTimestamp; + if (mDelegate->GetActiveDataset(activeDataset) == CHIP_NO_ERROR && + activeDataset.GetActiveTimestamp(activeDatasetTimestamp) == CHIP_NO_ERROR) + { + return aEncoder.Encode(DataModel::MakeNullable(activeDatasetTimestamp)); + } + return aEncoder.Encode(DataModel::Nullable()); +} + +CHIP_ERROR ServerInstance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) +{ + if (aPath.mClusterId != ThreadBorderRouterManagement::Id) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + if (!mDelegate) + { + ChipLogError(Zcl, "Thread Border Router Management server not initialized"); + return CHIP_ERROR_UNINITIALIZED; + } + CHIP_ERROR status = CHIP_NO_ERROR; + switch (aPath.mAttributeId) + { + case Globals::Attributes::FeatureMap::Id: + status = ReadFeatureMap(aEncoder); + break; + case Attributes::BorderRouterName::Id: + status = ReadBorderRouterName(aEncoder); + break; + case Attributes::BorderAgentId::Id: + status = ReadBorderAgentID(aEncoder); + break; + case Attributes::ThreadVersion::Id: + status = ReadThreadVersion(aEncoder); + break; + case Attributes::InterfaceEnabled::Id: + status = ReadInterfaceEnabled(aEncoder); + break; + case Attributes::ThreadNode::Id: + status = ReadThreadNode(aEncoder); + break; + case Attributes::ActiveDatasetTimestamp::Id: + status = ReadActiveDatasetTimestamp(aEncoder); + break; + default: + break; + } + return status; +} + +CHIP_ERROR ServerInstance::Init() +{ + ReturnErrorCodeIf(!mDelegate, CHIP_ERROR_INVALID_ARGUMENT); + ReturnErrorOnFailure(InteractionModelEngine::GetInstance()->RegisterCommandHandler(this)); + VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE); + return mDelegate->Init(); +} + +} // namespace ThreadBorderRouterManagement +} // namespace Clusters +} // namespace app +} // namespace chip + +void MatterThreadBorderRouterManagementPluginServerInitCallback() +{ + // Nothing to do, the server init routine will be done in Instance::Init() +} diff --git a/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.h b/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.h new file mode 100644 index 00000000000000..3ea8945fbad3c3 --- /dev/null +++ b/src/app/clusters/thread-border-router-management-server/thread-br-mgmt-server.h @@ -0,0 +1,84 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "thread-br-delegate.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { +namespace ThreadBorderRouterManagement { + +class ServerInstance : public CommandHandlerInterface, public AttributeAccessInterface, public Delegate::Callback +{ +public: + ServerInstance(EndpointId endpointId, Delegate * delegate) : + CommandHandlerInterface(Optional(endpointId), Id), + AttributeAccessInterface(Optional(endpointId), Id), mDelegate(delegate) + {} + virtual ~ServerInstance() = default; + + CHIP_ERROR Init(); + + // CommandHanlerInterface + void InvokeCommand(HandlerContext & ctx) override; + + // AttributeAccessInterface + CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override; + + // DelegateInterface + + void OnTopologyRequestFinished(Protocols::InteractionModel::Status status, uint8_t snapshot, + const Span & threadNodes) override; + +private: + // Command Handlers + void HandleGetActiveDatasetRequest(HandlerContext & ctx, const Commands::GetActiveDatasetRequest::DecodableType & req); + void HandleGetPendingDatasetRequest(HandlerContext & ctx, const Commands::GetPendingDatasetRequest::DecodableType & req); + void HandleSetActiveDatasetRequest(HandlerContext & ctx, const Commands::SetActiveDatasetRequest::DecodableType & req); + void HandleSetPendingDatasetRequest(HandlerContext & ctx, const Commands::SetPendingDatasetRequest::DecodableType & req); + void HandleTopologyRequest(HandlerContext & ctx, const Commands::TopologyRequest::DecodableType & req); + + // Attribute Read handler + CHIP_ERROR ReadFeatureMap(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadBorderRouterName(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadBorderAgentID(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadThreadVersion(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadInterfaceEnabled(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadThreadNode(AttributeValueEncoder & aEncoder); + CHIP_ERROR ReadActiveDatasetTimestamp(AttributeValueEncoder & aEncoder); + + Delegate * mDelegate; + app::CommandHandler::Handle mAsyncCommandHandle; + ConcreteCommandPath mCommandPath = ConcreteCommandPath(0, 0, 0); + Commands::TopologyRequest::DecodableType mTopologyReq; +}; + +} // namespace ThreadBorderRouterManagement +} // namespace Clusters +} // namespace app +} // namespace chip From 88e3b2d1043846ccafb77e8a70d6fb48337a9ff9 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Tue, 14 May 2024 19:26:13 +0800 Subject: [PATCH 3/4] Add thread br app for ESP32 --- .../esp32/common/CommonDeviceCallbacks.cpp | 8 + .../esp32/common/CommonDeviceCallbacks.h | 1 + .../platform/esp32/common/Esp32AppServer.cpp | 2 +- .../platform/esp32/common/Esp32ThreadInit.h | 47 + examples/thread-br-app/esp32/.gitignore | 5 + examples/thread-br-app/esp32/CMakeLists.txt | 49 + .../thread-br-app/esp32/main/CMakeLists.txt | 73 + .../esp32/main/DeviceCallbacks.cpp | 61 + .../main/ESP32ThreadBorderRouterDelegate.cpp | 526 +++ .../esp32/main/Kconfig.projbuild | 45 + .../esp32/main/include/DeviceCallbacks.h | 45 + .../include/ESP32ThreadBorderRouterDelegate.h | 111 + examples/thread-br-app/esp32/main/main.cpp | 152 + examples/thread-br-app/esp32/partitions.csv | 7 + .../thread-br-app/esp32/sdkconfig.defaults | 73 + .../esp32/third_party/connectedhomeip | 1 + .../thread-br-common/thread-br-app.matter | 1546 +++++++++ .../thread-br-common/thread-br-app.zap | 3081 +++++++++++++++++ third_party/infineon/repos/matter-wpan-sdk | 2 +- 19 files changed, 5833 insertions(+), 2 deletions(-) create mode 100644 examples/thread-br-app/esp32/.gitignore create mode 100644 examples/thread-br-app/esp32/CMakeLists.txt create mode 100644 examples/thread-br-app/esp32/main/CMakeLists.txt create mode 100644 examples/thread-br-app/esp32/main/DeviceCallbacks.cpp create mode 100644 examples/thread-br-app/esp32/main/ESP32ThreadBorderRouterDelegate.cpp create mode 100644 examples/thread-br-app/esp32/main/Kconfig.projbuild create mode 100644 examples/thread-br-app/esp32/main/include/DeviceCallbacks.h create mode 100644 examples/thread-br-app/esp32/main/include/ESP32ThreadBorderRouterDelegate.h create mode 100644 examples/thread-br-app/esp32/main/main.cpp create mode 100644 examples/thread-br-app/esp32/partitions.csv create mode 100644 examples/thread-br-app/esp32/sdkconfig.defaults create mode 120000 examples/thread-br-app/esp32/third_party/connectedhomeip create mode 100644 examples/thread-br-app/thread-br-common/thread-br-app.matter create mode 100644 examples/thread-br-app/thread-br-common/thread-br-app.zap diff --git a/examples/platform/esp32/common/CommonDeviceCallbacks.cpp b/examples/platform/esp32/common/CommonDeviceCallbacks.cpp index 7203a0cd6a92cf..2dfcffef3dece8 100644 --- a/examples/platform/esp32/common/CommonDeviceCallbacks.cpp +++ b/examples/platform/esp32/common/CommonDeviceCallbacks.cpp @@ -84,6 +84,14 @@ void CommonDeviceCallbacks::DeviceEventCallback(const ChipDeviceEvent * event, i // newly selected address. chip::app::DnssdServer::Instance().StartServer(); } + if (event->InterfaceIpAddressChanged.Type == InterfaceIpChangeType::kIpV6_Assigned) + { + appDelegate = DeviceCallbacksDelegate::Instance().GetAppDelegate(); + if (appDelegate != nullptr) + { + appDelegate->OnIPv6ConnectivityEstablished(); + } + } break; } diff --git a/examples/platform/esp32/common/CommonDeviceCallbacks.h b/examples/platform/esp32/common/CommonDeviceCallbacks.h index f76cdc405aa80e..de6770f1ee311d 100644 --- a/examples/platform/esp32/common/CommonDeviceCallbacks.h +++ b/examples/platform/esp32/common/CommonDeviceCallbacks.h @@ -41,6 +41,7 @@ class DeviceCallbacksDelegate virtual void OnIPv4ConnectivityEstablished() {} virtual void OnIPv4ConnectivityLost() {} virtual void OnDnssdInitialized() {} + virtual void OnIPv6ConnectivityEstablished() {} DeviceCallbacksDelegate * mDelegate = nullptr; void SetAppDelegate(DeviceCallbacksDelegate * delegate) { mDelegate = delegate; } DeviceCallbacksDelegate * GetAppDelegate() { return mDelegate; } diff --git a/examples/platform/esp32/common/Esp32AppServer.cpp b/examples/platform/esp32/common/Esp32AppServer.cpp index 4f854c518bd01f..07669684eeae50 100644 --- a/examples/platform/esp32/common/Esp32AppServer.cpp +++ b/examples/platform/esp32/common/Esp32AppServer.cpp @@ -48,7 +48,7 @@ static constexpr char TAG[] = "ESP32Appserver"; namespace { #if CHIP_DEVICE_CONFIG_ENABLE_WIFI -#if CHIP_DEVICE_CONFIG_ENABLE_THREAD || CHIP_DEVICE_CONFIG_ENABLE_ETHERNET +#if (CHIP_DEVICE_CONFIG_ENABLE_THREAD && !defined(CONFIG_OPENTHREAD_BORDER_ROUTER)) || CHIP_DEVICE_CONFIG_ENABLE_ETHERNET constexpr chip::EndpointId kNetworkCommissioningEndpointWiFi = 0xFFFE; #else constexpr chip::EndpointId kNetworkCommissioningEndpointWiFi = 0; diff --git a/examples/platform/esp32/common/Esp32ThreadInit.h b/examples/platform/esp32/common/Esp32ThreadInit.h index f6edba24b2b82f..6395a78ef41691 100644 --- a/examples/platform/esp32/common/Esp32ThreadInit.h +++ b/examples/platform/esp32/common/Esp32ThreadInit.h @@ -22,10 +22,57 @@ #if CONFIG_OPENTHREAD_ENABLED #include "esp_openthread_types.h" +#if CONFIG_OPENTHREAD_RADIO_NATIVE #define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG() \ { \ .radio_mode = RADIO_MODE_NATIVE, \ } +#elif CONFIG_OPENTHREAD_RADIO_SPINEL_UART +#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG() \ + { \ + .radio_mode = RADIO_MODE_UART_RCP, \ + .radio_uart_config = { \ + .port = UART_NUM_1, \ + .uart_config = \ + { \ + .baud_rate = 460800, \ + .data_bits = UART_DATA_8_BITS, \ + .parity = UART_PARITY_DISABLE, \ + .stop_bits = UART_STOP_BITS_1, \ + .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, \ + .rx_flow_ctrl_thresh = 0, \ + .source_clk = UART_SCLK_DEFAULT, \ + }, \ + .rx_pin = GPIO_NUM_17, \ + .tx_pin = GPIO_NUM_18, \ + }, \ + } +#else +#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG() \ + { \ + .radio_mode = RADIO_MODE_SPI_RCP, \ + .radio_spi_config = { \ + .host_device = SPI2_HOST, \ + .dma_channel = 2, \ + .spi_interface = \ + { \ + .mosi_io_num = 11, \ + .sclk_io_num = 12, \ + .miso_io_num = 13, \ + }, \ + .spi_device = \ + { \ + .cs_ena_pretrans = 2, \ + .input_delay_ns = 100, \ + .mode = 0, \ + .clock_speed_hz = 2500 * 1000, \ + .spics_io_num = 10, \ + .queue_size = 5, \ + }, \ + .intr_pin = 8, \ + }, \ + } +#endif // CONFIG_OPENTHREAD_RADIO_SPINEL_UART OR CONFIG_OPENTHREAD_RADIO_SPINEL_SPI #define ESP_OPENTHREAD_DEFAULT_HOST_CONFIG() \ { \ diff --git a/examples/thread-br-app/esp32/.gitignore b/examples/thread-br-app/esp32/.gitignore new file mode 100644 index 00000000000000..234526a082ad26 --- /dev/null +++ b/examples/thread-br-app/esp32/.gitignore @@ -0,0 +1,5 @@ +*.vscode + +/build/ +/sdkconfig +/sdkconfig.old diff --git a/examples/thread-br-app/esp32/CMakeLists.txt b/examples/thread-br-app/esp32/CMakeLists.txt new file mode 100644 index 00000000000000..22ae0cf4c53c46 --- /dev/null +++ b/examples/thread-br-app/esp32/CMakeLists.txt @@ -0,0 +1,49 @@ +# +# Copyright (c) 2021 Project CHIP Authors +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# The following lines of boilerplate have to be in your project's +# CMakeLists in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.5) + +set(PROJECT_VER "v1.0") +set(PROJECT_VER_NUMBER 1) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/../../common/cmake/idf_flashing.cmake) + +set(EXTRA_COMPONENT_DIRS + "${CMAKE_CURRENT_LIST_DIR}/third_party/connectedhomeip/config/esp32/components" +) + +project(chip-thread-br-app) + +# C++17 is required for RPC build. +idf_build_set_property(CXX_COMPILE_OPTIONS "-std=gnu++17;-Os;-DCHIP_HAVE_CONFIG_H" APPEND) +idf_build_set_property(C_COMPILE_OPTIONS "-Os" APPEND) +# For the C3, project_include.cmake sets -Wno-format, but does not clear various +# flags that depend on -Wformat +idf_build_set_property(COMPILE_OPTIONS "-Wno-format-nonliteral;-Wno-format-security" APPEND) + +# We don't need Thread Network Commissioning Driver +idf_build_set_property(COMPILE_OPTIONS "-D_NO_NETWORK_COMMISSIONING_DRIVER_" APPEND) + +# -Wmaybe-uninitialized has too many false positives, including on std::optional +# and chip::Optional. Make it nonfatal. +# +# See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635 +idf_build_set_property(COMPILE_OPTIONS "-Wno-error=maybe-uninitialized" APPEND) + +flashing_script() diff --git a/examples/thread-br-app/esp32/main/CMakeLists.txt b/examples/thread-br-app/esp32/main/CMakeLists.txt new file mode 100644 index 00000000000000..c0cb1234b0cca3 --- /dev/null +++ b/examples/thread-br-app/esp32/main/CMakeLists.txt @@ -0,0 +1,73 @@ +# +# Copyright (c) 2022 Project CHIP Authors +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) +idf_component_register(PRIV_INCLUDE_DIRS + "${CMAKE_CURRENT_LIST_DIR}/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" + SRC_DIRS + "${CMAKE_CURRENT_LIST_DIR}" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/zzz_generated/app-common/app-common/zap-generated/attributes" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/zzz_generated/app-common/app-common/zap-generated" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/ota" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/common" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/shell_extension" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/util" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/reporting" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/icd/server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/access-control-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/administrator-commissioning-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/basic-information" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/bindings" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/descriptor" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/diagnostic-logs-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ethernet-network-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/fixed-label-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/general-commissioning-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/general-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/identify-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/localization-configuration-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/time-format-localization-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/network-commissioning" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/operational-credentials-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ota-requestor" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/power-source-configuration-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/software-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/thread-network-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/thread-border-router-management-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/user-label-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/wifi-network-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ota-requestor" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/groups-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/group-key-mgmt-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/time-synchronization-server") + +get_filename_component(CHIP_ROOT ${CMAKE_SOURCE_DIR}/third_party/connectedhomeip REALPATH) + +include("${CHIP_ROOT}/build/chip/esp32/esp32_codegen.cmake") + +chip_app_component_codegen("${CHIP_ROOT}/examples/thread-br-app/thread-br-common/thread-br-app.matter") +chip_app_component_zapgen("${CHIP_ROOT}/examples/thread-br-app/thread-br-common/thread-br-app.zap") + +set_property(TARGET ${COMPONENT_LIB} PROPERTY CXX_STANDARD 17) +target_compile_options(${COMPONENT_LIB} PRIVATE "-DCHIP_HAVE_CONFIG_H") +target_compile_options(${COMPONENT_LIB} PUBLIC + "-DCHIP_ADDRESS_RESOLVE_IMPL_INCLUDE_HEADER=" +) diff --git a/examples/thread-br-app/esp32/main/DeviceCallbacks.cpp b/examples/thread-br-app/esp32/main/DeviceCallbacks.cpp new file mode 100644 index 00000000000000..6925df9b21da8f --- /dev/null +++ b/examples/thread-br-app/esp32/main/DeviceCallbacks.cpp @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file DeviceCallbacks.cpp + * + * Implements all the callbacks to the application from the CHIP Stack + * + **/ + +#include "DeviceCallbacks.h" +#include "common/Esp32ThreadInit.h" +#include "platform/ESP32/OpenthreadLauncher.h" +#include "platform/ThreadStackManager.h" +#include +#include +#include +#include + +static const char TAG[] = "thread-br-app-callbacks"; + +using namespace chip; +using namespace chip::Inet; +using namespace chip::System; +using namespace chip::app::Clusters; + +void AppDeviceCallbacks::PostAttributeChangeCallback(EndpointId endpointId, ClusterId clusterId, AttributeId attributeId, + uint8_t type, uint16_t size, uint8_t * value) +{ + ESP_LOGI(TAG, "PostAttributeChangeCallback - Cluster ID: '0x%" PRIx32 "', EndPoint ID: '0x%x', Attribute ID: '0x%" PRIx32 "'", + clusterId, endpointId, attributeId); + + ESP_LOGI(TAG, "Current free heap: %u\n", static_cast(heap_caps_get_free_size(MALLOC_CAP_8BIT))); +} + +void AppDeviceCallbacksDelegate::OnIPv6ConnectivityEstablished(void) +{ + static bool sThreadBRInitialized = false; + if (!sThreadBRInitialized) + { + esp_openthread_lock_acquire(portMAX_DELAY); + esp_openthread_border_router_init(); + esp_openthread_lock_release(); + sThreadBRInitialized = true; + } +} diff --git a/examples/thread-br-app/esp32/main/ESP32ThreadBorderRouterDelegate.cpp b/examples/thread-br-app/esp32/main/ESP32ThreadBorderRouterDelegate.cpp new file mode 100644 index 00000000000000..6b354fde2a9548 --- /dev/null +++ b/examples/thread-br-app/esp32/main/ESP32ThreadBorderRouterDelegate.cpp @@ -0,0 +1,526 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ESP32ThreadBorderRouterDelegate.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { + +using Protocols::InteractionModel::Status; + +namespace ThreadBorderRouterManagement { + +class ScopedThreadLock +{ +public: + ScopedThreadLock() { DeviceLayer::ThreadStackMgr().LockThreadStack(); } + ~ScopedThreadLock() { DeviceLayer::ThreadStackMgr().UnlockThreadStack(); } +}; + +static RoutingRoleEnum MapRoutingRole(otDeviceRole role, bool isFTD, bool rxOnWhenIdle) +{ + if (role == OT_DEVICE_ROLE_DISABLED || role == OT_DEVICE_ROLE_DETACHED) + { + return RoutingRoleEnum::kUnassigned; + } + else if (role == OT_DEVICE_ROLE_CHILD) + { + if (rxOnWhenIdle) + { + return isFTD ? RoutingRoleEnum::kReed : RoutingRoleEnum::kEndDevice; + } + else + { + return RoutingRoleEnum::kSleepyEndDevice; + } + } + else if (role == OT_DEVICE_ROLE_ROUTER) + { + return RoutingRoleEnum::kRouter; + } + else if (role == OT_DEVICE_ROLE_LEADER) + { + return RoutingRoleEnum::kLeader; + } + return RoutingRoleEnum::kUnspecified; +} + +void ClearThreadNode(Delegate::ThreadNode & threadNode) +{ + threadNode.Routes.Free(); + threadNode.routeTable = DataModel::List(); + threadNode.Ipv6Addresses.Free(); + threadNode.Ipv6AddressesSpans.Free(); + threadNode.IPv6s = DataModel::List(); + threadNode.Children.Free(); + threadNode.childTable = DataModel::List(); +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetBorderAgentId(MutableByteSpan & borderAgentIdSpan) +{ + otBorderAgentId borderAgentId; + if (borderAgentIdSpan.size() < sizeof(borderAgentId.mId)) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + ScopedThreadLock threadLock; + otError err = otBorderAgentGetId(esp_openthread_get_instance(), &borderAgentId); + if (err == OT_ERROR_NONE) + { + memcpy(borderAgentIdSpan.data(), borderAgentId.mId, sizeof(borderAgentId.mId)); + borderAgentIdSpan.reduce_size(sizeof(borderAgentId.mId)); + return CHIP_NO_ERROR; + } + return CHIP_ERROR_INTERNAL; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetThreadVersion(uint16_t & threadVersion) +{ + threadVersion = otThreadGetVersion(); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetInterfaceEnabled(bool & interfaceEnabled) +{ + ScopedThreadLock threadLock; + interfaceEnabled = otIp6IsEnabled(esp_openthread_get_instance()); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetThreadNode(ThreadNode & threadNode) +{ + ScopedThreadLock threadLock; + ReturnErrorOnFailure(GetExtAddress(threadNode.extAddress)); + ReturnErrorOnFailure(GetRolc16(threadNode.rloc16)); + ReturnErrorOnFailure(GetRoutingRole(threadNode.routingRole)); + threadNode.Ipv6Addresses.Alloc(kOpenThreadMaxIPv6AddressCount); + threadNode.Ipv6AddressesSpans.Alloc(kOpenThreadMaxIPv6AddressCount); + ReturnErrorCodeIf((!threadNode.Ipv6Addresses.Get()) || (!threadNode.Ipv6AddressesSpans.Get()), CHIP_ERROR_NO_MEMORY); + Span ipv6AddrsSpan(threadNode.Ipv6Addresses.Get(), kOpenThreadMaxIPv6AddressCount); + ReturnErrorOnFailure(GetIpv6s(ipv6AddrsSpan)); + for (size_t i = 0; i < ipv6AddrsSpan.size(); ++i) + { + threadNode.Ipv6AddressesSpans[i] = + ByteSpan((uint8_t *) threadNode.Ipv6Addresses[i].Addr, sizeof(threadNode.Ipv6Addresses[i].Addr)); + } + threadNode.IPv6s = DataModel::List(threadNode.Ipv6AddressesSpans.Get(), ipv6AddrsSpan.size()); + threadNode.Routes.Alloc(kOpenThreadMaxRouterId); + ReturnErrorCodeIf(!threadNode.Routes.Get(), CHIP_ERROR_NO_MEMORY); + Span routeTableSpan(threadNode.Routes.Get(), kOpenThreadMaxRouterId); + ReturnErrorOnFailure(GetRouteTable(routeTableSpan)); + threadNode.routeTable = DataModel::List(routeTableSpan); + threadNode.Children.Alloc(kOpenThreadMaxChildCount); + ReturnErrorCodeIf(!threadNode.Children.Get(), CHIP_ERROR_NO_MEMORY); + Span childTableSpan(threadNode.Children.Get(), kOpenThreadMaxChildCount); + ReturnErrorOnFailure(GetChildTable(childTableSpan)); + threadNode.childTable = DataModel::List(childTableSpan); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetActiveDataset(chip::Thread::OperationalDataset & activeDataset) +{ + ScopedThreadLock threadLock; + otOperationalDatasetTlvs datasetTlvs; + otError otErr = otDatasetGetActiveTlvs(esp_openthread_get_instance(), &datasetTlvs); + if (otErr == OT_ERROR_NONE) + { + return activeDataset.Init(ByteSpan(datasetTlvs.mTlvs, datasetTlvs.mLength)); + } + return CHIP_ERROR_NOT_FOUND; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetPendingDataset(chip::Thread::OperationalDataset & pendingDataset) +{ + ScopedThreadLock threadLock; + otOperationalDatasetTlvs datasetTlvs; + otError otErr = otDatasetGetPendingTlvs(esp_openthread_get_instance(), &datasetTlvs); + if (otErr == OT_ERROR_NONE) + { + return pendingDataset.Init(ByteSpan(datasetTlvs.mTlvs, datasetTlvs.mLength)); + } + return CHIP_ERROR_NOT_FOUND; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::SetActiveDataset(const chip::Thread::OperationalDataset & activeDataset) +{ + otInstance * otInst = esp_openthread_get_instance(); + ReturnErrorCodeIf(!otInst, CHIP_ERROR_INCORRECT_STATE); + otOperationalDatasetTlvs datasetTlvs; + ScopedThreadLock threadLock; + if (otDatasetGetActiveTlvs(otInst, &datasetTlvs) != OT_ERROR_NONE || activeDataset.AsByteSpan().size() != datasetTlvs.mLength || + memcmp(datasetTlvs.mTlvs, activeDataset.AsByteSpan().data(), datasetTlvs.mLength) != 0) + { + memcpy(datasetTlvs.mTlvs, activeDataset.AsByteSpan().data(), activeDataset.AsByteSpan().size()); + datasetTlvs.mLength = activeDataset.AsByteSpan().size(); + + // Disable thread before setting active dataset + ReturnErrorOnFailure(SetThreadEnabled(false)); + ReturnErrorCodeIf(otDatasetSetActiveTlvs(otInst, &datasetTlvs) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + } + ReturnErrorOnFailure(SetThreadEnabled(true)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::SetPendingDataset(const chip::Thread::OperationalDataset & pendingDataset) +{ + ScopedThreadLock threadLock; + otOperationalDatasetTlvs datasetTlvs; + memcpy(datasetTlvs.mTlvs, pendingDataset.AsByteSpan().data(), pendingDataset.AsByteSpan().size()); + datasetTlvs.mLength = pendingDataset.AsByteSpan().size(); + ReturnErrorCodeIf(otDatasetSetPendingTlvs(esp_openthread_get_instance(), &datasetTlvs) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + return CHIP_NO_ERROR; +} + +void ESP32ThreadBorderRouterDelegate::OnTopologyRequestCompleted(chip::System::Layer * systemLayer, void * appState) +{ + ESP32ThreadBorderRouterDelegate * delegate = (ESP32ThreadBorderRouterDelegate *) appState; + if (delegate) + { + // Finish the topology request + delegate->mCurrentSnapshot++; + if (delegate->mCurrentSnapshot == 0) + { + delegate->mCurrentSnapshot = 1; + } + auto topology = Span(delegate->mThreadNodesBuffer, delegate->mThreadNodesCount); + delegate->mCallback->OnTopologyRequestFinished(Status::Success, delegate->mCurrentSnapshot, topology); + } +} + +void ESP32ThreadBorderRouterDelegate::DiagnosticReceiveHandler(otError error, otMessage * message, + const otMessageInfo * messageInfo, void * context) +{ + ESP32ThreadBorderRouterDelegate * delegate = (ESP32ThreadBorderRouterDelegate *) context; + // This should never happen + VerifyOrDie(delegate); + if (error != OT_ERROR_NONE) + { + DeviceLayer::SystemLayer().ScheduleLambda( + [delegate]() { delegate->mCallback->OnTopologyRequestFinished(Status::Failure, 0, Span()); }); + // Some error when requesting topology + return; + } + if (delegate->mThreadNodesCount >= kMaxThreadNodesCount) + { + DeviceLayer::SystemLayer().ScheduleLambda( + [delegate]() { delegate->mCallback->OnTopologyRequestFinished(Status::ResourceExhausted, 0, Span()); }); + return; + } + DeviceLayer::PlatformMgr().LockChipStack(); + // ExtendTimer when receiving a diagnostic message + DeviceLayer::SystemLayer().ExtendTimerTo(System::Clock::Milliseconds32(1000), OnTopologyRequestCompleted, delegate); + DeviceLayer::PlatformMgr().UnlockChipStack(); + otNetworkDiagIterator iterator = OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT; + otNetworkDiagTlv diagTlv; + otLinkModeConfig linkMode = { + .mRxOnWhenIdle = false, + .mDeviceType = false, + .mNetworkData = false, + }; + bool linkModeGet = false, rloc16Get = false, isLeader = false; + auto & currentThreadNode = delegate->mThreadNodesBuffer[delegate->mThreadNodesCount]; + ClearThreadNode(currentThreadNode); + while ((error = otThreadGetNextDiagnosticTlv(message, &iterator, &diagTlv)) == OT_ERROR_NONE) + { + switch (diagTlv.mType) + { + case OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS: + memcpy(&(currentThreadNode.extAddress), diagTlv.mData.mExtAddress.m8, sizeof(uint64_t)); + break; + case OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS: + currentThreadNode.rloc16 = diagTlv.mData.mAddr16; + rloc16Get = true; + break; + case OT_NETWORK_DIAGNOSTIC_TLV_MODE: + linkMode = diagTlv.mData.mMode; + linkModeGet = true; + break; + case OT_NETWORK_DIAGNOSTIC_TLV_ROUTE: { + if (diagTlv.mData.mRoute.mRouteCount == 0) + { + DeviceLayer::SystemLayer().ScheduleLambda( + [delegate]() { delegate->mCallback->OnTopologyRequestFinished(Status::Failure, 0, Span()); }); + return; + } + currentThreadNode.Routes.Alloc(diagTlv.mData.mRoute.mRouteCount); + if (!currentThreadNode.Routes.Get()) + { + DeviceLayer::SystemLayer().ScheduleLambda([delegate]() { + delegate->mCallback->OnTopologyRequestFinished(Status::ResourceExhausted, 0, Span()); + }); + return; + } + for (size_t routeIndex = 0; routeIndex < diagTlv.mData.mRoute.mRouteCount; ++routeIndex) + { + currentThreadNode.Routes[routeIndex].routerId = diagTlv.mData.mRoute.mRouteData[routeIndex].mRouterId; + currentThreadNode.Routes[routeIndex].pathCost = diagTlv.mData.mRoute.mRouteData[routeIndex].mRouteCost; + currentThreadNode.Routes[routeIndex].LQIIn = diagTlv.mData.mRoute.mRouteData[routeIndex].mLinkQualityIn; + currentThreadNode.Routes[routeIndex].LQIOut = diagTlv.mData.mRoute.mRouteData[routeIndex].mLinkQualityOut; + if (currentThreadNode.Routes[routeIndex].routerId == delegate->mLeaderRouterId && + currentThreadNode.Routes[routeIndex].LQIIn == 0 && currentThreadNode.Routes[routeIndex].LQIOut == 0) + { + isLeader = true; + } + } + Span routeTableSpan = + Span(currentThreadNode.Routes.Get(), diagTlv.mData.mRoute.mRouteCount); + currentThreadNode.routeTable = DataModel::List(routeTableSpan); + break; + } + case OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST: { + if (diagTlv.mData.mIp6AddrList.mCount == 0) + { + DeviceLayer::SystemLayer().ScheduleLambda( + [delegate]() { delegate->mCallback->OnTopologyRequestFinished(Status::Failure, 0, Span()); }); + return; + } + currentThreadNode.Ipv6Addresses.Alloc(diagTlv.mData.mIp6AddrList.mCount); + currentThreadNode.Ipv6AddressesSpans.Alloc(diagTlv.mData.mIp6AddrList.mCount); + if ((!currentThreadNode.Ipv6Addresses.Get()) || (!currentThreadNode.Ipv6AddressesSpans.Get())) + { + DeviceLayer::SystemLayer().ScheduleLambda([delegate]() { + delegate->mCallback->OnTopologyRequestFinished(Status::ResourceExhausted, 0, Span()); + }); + return; + } + for (size_t ipAddrIndex = 0; ipAddrIndex < diagTlv.mData.mIp6AddrList.mCount; ++ipAddrIndex) + { + memcpy(currentThreadNode.Ipv6Addresses[ipAddrIndex].Addr, diagTlv.mData.mIp6AddrList.mList[ipAddrIndex].mFields.m8, + OT_IP6_ADDRESS_SIZE); + currentThreadNode.Ipv6AddressesSpans[ipAddrIndex] = + ByteSpan((uint8_t *) currentThreadNode.Ipv6Addresses[ipAddrIndex].Addr, + sizeof(currentThreadNode.Ipv6Addresses[ipAddrIndex].Addr)); + } + currentThreadNode.IPv6s = + DataModel::List(currentThreadNode.Ipv6AddressesSpans.Get(), diagTlv.mData.mIp6AddrList.mCount); + break; + } + case OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE: + if (diagTlv.mData.mChildTable.mCount > 0) + { + currentThreadNode.Children.Alloc(diagTlv.mData.mChildTable.mCount); + if (!currentThreadNode.Children.Get()) + { + DeviceLayer::SystemLayer().ScheduleLambda( + [delegate]() { delegate->mCallback->OnTopologyRequestFinished(Status::Failure, 0, Span()); }); + return; + } + for (size_t childIndex = 0; childIndex < diagTlv.mData.mChildTable.mCount; ++childIndex) + { + currentThreadNode.Children[childIndex].linkQuality = diagTlv.mData.mChildTable.mTable[childIndex].mLinkQuality; + currentThreadNode.Children[childIndex].rloc16 = diagTlv.mData.mChildTable.mTable[childIndex].mChildId; + currentThreadNode.Children[childIndex].routingRole = + MapRoutingRole(OT_DEVICE_ROLE_CHILD, diagTlv.mData.mChildTable.mTable[childIndex].mMode.mDeviceType, + diagTlv.mData.mChildTable.mTable[childIndex].mMode.mRxOnWhenIdle); + } + currentThreadNode.childTable = + DataModel::List(currentThreadNode.Children.Get(), diagTlv.mData.mChildTable.mCount); + } + break; + default: + break; + } + } + if (linkModeGet && rloc16Get && currentThreadNode.routeTable.size() > 0) + { + if ((currentThreadNode.rloc16 & 0x00FF) == 0) + { + currentThreadNode.routingRole = isLeader ? RoutingRoleEnum::kLeader : RoutingRoleEnum::kRouter; + } + else + { + currentThreadNode.routingRole = MapRoutingRole(OT_DEVICE_ROLE_CHILD, linkMode.mDeviceType, linkMode.mRxOnWhenIdle); + } + } + if (rloc16Get && currentThreadNode.childTable.size() > 0) + { + for (size_t i = 0; i < currentThreadNode.childTable.size(); ++i) + { + currentThreadNode.Children[i].rloc16 |= (currentThreadNode.rloc16 & 0xFF00); + } + } + delegate->mThreadNodesCount++; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetTopology(uint8_t snapshot, Callback * callback) +{ + if (!callback) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + if (snapshot != 0) + { + if (snapshot != mCurrentSnapshot) + { + return CHIP_ERROR_NOT_FOUND; + } + auto topology = Span(mThreadNodesBuffer, mThreadNodesCount); + callback->OnTopologyRequestFinished(Status::Success, snapshot, topology); + return CHIP_NO_ERROR; + } + // snapshot is zero, we need to create a new snapshot. + mThreadNodesCount = 0; + mCallback = callback; + ScopedThreadLock threadLock; + otIp6Address multicastAddress; + // Get Leader RouterId to distinguish Router and Leader in DiagnosticReceiveHandler + otLeaderData leaderdata; + ReturnErrorCodeIf(otThreadGetLeaderData(esp_openthread_get_instance(), &leaderdata) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + mLeaderRouterId = leaderdata.mLeaderRouterId; + // Send DiagnosticGet message to all the Routers to create a topology snapshot + ReturnErrorCodeIf(otIp6AddressFromString(kMulticastAddrAllRouters, &multicastAddress) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + ReturnErrorCodeIf(otThreadSendDiagnosticGet(esp_openthread_get_instance(), &multicastAddress, kDiagTLVTypes, + sizeof(kDiagTLVTypes), DiagnosticReceiveHandler, this) != OT_ERROR_NONE, + CHIP_ERROR_INTERNAL); + // If the BR doesn't receive diagnostic message in 1 seconds, we consider that the topology request is done + DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(1000), OnTopologyRequestCompleted, this); + return CHIP_NO_ERROR; +} + +// These function should be called when Thread stack is locked +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetExtAddress(uint64_t & extAddr) +{ + otInstance * otInst = esp_openthread_get_instance(); + const otExtAddress * extAddress = otLinkGetExtendedAddress(otInst); + memcpy(&extAddr, extAddress->m8, sizeof(extAddress->m8)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetRolc16(uint16_t & rloc16) +{ + rloc16 = otThreadGetRloc16(esp_openthread_get_instance()); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetRoutingRole(RoutingRoleEnum & routingRole) +{ + otInstance * otInst = esp_openthread_get_instance(); + otDeviceRole role = otThreadGetDeviceRole(otInst); + otLinkModeConfig linkModeConfig = otThreadGetLinkMode(otInst); + routingRole = MapRoutingRole(role, linkModeConfig.mDeviceType, linkModeConfig.mRxOnWhenIdle); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetIpv6s(Span & ipv6Addrs) +{ + otInstance * otInst = esp_openthread_get_instance(); + const otNetifAddress * netifAddrs = otIp6GetUnicastAddresses(otInst); + size_t addrIndex = 0; + for (const otNetifAddress * addr = netifAddrs; addr; addr = addr->mNext) + { + if (addrIndex >= ipv6Addrs.size()) + { + return CHIP_ERROR_NO_MEMORY; + } + memcpy(ipv6Addrs[addrIndex].Addr, addr->mAddress.mFields.m8, OT_IP6_ADDRESS_SIZE); + addrIndex++; + } + ipv6Addrs.reduce_size(addrIndex); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetRouteTable(Span & routeTableSpan) +{ + otInstance * otInst = esp_openthread_get_instance(); + uint8_t maxRouterId; + otRouterInfo routerInfo; + maxRouterId = otThreadGetMaxRouterId(otInst); + uint8_t routeTableIndex = 0; + for (uint8_t i = 0; i < maxRouterId && routeTableIndex < routeTableSpan.size(); ++i) + { + if (otThreadGetRouterInfo(otInst, i, &routerInfo) == OT_ERROR_NONE) + { + routeTableSpan[routeTableIndex].LQIIn = routerInfo.mLinkQualityIn; + routeTableSpan[routeTableIndex].LQIOut = routerInfo.mLinkQualityOut; + routeTableSpan[routeTableIndex].routerId = routerInfo.mRouterId; + routeTableSpan[routeTableIndex].pathCost = routerInfo.mPathCost; + routeTableIndex++; + } + } + routeTableSpan.reduce_size(routeTableIndex); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::GetChildTable(Span & childTable) +{ + otInstance * otInst = esp_openthread_get_instance(); + uint16_t maxChildren = otThreadGetMaxAllowedChildren(otInst); + uint16_t childTableIndex = 0; + otChildInfo childInfo; + for (uint8_t i = 0; i < maxChildren && childTableIndex < childTable.size(); ++i) + { + if (otThreadGetChildInfoByIndex(otInst, i, &childInfo) == OT_ERROR_NONE) + { + childTable[childTableIndex].rloc16 = childInfo.mRloc16; + childTable[childTableIndex].linkQuality = childInfo.mLinkQualityIn; + childTable[childTableIndex].routingRole = + MapRoutingRole(OT_DEVICE_ROLE_CHILD, childInfo.mFullThreadDevice, childInfo.mRxOnWhenIdle); + childTableIndex++; + } + } + childTable.reduce_size(childTableIndex); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ESP32ThreadBorderRouterDelegate::SetThreadEnabled(bool enabled) +{ + otInstance * instance = esp_openthread_get_instance(); + bool isEnabled = (otThreadGetDeviceRole(instance) != OT_DEVICE_ROLE_DISABLED); + bool isIp6Enabled = otIp6IsEnabled(instance); + if (enabled && !isIp6Enabled) + { + ReturnErrorCodeIf(otIp6SetEnabled(instance, enabled) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + } + if (enabled != isEnabled) + { + ReturnErrorCodeIf(otThreadSetEnabled(instance, enabled) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + } + if (!enabled && isIp6Enabled) + { + ReturnErrorCodeIf(otIp6SetEnabled(instance, enabled) != OT_ERROR_NONE, CHIP_ERROR_INTERNAL); + } + return CHIP_NO_ERROR; +} + +} // namespace ThreadBorderRouterManagement +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/examples/thread-br-app/esp32/main/Kconfig.projbuild b/examples/thread-br-app/esp32/main/Kconfig.projbuild new file mode 100644 index 00000000000000..7f65d083795e42 --- /dev/null +++ b/examples/thread-br-app/esp32/main/Kconfig.projbuild @@ -0,0 +1,45 @@ +# +# Copyright (c) 2022 Project CHIP Authors +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Description: +# Configuration options CHIP ESP32 demo application. +# + +menu "Demo" + choice + prompt "Rendezvous Mode" + default RENDEZVOUS_MODE_BLE + help + Specifies the Rendezvous mode of the peripheral. + + config RENDEZVOUS_MODE_WIFI + bool "Wi-Fi" + config RENDEZVOUS_MODE_BLE + bool "BLE" + config RENDEZVOUS_MODE_THREAD + bool "Thread" + config RENDEZVOUS_MODE_ETHERNET + bool "Ethernet" + endchoice + + config RENDEZVOUS_MODE + int + range 0 8 + default 1 if RENDEZVOUS_MODE_WIFI + default 2 if RENDEZVOUS_MODE_BLE + default 4 if RENDEZVOUS_MODE_THREAD + default 8 if RENDEZVOUS_MODE_ETHERNET +endmenu diff --git a/examples/thread-br-app/esp32/main/include/DeviceCallbacks.h b/examples/thread-br-app/esp32/main/include/DeviceCallbacks.h new file mode 100644 index 00000000000000..1507e284e0d5f5 --- /dev/null +++ b/examples/thread-br-app/esp32/main/include/DeviceCallbacks.h @@ -0,0 +1,45 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file DeviceCallbacks.h + * + * Implementations for the DeviceManager callbacks for this application + * + **/ + +#pragma once + +#include +#include + +class AppDeviceCallbacks : public CommonDeviceCallbacks +{ +public: + virtual void PostAttributeChangeCallback(chip::EndpointId endpointId, chip::ClusterId clusterId, chip::AttributeId attributeId, + uint8_t type, uint16_t size, uint8_t * value); +}; + +class AppDeviceCallbacksDelegate : public DeviceCallbacksDelegate +{ +public: + void OnIPv4ConnectivityEstablished(void) override {} + void OnIPv4ConnectivityLost(void) override {} + void OnIPv6ConnectivityEstablished(void) override; + void OnDnssdInitialized(void) override {} +}; diff --git a/examples/thread-br-app/esp32/main/include/ESP32ThreadBorderRouterDelegate.h b/examples/thread-br-app/esp32/main/include/ESP32ThreadBorderRouterDelegate.h new file mode 100644 index 00000000000000..f49cfc7d38b4b6 --- /dev/null +++ b/examples/thread-br-app/esp32/main/include/ESP32ThreadBorderRouterDelegate.h @@ -0,0 +1,111 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include + +using chip::MutableByteSpan; +using chip::MutableCharSpan; +using chip::Span; + +namespace chip { +namespace app { +namespace Clusters { + +namespace ThreadBorderRouterManagement { + +class ESP32ThreadBorderRouterDelegate : public Delegate +{ +public: + static constexpr char kThreadBorderRourterName[] = "Espressif-ThreadBR"; + static constexpr uint8_t kOpenThreadMaxRouterId = OT_NETWORK_MAX_ROUTER_ID; + static constexpr uint8_t kOpenThreadMaxChildCount = 10; + static constexpr uint8_t kOpenThreadMaxIPv6AddressCount = 8; + static constexpr uint8_t kMaxThreadNodesCount = 64; + static constexpr char kMulticastAddrAllRouters[] = "ff03::2"; + static constexpr uint8_t kDiagTLVTypes[] = { OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS, OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS, + OT_NETWORK_DIAGNOSTIC_TLV_MODE, OT_NETWORK_DIAGNOSTIC_TLV_ROUTE, + OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST, OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE }; + + ESP32ThreadBorderRouterDelegate() = default; + ~ESP32ThreadBorderRouterDelegate() = default; + + CHIP_ERROR Init() override { return CHIP_NO_ERROR; } + + CHIP_ERROR GetPanChangeSupported(bool & panChangeSupported) override + { + panChangeSupported = true; + return CHIP_NO_ERROR; + } + + CHIP_ERROR GetBorderRouterName(MutableCharSpan & borderRouterName) override + { + if (borderRouterName.size() < strlen(kThreadBorderRourterName)) + { + return CHIP_ERROR_NO_MEMORY; + } + strcpy(borderRouterName.data(), kThreadBorderRourterName); + borderRouterName.reduce_size(strlen(kThreadBorderRourterName)); + return CHIP_NO_ERROR; + } + + CHIP_ERROR GetBorderAgentId(MutableByteSpan & borderAgentId) override; + + CHIP_ERROR GetThreadVersion(uint16_t & threadVersion) override; + + CHIP_ERROR GetInterfaceEnabled(bool & interfaceEnabled) override; + + CHIP_ERROR GetThreadNode(ThreadNode & threadNode) override; + + CHIP_ERROR GetActiveDataset(chip::Thread::OperationalDataset & activeDataset) override; + + CHIP_ERROR GetPendingDataset(chip::Thread::OperationalDataset & pendingDataset) override; + + CHIP_ERROR SetActiveDataset(const chip::Thread::OperationalDataset & activeDataset) override; + + CHIP_ERROR SetPendingDataset(const chip::Thread::OperationalDataset & pendingDataset) override; + + CHIP_ERROR GetTopology(uint8_t snapshot, Callback * callback) override; + +private: + CHIP_ERROR GetExtAddress(uint64_t & extAddr); + CHIP_ERROR GetRolc16(uint16_t & rloc16); + CHIP_ERROR GetRoutingRole(RoutingRoleEnum & routingRole); + CHIP_ERROR GetIpv6s(Span & ipv6Addrs); + CHIP_ERROR GetRouteTable(Span & routeTable); + CHIP_ERROR GetChildTable(Span & childTable); + CHIP_ERROR SetThreadEnabled(bool enabled); + + static void DiagnosticReceiveHandler(otError error, otMessage * message, const otMessageInfo * messageInfo, void * aContext); + static void OnTopologyRequestCompleted(chip::System::Layer * systemLayer, void * appState); + + uint8_t mCurrentSnapshot; + size_t mThreadNodesCount = 0; + ThreadNode mThreadNodesBuffer[kMaxThreadNodesCount]; + Callback * mCallback = nullptr; + uint8_t mLeaderRouterId = 0; +}; +} // namespace ThreadBorderRouterManagement +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/examples/thread-br-app/esp32/main/main.cpp b/examples/thread-br-app/esp32/main/main.cpp new file mode 100644 index 00000000000000..12d0f35c8c6ddb --- /dev/null +++ b/examples/thread-br-app/esp32/main/main.cpp @@ -0,0 +1,152 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "DeviceCallbacks.h" +#include "ESP32ThreadBorderRouterDelegate.h" + +#include +#include +#include +#include + +#include "esp_log.h" +#include "esp_netif.h" +#include "esp_openthread_border_router.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "nvs_flash.h" +#include "shell_extension/launch.h" + +#include +#include +#include +#include +#include + +#if CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER +#include +#endif // CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER + +#if CONFIG_ENABLE_ESP32_DEVICE_INFO_PROVIDER +#include +#else +#include +#endif // CONFIG_ENABLE_ESP32_DEVICE_INFO_PROVIDER + +using namespace ::chip; +using namespace ::chip::Credentials; +using namespace ::chip::DeviceManager; +using namespace ::chip::DeviceLayer; +using namespace ::chip::app::Clusters; + +namespace { +#if CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER +DeviceLayer::ESP32FactoryDataProvider sFactoryDataProvider; +#endif // CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER + +#if CONFIG_ENABLE_ESP32_DEVICE_INFO_PROVIDER +DeviceLayer::ESP32DeviceInfoProvider gExampleDeviceInfoProvider; +#else +DeviceLayer::DeviceInfoProviderImpl gExampleDeviceInfoProvider; +#endif // CONFIG_ENABLE_ESP32_DEVICE_INFO_PROVIDER +} // namespace + +static const char TAG[] = "thread-br-app"; + +static AppDeviceCallbacks EchoCallbacks; +static AppDeviceCallbacksDelegate sAppDeviceCallbacksDelegate; + +static void InitServer(intptr_t context) +{ + // Print QR Code URL + PrintOnboardingCodes(chip::RendezvousInformationFlags(CONFIG_RENDEZVOUS_MODE)); + + Esp32AppServer::Init(); // Init ZCL Data Model and CHIP App Server AND Initialize device attestation config +} + +static constexpr EndpointId kThreadBRMgmtEndpoint = 1; + +static ThreadBorderRouterManagement::ESP32ThreadBorderRouterDelegate sThreadBRDelegate; +static ThreadBorderRouterManagement::ServerInstance sThreadBRMgmtInstance(kThreadBRMgmtEndpoint, &sThreadBRDelegate); + +extern "C" void app_main() +{ + // Initialize the ESP NVS layer. + esp_err_t err = nvs_flash_init(); + if (err != ESP_OK) + { + ESP_LOGE(TAG, "nvs_flash_init() failed: %s", esp_err_to_name(err)); + return; + } + err = esp_event_loop_create_default(); + if (err != ESP_OK) + { + ESP_LOGE(TAG, "esp_event_loop_create_default() failed: %s", esp_err_to_name(err)); + return; + } + + ESP_LOGI(TAG, "=================================================="); + ESP_LOGI(TAG, "chip-esp32-thread-br-example starting"); + ESP_LOGI(TAG, "=================================================="); + +#if CHIP_DEVICE_CONFIG_ENABLE_WIFI + if (DeviceLayer::Internal::ESP32Utils::InitWiFiStack() != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "Failed to initialize the Wi-Fi stack"); + return; + } +#endif + +#if CONFIG_ENABLE_CHIP_SHELL +#if CONFIG_OPENTHREAD_CLI + chip::RegisterOpenThreadCliCommands(); +#endif + chip::LaunchShell(); +#endif // CONFIG_ENABLE_CHIP_SHELL + + DeviceLayer::SetDeviceInfoProvider(&gExampleDeviceInfoProvider); + + CHIPDeviceManager & deviceMgr = CHIPDeviceManager::GetInstance(); + CHIP_ERROR error = deviceMgr.Init(&EchoCallbacks); + DeviceCallbacksDelegate::Instance().SetAppDelegate(&sAppDeviceCallbacksDelegate); + if (error != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "device.Init() failed: %" CHIP_ERROR_FORMAT, error.Format()); + return; + } + +#if CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER + SetCommissionableDataProvider(&sFactoryDataProvider); + SetDeviceAttestationCredentialsProvider(&sFactoryDataProvider); +#if CONFIG_ENABLE_ESP32_DEVICE_INSTANCE_INFO_PROVIDER + SetDeviceInstanceInfoProvider(&sFactoryDataProvider); +#endif +#else + SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider()); +#endif // CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER + esp_openthread_set_backbone_netif(esp_netif_get_handle_from_ifkey("WIFI_STA_DEF")); + ESPOpenThreadInit(); + + chip::DeviceLayer::PlatformMgr().ScheduleWork(InitServer, reinterpret_cast(nullptr)); + sThreadBRMgmtInstance.Init(); +} + +extern "C" void otSysProcessDrivers(otInstance *aInstance) +{ + (void)aInstance; +} diff --git a/examples/thread-br-app/esp32/partitions.csv b/examples/thread-br-app/esp32/partitions.csv new file mode 100644 index 00000000000000..46c93555d6a4cf --- /dev/null +++ b/examples/thread-br-app/esp32/partitions.csv @@ -0,0 +1,7 @@ +# Name, Type, SubType, Offset, Size, Flags +# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap +nvs, data, nvs, , 0xC000, +otadata, data, ota, , 0x2000, +phy_init, data, phy, , 0x1000, +ota_0, app, ota_0, , 1800K, +ota_1, app, ota_1, , 1800K, diff --git a/examples/thread-br-app/esp32/sdkconfig.defaults b/examples/thread-br-app/esp32/sdkconfig.defaults new file mode 100644 index 00000000000000..1e3b6fb3ce0d51 --- /dev/null +++ b/examples/thread-br-app/esp32/sdkconfig.defaults @@ -0,0 +1,73 @@ +# +# Copyright (c) 2024 Project CHIP Authors +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Description: +# Some useful defaults for the demo app configuration. +# + +# Flash size and partition table +CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y +CONFIG_PARTITION_TABLE_CUSTOM=y + +# BLE +CONFIG_BT_ENABLED=y +CONFIG_BT_NIMBLE_ENABLED=y +CONFIG_BT_NIMBLE_ENABLE_CONN_REATTEMPT=n + +# Increase some stack size +CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=7200 +CONFIG_ESP_MAIN_TASK_STACK_SIZE=5120 +CONFIG_ESP_TIMER_TASK_STACK_SIZE=5120 + +# USB console for Thread border board +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y + +# Disable SoftAP +CONFIG_ESP_WIFI_SOFTAP_SUPPORT=n + +# LWIP +CONFIG_LWIP_IPV6_FORWARD=y +CONFIG_LWIP_IPV6_AUTOCONFIG=y +CONFIG_LWIP_IPV6_NUM_ADDRESSES=6 +CONFIG_LWIP_MULTICAST_PING=y +CONFIG_LWIP_NETIF_STATUS_CALLBACK=y +CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT=y +CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT=y +CONFIG_LWIP_HOOK_IP6_INPUT_CUSTOM=y +CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM=y + +# ESP Border Router will also enable a route hook so we don't need the route hook in matter +CONFIG_ENABLE_ROUTE_HOOK=n + +# mbedTLS +CONFIG_MBEDTLS_KEY_EXCHANGE_ECJPAKE=y +CONFIG_MBEDTLS_SSL_PROTO_DTLS=y +CONFIG_MBEDTLS_ECJPAKE_C=y +CONFIG_MBEDTLS_HKDF_C=y + +# OpenThread +CONFIG_OPENTHREAD_ENABLED=y +CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC=n +CONFIG_OPENTHREAD_LOG_LEVEL_NOTE=y +CONFIG_OPENTHREAD_SRP_CLIENT=n +CONFIG_OPENTHREAD_DNS_CLIENT=n +CONFIG_OPENTHREAD_BORDER_ROUTER=y + +# Use platform mDNS +CONFIG_USE_MINIMAL_MDNS=n + +# Enable Matter shell +CONFIG_ENABLE_CHIP_SHELL=y diff --git a/examples/thread-br-app/esp32/third_party/connectedhomeip b/examples/thread-br-app/esp32/third_party/connectedhomeip new file mode 120000 index 00000000000000..11a54ed360106c --- /dev/null +++ b/examples/thread-br-app/esp32/third_party/connectedhomeip @@ -0,0 +1 @@ +../../../../ \ No newline at end of file diff --git a/examples/thread-br-app/thread-br-common/thread-br-app.matter b/examples/thread-br-app/thread-br-common/thread-br-app.matter new file mode 100644 index 00000000000000..9fc5a12a8397b5 --- /dev/null +++ b/examples/thread-br-app/thread-br-common/thread-br-app.matter @@ -0,0 +1,1546 @@ +// This IDL was generated automatically by ZAP. +// It is for view/code review purposes only. + +/** The Descriptor Cluster is meant to replace the support from the Zigbee Device Object (ZDO) for describing a node, its endpoints and clusters. */ +cluster Descriptor = 29 { + revision 2; + + bitmap Feature : bitmap32 { + kTagList = 0x1; + } + + struct DeviceTypeStruct { + devtype_id deviceType = 0; + int16u revision = 1; + } + + struct SemanticTagStruct { + nullable vendor_id mfgCode = 0; + enum8 namespaceID = 1; + enum8 tag = 2; + optional nullable char_string label = 3; + } + + readonly attribute DeviceTypeStruct deviceTypeList[] = 0; + readonly attribute cluster_id serverList[] = 1; + readonly attribute cluster_id clientList[] = 2; + readonly attribute endpoint_no partsList[] = 3; + readonly attribute optional SemanticTagStruct tagList[] = 4; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** The Access Control Cluster exposes a data model view of a + Node's Access Control List (ACL), which codifies the rules used to manage + and enforce Access Control for the Node's endpoints and their associated + cluster instances. */ +cluster AccessControl = 31 { + revision 1; // NOTE: Default/not specifically set + + enum AccessControlEntryAuthModeEnum : enum8 { + kPASE = 1; + kCASE = 2; + kGroup = 3; + } + + enum AccessControlEntryPrivilegeEnum : enum8 { + kView = 1; + kProxyView = 2; + kOperate = 3; + kManage = 4; + kAdminister = 5; + } + + enum ChangeTypeEnum : enum8 { + kChanged = 0; + kAdded = 1; + kRemoved = 2; + } + + struct AccessControlTargetStruct { + nullable cluster_id cluster = 0; + nullable endpoint_no endpoint = 1; + nullable devtype_id deviceType = 2; + } + + fabric_scoped struct AccessControlEntryStruct { + fabric_sensitive AccessControlEntryPrivilegeEnum privilege = 1; + fabric_sensitive AccessControlEntryAuthModeEnum authMode = 2; + nullable fabric_sensitive int64u subjects[] = 3; + nullable fabric_sensitive AccessControlTargetStruct targets[] = 4; + fabric_idx fabricIndex = 254; + } + + fabric_scoped struct AccessControlExtensionStruct { + fabric_sensitive octet_string<128> data = 1; + fabric_idx fabricIndex = 254; + } + + fabric_sensitive info event access(read: administer) AccessControlEntryChanged = 0 { + nullable node_id adminNodeID = 1; + nullable int16u adminPasscodeID = 2; + ChangeTypeEnum changeType = 3; + nullable AccessControlEntryStruct latestValue = 4; + fabric_idx fabricIndex = 254; + } + + fabric_sensitive info event access(read: administer) AccessControlExtensionChanged = 1 { + nullable node_id adminNodeID = 1; + nullable int16u adminPasscodeID = 2; + ChangeTypeEnum changeType = 3; + nullable AccessControlExtensionStruct latestValue = 4; + fabric_idx fabricIndex = 254; + } + + attribute access(read: administer, write: administer) AccessControlEntryStruct acl[] = 0; + attribute access(read: administer, write: administer) optional AccessControlExtensionStruct extension[] = 1; + readonly attribute int16u subjectsPerAccessControlEntry = 2; + readonly attribute int16u targetsPerAccessControlEntry = 3; + readonly attribute int16u accessControlEntriesPerFabric = 4; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** The Access Control Cluster exposes a data model view of a + Node's Access Control List (ACL), which codifies the rules used to manage + and enforce Access Control for the Node's endpoints and their associated + cluster instances. */ +cluster AccessControl = 31 { + revision 1; // NOTE: Default/not specifically set + + enum AccessControlEntryAuthModeEnum : enum8 { + kPASE = 1; + kCASE = 2; + kGroup = 3; + } + + enum AccessControlEntryPrivilegeEnum : enum8 { + kView = 1; + kProxyView = 2; + kOperate = 3; + kManage = 4; + kAdminister = 5; + } + + enum ChangeTypeEnum : enum8 { + kChanged = 0; + kAdded = 1; + kRemoved = 2; + } + + struct AccessControlTargetStruct { + nullable cluster_id cluster = 0; + nullable endpoint_no endpoint = 1; + nullable devtype_id deviceType = 2; + } + + fabric_scoped struct AccessControlEntryStruct { + fabric_sensitive AccessControlEntryPrivilegeEnum privilege = 1; + fabric_sensitive AccessControlEntryAuthModeEnum authMode = 2; + nullable fabric_sensitive int64u subjects[] = 3; + nullable fabric_sensitive AccessControlTargetStruct targets[] = 4; + fabric_idx fabricIndex = 254; + } + + fabric_scoped struct AccessControlExtensionStruct { + fabric_sensitive octet_string<128> data = 1; + fabric_idx fabricIndex = 254; + } + + fabric_sensitive info event access(read: administer) AccessControlEntryChanged = 0 { + nullable node_id adminNodeID = 1; + nullable int16u adminPasscodeID = 2; + ChangeTypeEnum changeType = 3; + nullable AccessControlEntryStruct latestValue = 4; + fabric_idx fabricIndex = 254; + } + + fabric_sensitive info event access(read: administer) AccessControlExtensionChanged = 1 { + nullable node_id adminNodeID = 1; + nullable int16u adminPasscodeID = 2; + ChangeTypeEnum changeType = 3; + nullable AccessControlExtensionStruct latestValue = 4; + fabric_idx fabricIndex = 254; + } + + attribute access(read: administer, write: administer) AccessControlEntryStruct acl[] = 0; + attribute access(read: administer, write: administer) optional AccessControlExtensionStruct extension[] = 1; + readonly attribute int16u subjectsPerAccessControlEntry = 2; + readonly attribute int16u targetsPerAccessControlEntry = 3; + readonly attribute int16u accessControlEntriesPerFabric = 4; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** This cluster provides attributes and events for determining basic information about Nodes, which supports both + Commissioning and operational determination of Node characteristics, such as Vendor ID, Product ID and serial number, + which apply to the whole Node. Also allows setting user device information such as location. */ +cluster BasicInformation = 40 { + revision 3; + + enum ColorEnum : enum8 { + kBlack = 0; + kNavy = 1; + kGreen = 2; + kTeal = 3; + kMaroon = 4; + kPurple = 5; + kOlive = 6; + kGray = 7; + kBlue = 8; + kLime = 9; + kAqua = 10; + kRed = 11; + kFuchsia = 12; + kYellow = 13; + kWhite = 14; + kNickel = 15; + kChrome = 16; + kBrass = 17; + kCopper = 18; + kSilver = 19; + kGold = 20; + } + + enum ProductFinishEnum : enum8 { + kOther = 0; + kMatte = 1; + kSatin = 2; + kPolished = 3; + kRugged = 4; + kFabric = 5; + } + + struct CapabilityMinimaStruct { + int16u caseSessionsPerFabric = 0; + int16u subscriptionsPerFabric = 1; + } + + struct ProductAppearanceStruct { + ProductFinishEnum finish = 0; + nullable ColorEnum primaryColor = 1; + } + + critical event StartUp = 0 { + int32u softwareVersion = 0; + } + + critical event ShutDown = 1 { + } + + info event Leave = 2 { + fabric_idx fabricIndex = 0; + } + + info event ReachableChanged = 3 { + boolean reachableNewValue = 0; + } + + readonly attribute int16u dataModelRevision = 0; + readonly attribute char_string<32> vendorName = 1; + readonly attribute vendor_id vendorID = 2; + readonly attribute char_string<32> productName = 3; + readonly attribute int16u productID = 4; + attribute access(write: manage) char_string<32> nodeLabel = 5; + attribute access(write: administer) char_string<2> location = 6; + readonly attribute int16u hardwareVersion = 7; + readonly attribute char_string<64> hardwareVersionString = 8; + readonly attribute int32u softwareVersion = 9; + readonly attribute char_string<64> softwareVersionString = 10; + readonly attribute optional char_string<16> manufacturingDate = 11; + readonly attribute optional char_string<32> partNumber = 12; + readonly attribute optional long_char_string<256> productURL = 13; + readonly attribute optional char_string<64> productLabel = 14; + readonly attribute optional char_string<32> serialNumber = 15; + attribute access(write: manage) optional boolean localConfigDisabled = 16; + readonly attribute optional boolean reachable = 17; + readonly attribute optional char_string<32> uniqueID = 18; + readonly attribute CapabilityMinimaStruct capabilityMinima = 19; + readonly attribute optional ProductAppearanceStruct productAppearance = 20; + readonly attribute int32u specificationVersion = 21; + readonly attribute int16u maxPathsPerInvoke = 22; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + command MfgSpecificPing(): DefaultSuccess = 0; +} + +/** Nodes should be expected to be deployed to any and all regions of the world. These global regions + may have differing common languages, units of measurements, and numerical formatting + standards. As such, Nodes that visually or audibly convey information need a mechanism by which + they can be configured to use a user’s preferred language, units, etc */ +cluster LocalizationConfiguration = 43 { + revision 1; // NOTE: Default/not specifically set + + attribute access(write: manage) char_string<35> activeLocale = 0; + readonly attribute char_string supportedLocales[] = 1; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** Nodes should be expected to be deployed to any and all regions of the world. These global regions + may have differing preferences for how dates and times are conveyed. As such, Nodes that visually + or audibly convey time information need a mechanism by which they can be configured to use a + user’s preferred format. */ +cluster TimeFormatLocalization = 44 { + revision 1; // NOTE: Default/not specifically set + + enum CalendarTypeEnum : enum8 { + kBuddhist = 0; + kChinese = 1; + kCoptic = 2; + kEthiopian = 3; + kGregorian = 4; + kHebrew = 5; + kIndian = 6; + kIslamic = 7; + kJapanese = 8; + kKorean = 9; + kPersian = 10; + kTaiwanese = 11; + kUseActiveLocale = 255; + } + + enum HourFormatEnum : enum8 { + k12hr = 0; + k24hr = 1; + kUseActiveLocale = 255; + } + + bitmap Feature : bitmap32 { + kCalendarFormat = 0x1; + } + + attribute access(write: manage) HourFormatEnum hourFormat = 0; + attribute access(write: manage) optional CalendarTypeEnum activeCalendarType = 1; + readonly attribute optional CalendarTypeEnum supportedCalendarTypes[] = 2; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** This cluster is used to manage global aspects of the Commissioning flow. */ +cluster GeneralCommissioning = 48 { + revision 1; // NOTE: Default/not specifically set + + enum CommissioningErrorEnum : enum8 { + kOK = 0; + kValueOutsideRange = 1; + kInvalidAuthentication = 2; + kNoFailSafe = 3; + kBusyWithOtherAdmin = 4; + } + + enum RegulatoryLocationTypeEnum : enum8 { + kIndoor = 0; + kOutdoor = 1; + kIndoorOutdoor = 2; + } + + struct BasicCommissioningInfo { + int16u failSafeExpiryLengthSeconds = 0; + int16u maxCumulativeFailsafeSeconds = 1; + } + + attribute access(write: administer) int64u breadcrumb = 0; + readonly attribute BasicCommissioningInfo basicCommissioningInfo = 1; + readonly attribute RegulatoryLocationTypeEnum regulatoryConfig = 2; + readonly attribute RegulatoryLocationTypeEnum locationCapability = 3; + readonly attribute boolean supportsConcurrentConnection = 4; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct ArmFailSafeRequest { + int16u expiryLengthSeconds = 0; + int64u breadcrumb = 1; + } + + response struct ArmFailSafeResponse = 1 { + CommissioningErrorEnum errorCode = 0; + char_string<128> debugText = 1; + } + + request struct SetRegulatoryConfigRequest { + RegulatoryLocationTypeEnum newRegulatoryConfig = 0; + char_string<2> countryCode = 1; + int64u breadcrumb = 2; + } + + response struct SetRegulatoryConfigResponse = 3 { + CommissioningErrorEnum errorCode = 0; + char_string debugText = 1; + } + + response struct CommissioningCompleteResponse = 5 { + CommissioningErrorEnum errorCode = 0; + char_string debugText = 1; + } + + /** Arm the persistent fail-safe timer with an expiry time of now + ExpiryLengthSeconds using device clock */ + command access(invoke: administer) ArmFailSafe(ArmFailSafeRequest): ArmFailSafeResponse = 0; + /** Set the regulatory configuration to be used during commissioning */ + command access(invoke: administer) SetRegulatoryConfig(SetRegulatoryConfigRequest): SetRegulatoryConfigResponse = 2; + /** Signals the Server that the Client has successfully completed all steps of Commissioning/Recofiguration needed during fail-safe period. */ + fabric command access(invoke: administer) CommissioningComplete(): CommissioningCompleteResponse = 4; +} + +/** Functionality to configure, enable, disable network credentials and access on a Matter device. */ +cluster NetworkCommissioning = 49 { + revision 1; // NOTE: Default/not specifically set + + enum NetworkCommissioningStatusEnum : enum8 { + kSuccess = 0; + kOutOfRange = 1; + kBoundsExceeded = 2; + kNetworkIDNotFound = 3; + kDuplicateNetworkID = 4; + kNetworkNotFound = 5; + kRegulatoryError = 6; + kAuthFailure = 7; + kUnsupportedSecurity = 8; + kOtherConnectionFailure = 9; + kIPV6Failed = 10; + kIPBindFailed = 11; + kUnknownError = 12; + } + + enum WiFiBandEnum : enum8 { + k2G4 = 0; + k3G65 = 1; + k5G = 2; + k6G = 3; + k60G = 4; + k1G = 5; + } + + bitmap Feature : bitmap32 { + kWiFiNetworkInterface = 0x1; + kThreadNetworkInterface = 0x2; + kEthernetNetworkInterface = 0x4; + kPerDeviceCredentials = 0x8; + } + + bitmap ThreadCapabilitiesBitmap : bitmap16 { + kIsBorderRouterCapable = 0x1; + kIsRouterCapable = 0x2; + kIsSleepyEndDeviceCapable = 0x4; + kIsFullThreadDevice = 0x8; + kIsSynchronizedSleepyEndDeviceCapable = 0x10; + } + + bitmap WiFiSecurityBitmap : bitmap8 { + kUnencrypted = 0x1; + kWEP = 0x2; + kWPAPersonal = 0x4; + kWPA2Personal = 0x8; + kWPA3Personal = 0x10; + kWPA3MatterPDC = 0x20; + } + + struct NetworkInfoStruct { + octet_string<32> networkID = 0; + boolean connected = 1; + optional nullable octet_string<20> networkIdentifier = 2; + optional nullable octet_string<20> clientIdentifier = 3; + } + + struct ThreadInterfaceScanResultStruct { + int16u panId = 0; + int64u extendedPanId = 1; + char_string<16> networkName = 2; + int16u channel = 3; + int8u version = 4; + octet_string<8> extendedAddress = 5; + int8s rssi = 6; + int8u lqi = 7; + } + + struct WiFiInterfaceScanResultStruct { + WiFiSecurityBitmap security = 0; + octet_string<32> ssid = 1; + octet_string<6> bssid = 2; + int16u channel = 3; + WiFiBandEnum wiFiBand = 4; + int8s rssi = 5; + } + + readonly attribute access(read: administer) int8u maxNetworks = 0; + readonly attribute access(read: administer) NetworkInfoStruct networks[] = 1; + readonly attribute optional int8u scanMaxTimeSeconds = 2; + readonly attribute optional int8u connectMaxTimeSeconds = 3; + attribute access(write: administer) boolean interfaceEnabled = 4; + readonly attribute access(read: administer) nullable NetworkCommissioningStatusEnum lastNetworkingStatus = 5; + readonly attribute access(read: administer) nullable octet_string<32> lastNetworkID = 6; + readonly attribute access(read: administer) nullable int32s lastConnectErrorValue = 7; + readonly attribute optional WiFiBandEnum supportedWiFiBands[] = 8; + readonly attribute optional ThreadCapabilitiesBitmap supportedThreadFeatures = 9; + readonly attribute optional int16u threadVersion = 10; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct ScanNetworksRequest { + optional nullable octet_string<32> ssid = 0; + optional int64u breadcrumb = 1; + } + + response struct ScanNetworksResponse = 1 { + NetworkCommissioningStatusEnum networkingStatus = 0; + optional char_string debugText = 1; + optional WiFiInterfaceScanResultStruct wiFiScanResults[] = 2; + optional ThreadInterfaceScanResultStruct threadScanResults[] = 3; + } + + request struct AddOrUpdateWiFiNetworkRequest { + octet_string<32> ssid = 0; + octet_string<64> credentials = 1; + optional int64u breadcrumb = 2; + optional octet_string<140> networkIdentity = 3; + optional octet_string<20> clientIdentifier = 4; + optional octet_string<32> possessionNonce = 5; + } + + request struct AddOrUpdateThreadNetworkRequest { + octet_string<254> operationalDataset = 0; + optional int64u breadcrumb = 1; + } + + request struct RemoveNetworkRequest { + octet_string<32> networkID = 0; + optional int64u breadcrumb = 1; + } + + response struct NetworkConfigResponse = 5 { + NetworkCommissioningStatusEnum networkingStatus = 0; + optional char_string<512> debugText = 1; + optional int8u networkIndex = 2; + optional octet_string<140> clientIdentity = 3; + optional octet_string<64> possessionSignature = 4; + } + + request struct ConnectNetworkRequest { + octet_string<32> networkID = 0; + optional int64u breadcrumb = 1; + } + + response struct ConnectNetworkResponse = 7 { + NetworkCommissioningStatusEnum networkingStatus = 0; + optional char_string debugText = 1; + nullable int32s errorValue = 2; + } + + request struct ReorderNetworkRequest { + octet_string<32> networkID = 0; + int8u networkIndex = 1; + optional int64u breadcrumb = 2; + } + + request struct QueryIdentityRequest { + octet_string<20> keyIdentifier = 0; + optional octet_string<32> possessionNonce = 1; + } + + response struct QueryIdentityResponse = 10 { + octet_string<140> identity = 0; + optional octet_string<64> possessionSignature = 1; + } + + /** Detemine the set of networks the device sees as available. */ + command access(invoke: administer) ScanNetworks(ScanNetworksRequest): ScanNetworksResponse = 0; + /** Add or update the credentials for a given Wi-Fi network. */ + command access(invoke: administer) AddOrUpdateWiFiNetwork(AddOrUpdateWiFiNetworkRequest): NetworkConfigResponse = 2; + /** Add or update the credentials for a given Thread network. */ + command access(invoke: administer) AddOrUpdateThreadNetwork(AddOrUpdateThreadNetworkRequest): NetworkConfigResponse = 3; + /** Remove the definition of a given network (including its credentials). */ + command access(invoke: administer) RemoveNetwork(RemoveNetworkRequest): NetworkConfigResponse = 4; + /** Connect to the specified network, using previously-defined credentials. */ + command access(invoke: administer) ConnectNetwork(ConnectNetworkRequest): ConnectNetworkResponse = 6; + /** Modify the order in which networks will be presented in the Networks attribute. */ + command access(invoke: administer) ReorderNetwork(ReorderNetworkRequest): NetworkConfigResponse = 8; + /** Retrieve details about and optionally proof of possession of a network client identity. */ + command access(invoke: administer) QueryIdentity(QueryIdentityRequest): QueryIdentityResponse = 9; +} + +/** The General Diagnostics Cluster, along with other diagnostics clusters, provide a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems. */ +cluster GeneralDiagnostics = 51 { + revision 2; + + enum BootReasonEnum : enum8 { + kUnspecified = 0; + kPowerOnReboot = 1; + kBrownOutReset = 2; + kSoftwareWatchdogReset = 3; + kHardwareWatchdogReset = 4; + kSoftwareUpdateCompleted = 5; + kSoftwareReset = 6; + } + + enum HardwareFaultEnum : enum8 { + kUnspecified = 0; + kRadio = 1; + kSensor = 2; + kResettableOverTemp = 3; + kNonResettableOverTemp = 4; + kPowerSource = 5; + kVisualDisplayFault = 6; + kAudioOutputFault = 7; + kUserInterfaceFault = 8; + kNonVolatileMemoryError = 9; + kTamperDetected = 10; + } + + enum InterfaceTypeEnum : enum8 { + kUnspecified = 0; + kWiFi = 1; + kEthernet = 2; + kCellular = 3; + kThread = 4; + } + + enum NetworkFaultEnum : enum8 { + kUnspecified = 0; + kHardwareFailure = 1; + kNetworkJammed = 2; + kConnectionFailed = 3; + } + + enum RadioFaultEnum : enum8 { + kUnspecified = 0; + kWiFiFault = 1; + kCellularFault = 2; + kThreadFault = 3; + kNFCFault = 4; + kBLEFault = 5; + kEthernetFault = 6; + } + + bitmap Feature : bitmap32 { + kDataModelTest = 0x1; + } + + struct NetworkInterface { + char_string<32> name = 0; + boolean isOperational = 1; + nullable boolean offPremiseServicesReachableIPv4 = 2; + nullable boolean offPremiseServicesReachableIPv6 = 3; + octet_string<8> hardwareAddress = 4; + octet_string IPv4Addresses[] = 5; + octet_string IPv6Addresses[] = 6; + InterfaceTypeEnum type = 7; + } + + critical event HardwareFaultChange = 0 { + HardwareFaultEnum current[] = 0; + HardwareFaultEnum previous[] = 1; + } + + critical event RadioFaultChange = 1 { + RadioFaultEnum current[] = 0; + RadioFaultEnum previous[] = 1; + } + + critical event NetworkFaultChange = 2 { + NetworkFaultEnum current[] = 0; + NetworkFaultEnum previous[] = 1; + } + + critical event BootReason = 3 { + BootReasonEnum bootReason = 0; + } + + readonly attribute NetworkInterface networkInterfaces[] = 0; + readonly attribute int16u rebootCount = 1; + readonly attribute optional int64u upTime = 2; + readonly attribute optional int32u totalOperationalHours = 3; + readonly attribute optional BootReasonEnum bootReason = 4; + readonly attribute optional HardwareFaultEnum activeHardwareFaults[] = 5; + readonly attribute optional RadioFaultEnum activeRadioFaults[] = 6; + readonly attribute optional NetworkFaultEnum activeNetworkFaults[] = 7; + readonly attribute boolean testEventTriggersEnabled = 8; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct TestEventTriggerRequest { + octet_string<16> enableKey = 0; + int64u eventTrigger = 1; + } + + response struct TimeSnapshotResponse = 2 { + systime_ms systemTimeMs = 0; + nullable posix_ms posixTimeMs = 1; + } + + request struct PayloadTestRequestRequest { + octet_string<16> enableKey = 0; + int8u value = 1; + int16u count = 2; + } + + response struct PayloadTestResponse = 4 { + octet_string payload = 0; + } + + /** Provide a means for certification tests to trigger some test-plan-specific events */ + command access(invoke: manage) TestEventTrigger(TestEventTriggerRequest): DefaultSuccess = 0; + /** Take a snapshot of system time and epoch time. */ + command TimeSnapshot(): TimeSnapshotResponse = 1; + /** Request a variable length payload response. */ + command PayloadTestRequest(PayloadTestRequestRequest): PayloadTestResponse = 3; +} + +/** The Thread Network Diagnostics Cluster provides a means to acquire standardized diagnostics metrics that MAY be used by a Node to assist a user or Administrative Node in diagnosing potential problems */ +cluster ThreadNetworkDiagnostics = 53 { + revision 2; + + enum ConnectionStatusEnum : enum8 { + kConnected = 0; + kNotConnected = 1; + } + + enum NetworkFaultEnum : enum8 { + kUnspecified = 0; + kLinkDown = 1; + kHardwareFailure = 2; + kNetworkJammed = 3; + } + + enum RoutingRoleEnum : enum8 { + kUnspecified = 0; + kUnassigned = 1; + kSleepyEndDevice = 2; + kEndDevice = 3; + kREED = 4; + kRouter = 5; + kLeader = 6; + } + + bitmap Feature : bitmap32 { + kPacketCounts = 0x1; + kErrorCounts = 0x2; + kMLECounts = 0x4; + kMACCounts = 0x8; + } + + struct NeighborTableStruct { + int64u extAddress = 0; + int32u age = 1; + int16u rloc16 = 2; + int32u linkFrameCounter = 3; + int32u mleFrameCounter = 4; + int8u lqi = 5; + nullable int8s averageRssi = 6; + nullable int8s lastRssi = 7; + int8u frameErrorRate = 8; + int8u messageErrorRate = 9; + boolean rxOnWhenIdle = 10; + boolean fullThreadDevice = 11; + boolean fullNetworkData = 12; + boolean isChild = 13; + } + + struct OperationalDatasetComponents { + boolean activeTimestampPresent = 0; + boolean pendingTimestampPresent = 1; + boolean masterKeyPresent = 2; + boolean networkNamePresent = 3; + boolean extendedPanIdPresent = 4; + boolean meshLocalPrefixPresent = 5; + boolean delayPresent = 6; + boolean panIdPresent = 7; + boolean channelPresent = 8; + boolean pskcPresent = 9; + boolean securityPolicyPresent = 10; + boolean channelMaskPresent = 11; + } + + struct RouteTableStruct { + int64u extAddress = 0; + int16u rloc16 = 1; + int8u routerId = 2; + int8u nextHop = 3; + int8u pathCost = 4; + int8u LQIIn = 5; + int8u LQIOut = 6; + int8u age = 7; + boolean allocated = 8; + boolean linkEstablished = 9; + } + + struct SecurityPolicy { + int16u rotationTime = 0; + int16u flags = 1; + } + + info event ConnectionStatus = 0 { + ConnectionStatusEnum connectionStatus = 0; + } + + info event NetworkFaultChange = 1 { + NetworkFaultEnum current[] = 0; + NetworkFaultEnum previous[] = 1; + } + + readonly attribute nullable int16u channel = 0; + readonly attribute nullable RoutingRoleEnum routingRole = 1; + readonly attribute nullable char_string<16> networkName = 2; + readonly attribute nullable int16u panId = 3; + readonly attribute nullable int64u extendedPanId = 4; + readonly attribute nullable octet_string<17> meshLocalPrefix = 5; + readonly attribute optional int64u overrunCount = 6; + readonly attribute NeighborTableStruct neighborTable[] = 7; + readonly attribute RouteTableStruct routeTable[] = 8; + readonly attribute nullable int32u partitionId = 9; + readonly attribute nullable int16u weighting = 10; + readonly attribute nullable int16u dataVersion = 11; + readonly attribute nullable int16u stableDataVersion = 12; + readonly attribute nullable int8u leaderRouterId = 13; + readonly attribute optional int16u detachedRoleCount = 14; + readonly attribute optional int16u childRoleCount = 15; + readonly attribute optional int16u routerRoleCount = 16; + readonly attribute optional int16u leaderRoleCount = 17; + readonly attribute optional int16u attachAttemptCount = 18; + readonly attribute optional int16u partitionIdChangeCount = 19; + readonly attribute optional int16u betterPartitionAttachAttemptCount = 20; + readonly attribute optional int16u parentChangeCount = 21; + readonly attribute optional int32u txTotalCount = 22; + readonly attribute optional int32u txUnicastCount = 23; + readonly attribute optional int32u txBroadcastCount = 24; + readonly attribute optional int32u txAckRequestedCount = 25; + readonly attribute optional int32u txAckedCount = 26; + readonly attribute optional int32u txNoAckRequestedCount = 27; + readonly attribute optional int32u txDataCount = 28; + readonly attribute optional int32u txDataPollCount = 29; + readonly attribute optional int32u txBeaconCount = 30; + readonly attribute optional int32u txBeaconRequestCount = 31; + readonly attribute optional int32u txOtherCount = 32; + readonly attribute optional int32u txRetryCount = 33; + readonly attribute optional int32u txDirectMaxRetryExpiryCount = 34; + readonly attribute optional int32u txIndirectMaxRetryExpiryCount = 35; + readonly attribute optional int32u txErrCcaCount = 36; + readonly attribute optional int32u txErrAbortCount = 37; + readonly attribute optional int32u txErrBusyChannelCount = 38; + readonly attribute optional int32u rxTotalCount = 39; + readonly attribute optional int32u rxUnicastCount = 40; + readonly attribute optional int32u rxBroadcastCount = 41; + readonly attribute optional int32u rxDataCount = 42; + readonly attribute optional int32u rxDataPollCount = 43; + readonly attribute optional int32u rxBeaconCount = 44; + readonly attribute optional int32u rxBeaconRequestCount = 45; + readonly attribute optional int32u rxOtherCount = 46; + readonly attribute optional int32u rxAddressFilteredCount = 47; + readonly attribute optional int32u rxDestAddrFilteredCount = 48; + readonly attribute optional int32u rxDuplicatedCount = 49; + readonly attribute optional int32u rxErrNoFrameCount = 50; + readonly attribute optional int32u rxErrUnknownNeighborCount = 51; + readonly attribute optional int32u rxErrInvalidSrcAddrCount = 52; + readonly attribute optional int32u rxErrSecCount = 53; + readonly attribute optional int32u rxErrFcsCount = 54; + readonly attribute optional int32u rxErrOtherCount = 55; + readonly attribute optional nullable int64u activeTimestamp = 56; + readonly attribute optional nullable int64u pendingTimestamp = 57; + readonly attribute optional nullable int32u delay = 58; + readonly attribute nullable SecurityPolicy securityPolicy = 59; + readonly attribute nullable octet_string<4> channelPage0Mask = 60; + readonly attribute nullable OperationalDatasetComponents operationalDatasetComponents = 61; + readonly attribute NetworkFaultEnum activeNetworkFaultsList[] = 62; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + /** Reception of this command SHALL reset the OverrunCount attributes to 0 */ + command access(invoke: manage) ResetCounts(): DefaultSuccess = 0; +} + +/** Commands to trigger a Node to allow a new Administrator to commission it. */ +cluster AdministratorCommissioning = 60 { + revision 1; // NOTE: Default/not specifically set + + enum CommissioningWindowStatusEnum : enum8 { + kWindowNotOpen = 0; + kEnhancedWindowOpen = 1; + kBasicWindowOpen = 2; + } + + enum StatusCode : enum8 { + kBusy = 2; + kPAKEParameterError = 3; + kWindowNotOpen = 4; + } + + bitmap Feature : bitmap32 { + kBasic = 0x1; + } + + readonly attribute CommissioningWindowStatusEnum windowStatus = 0; + readonly attribute nullable fabric_idx adminFabricIndex = 1; + readonly attribute nullable vendor_id adminVendorId = 2; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct OpenCommissioningWindowRequest { + int16u commissioningTimeout = 0; + octet_string PAKEPasscodeVerifier = 1; + int16u discriminator = 2; + int32u iterations = 3; + octet_string<32> salt = 4; + } + + request struct OpenBasicCommissioningWindowRequest { + int16u commissioningTimeout = 0; + } + + /** This command is used by a current Administrator to instruct a Node to go into commissioning mode using enhanced commissioning method. */ + timed command access(invoke: administer) OpenCommissioningWindow(OpenCommissioningWindowRequest): DefaultSuccess = 0; + /** This command is used by a current Administrator to instruct a Node to go into commissioning mode using basic commissioning method, if the node supports it. */ + timed command access(invoke: administer) OpenBasicCommissioningWindow(OpenBasicCommissioningWindowRequest): DefaultSuccess = 1; + /** This command is used by a current Administrator to instruct a Node to revoke any active Open Commissioning Window or Open Basic Commissioning Window command. */ + timed command access(invoke: administer) RevokeCommissioning(): DefaultSuccess = 2; +} + +/** This cluster is used to add or remove Operational Credentials on a Commissionee or Node, as well as manage the associated Fabrics. */ +cluster OperationalCredentials = 62 { + revision 1; // NOTE: Default/not specifically set + + enum CertificateChainTypeEnum : enum8 { + kDACCertificate = 1; + kPAICertificate = 2; + } + + enum NodeOperationalCertStatusEnum : enum8 { + kOK = 0; + kInvalidPublicKey = 1; + kInvalidNodeOpId = 2; + kInvalidNOC = 3; + kMissingCsr = 4; + kTableFull = 5; + kInvalidAdminSubject = 6; + kFabricConflict = 9; + kLabelConflict = 10; + kInvalidFabricIndex = 11; + } + + fabric_scoped struct FabricDescriptorStruct { + octet_string<65> rootPublicKey = 1; + vendor_id vendorID = 2; + fabric_id fabricID = 3; + node_id nodeID = 4; + char_string<32> label = 5; + fabric_idx fabricIndex = 254; + } + + fabric_scoped struct NOCStruct { + fabric_sensitive octet_string noc = 1; + nullable fabric_sensitive octet_string icac = 2; + fabric_idx fabricIndex = 254; + } + + readonly attribute access(read: administer) NOCStruct NOCs[] = 0; + readonly attribute FabricDescriptorStruct fabrics[] = 1; + readonly attribute int8u supportedFabrics = 2; + readonly attribute int8u commissionedFabrics = 3; + readonly attribute octet_string trustedRootCertificates[] = 4; + readonly attribute int8u currentFabricIndex = 5; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct AttestationRequestRequest { + octet_string<32> attestationNonce = 0; + } + + response struct AttestationResponse = 1 { + octet_string<900> attestationElements = 0; + octet_string<64> attestationSignature = 1; + } + + request struct CertificateChainRequestRequest { + CertificateChainTypeEnum certificateType = 0; + } + + response struct CertificateChainResponse = 3 { + octet_string<600> certificate = 0; + } + + request struct CSRRequestRequest { + octet_string<32> CSRNonce = 0; + optional boolean isForUpdateNOC = 1; + } + + response struct CSRResponse = 5 { + octet_string NOCSRElements = 0; + octet_string attestationSignature = 1; + } + + request struct AddNOCRequest { + octet_string<400> NOCValue = 0; + optional octet_string<400> ICACValue = 1; + octet_string<16> IPKValue = 2; + int64u caseAdminSubject = 3; + vendor_id adminVendorId = 4; + } + + request struct UpdateNOCRequest { + octet_string NOCValue = 0; + optional octet_string ICACValue = 1; + } + + response struct NOCResponse = 8 { + NodeOperationalCertStatusEnum statusCode = 0; + optional fabric_idx fabricIndex = 1; + optional char_string<128> debugText = 2; + } + + request struct UpdateFabricLabelRequest { + char_string<32> label = 0; + } + + request struct RemoveFabricRequest { + fabric_idx fabricIndex = 0; + } + + request struct AddTrustedRootCertificateRequest { + octet_string rootCACertificate = 0; + } + + /** Sender is requesting attestation information from the receiver. */ + command access(invoke: administer) AttestationRequest(AttestationRequestRequest): AttestationResponse = 0; + /** Sender is requesting a device attestation certificate from the receiver. */ + command access(invoke: administer) CertificateChainRequest(CertificateChainRequestRequest): CertificateChainResponse = 2; + /** Sender is requesting a certificate signing request (CSR) from the receiver. */ + command access(invoke: administer) CSRRequest(CSRRequestRequest): CSRResponse = 4; + /** Sender is requesting to add the new node operational certificates. */ + command access(invoke: administer) AddNOC(AddNOCRequest): NOCResponse = 6; + /** Sender is requesting to update the node operational certificates. */ + fabric command access(invoke: administer) UpdateNOC(UpdateNOCRequest): NOCResponse = 7; + /** This command SHALL be used by an Administrative Node to set the user-visible Label field for a given Fabric, as reflected by entries in the Fabrics attribute. */ + fabric command access(invoke: administer) UpdateFabricLabel(UpdateFabricLabelRequest): NOCResponse = 9; + /** This command is used by Administrative Nodes to remove a given fabric index and delete all associated fabric-scoped data. */ + command access(invoke: administer) RemoveFabric(RemoveFabricRequest): NOCResponse = 10; + /** This command SHALL add a Trusted Root CA Certificate, provided as its CHIP Certificate representation. */ + command access(invoke: administer) AddTrustedRootCertificate(AddTrustedRootCertificateRequest): DefaultSuccess = 11; +} + +/** The Group Key Management Cluster is the mechanism by which group keys are managed. */ +cluster GroupKeyManagement = 63 { + revision 1; // NOTE: Default/not specifically set + + enum GroupKeySecurityPolicyEnum : enum8 { + kTrustFirst = 0; + kCacheAndSync = 1; + } + + bitmap Feature : bitmap32 { + kCacheAndSync = 0x1; + } + + fabric_scoped struct GroupInfoMapStruct { + group_id groupId = 1; + endpoint_no endpoints[] = 2; + optional char_string<16> groupName = 3; + fabric_idx fabricIndex = 254; + } + + fabric_scoped struct GroupKeyMapStruct { + group_id groupId = 1; + int16u groupKeySetID = 2; + fabric_idx fabricIndex = 254; + } + + struct GroupKeySetStruct { + int16u groupKeySetID = 0; + GroupKeySecurityPolicyEnum groupKeySecurityPolicy = 1; + nullable octet_string<16> epochKey0 = 2; + nullable epoch_us epochStartTime0 = 3; + nullable octet_string<16> epochKey1 = 4; + nullable epoch_us epochStartTime1 = 5; + nullable octet_string<16> epochKey2 = 6; + nullable epoch_us epochStartTime2 = 7; + } + + attribute access(write: manage) GroupKeyMapStruct groupKeyMap[] = 0; + readonly attribute GroupInfoMapStruct groupTable[] = 1; + readonly attribute int16u maxGroupsPerFabric = 2; + readonly attribute int16u maxGroupKeysPerFabric = 3; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct KeySetWriteRequest { + GroupKeySetStruct groupKeySet = 0; + } + + request struct KeySetReadRequest { + int16u groupKeySetID = 0; + } + + response struct KeySetReadResponse = 2 { + GroupKeySetStruct groupKeySet = 0; + } + + request struct KeySetRemoveRequest { + int16u groupKeySetID = 0; + } + + response struct KeySetReadAllIndicesResponse = 5 { + int16u groupKeySetIDs[] = 0; + } + + /** Write a new set of keys for the given key set id. */ + fabric command access(invoke: administer) KeySetWrite(KeySetWriteRequest): DefaultSuccess = 0; + /** Read the keys for a given key set id. */ + fabric command access(invoke: administer) KeySetRead(KeySetReadRequest): KeySetReadResponse = 1; + /** Revoke a Root Key from a Group */ + fabric command access(invoke: administer) KeySetRemove(KeySetRemoveRequest): DefaultSuccess = 3; + /** Return the list of Group Key Sets associated with the accessing fabric */ + fabric command access(invoke: administer) KeySetReadAllIndices(): KeySetReadAllIndicesResponse = 4; +} + +/** The Fixed Label Cluster provides a feature for the device to tag an endpoint with zero or more read only +labels. */ +cluster FixedLabel = 64 { + revision 1; // NOTE: Default/not specifically set + + struct LabelStruct { + char_string<16> label = 0; + char_string<16> value = 1; + } + + readonly attribute LabelStruct labelList[] = 0; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** The User Label Cluster provides a feature to tag an endpoint with zero or more labels. */ +cluster UserLabel = 65 { + revision 1; // NOTE: Default/not specifically set + + struct LabelStruct { + char_string<16> label = 0; + char_string<16> value = 1; + } + + attribute access(write: manage) LabelStruct labelList[] = 0; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; +} + +/** Thread BR management */ +cluster ThreadBorderRouterManagement = 1106 { + revision 1; + + enum RoutingRoleEnum : enum8 { + kUnspecified = 0; + kUnassigned = 1; + kSleepyEndDevice = 2; + kEndDevice = 3; + kREED = 4; + kRouter = 5; + kLeader = 6; + } + + bitmap Feature : bitmap32 { + kPANChange = 0x1; + } + + struct ChildTableStruct { + int16u rloc16 = 0; + int8u linkQuality = 1; + RoutingRoleEnum routingRole = 2; + } + + struct RouteTableStruct { + int8u routerId = 0; + int8u pathCost = 1; + int8u LQIIn = 2; + int8u LQIOut = 3; + } + + struct ThreadNodeStruct { + int64u extAddress = 0; + int16u rloc16 = 1; + octet_string IPv6s[] = 2; + RoutingRoleEnum routingRole = 3; + RouteTableStruct routeTable[] = 4; + ChildTableStruct childTable[] = 5; + } + + struct NeiborTableStruct { + int64u extAddress = 0; + int32u age = 1; + int16u rloc16 = 2; + nullable int8s averageRssi = 3; + nullable int8s lastRssi = 4; + RoutingRoleEnum routingRole = 5; + } + + readonly attribute char_string<63> borderRouterName = 0; + readonly attribute octet_string<16> borderAgentId = 1; + readonly attribute int16u threadVersion = 2; + readonly attribute boolean interfaceEnabled = 3; + readonly attribute ThreadNodeStruct threadNode = 4; + readonly attribute nullable int64u activeDatasetTimestamp = 5; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + response struct DatasetResponse = 2 { + octet_string<254> dataset = 0; + } + + request struct SetActiveDatasetRequestRequest { + octet_string<254> activeDataset = 0; + int64u breadcrumb = 1; + } + + request struct SetPendingDatasetRequestRequest { + octet_string<254> pendingDataset = 0; + } + + request struct TopologyRequestRequest { + int16u count = 0; + int16u startIndex = 1; + int8u snapshot = 2; + } + + response struct TopologyResponse = 6 { + status status = 0; + int8u snapshot = 1; + int16u numberOfDevices = 2; + ThreadNodeStruct threadTopology[] = 3; + } + + /** On receipt of this command, the Thread Border Router will read the active operational dataset of the Thread network that it is connaected to, and send the DatasetResponse as the response. This command must be sent over a valid CASE session */ + command access(invoke: manage) GetActiveDatasetRequest(): DatasetResponse = 0; + /** On receipt of this command, the Thread Border Router will read the pending dataset and send the DatasetResponse as the response. This command must be sent over a valid CASE session */ + command access(invoke: manage) GetPendingDatasetRequest(): DatasetResponse = 1; + /** On receipt of this command, the Thread Border Router will set or update the active Dataset of the Thread network that the Stub Router is connected to. */ + command access(invoke: manage) SetActiveDatasetRequest(SetActiveDatasetRequestRequest): DefaultSuccess = 3; + /** On receipt of this command, the Thread Border Router will set or update the pending Dataset */ + command access(invoke: manage) SetPendingDatasetRequest(SetPendingDatasetRequestRequest): DefaultSuccess = 4; + /** On receipt of this command, the Thread Border Router will response the current topology of the Thread network that it is connected to. */ + command access(invoke: administer) TopologyRequest(TopologyRequestRequest): TopologyResponse = 5; +} + +endpoint 0 { + device type ma_rootdevice = 22, version 1; + + binding cluster AccessControl; + + server cluster Descriptor { + callback attribute deviceTypeList; + callback attribute serverList; + callback attribute clientList; + callback attribute partsList; + callback attribute generatedCommandList; + callback attribute acceptedCommandList; + callback attribute attributeList; + callback attribute featureMap; + callback attribute clusterRevision; + } + + server cluster AccessControl { + emits event AccessControlEntryChanged; + emits event AccessControlExtensionChanged; + callback attribute acl; + callback attribute extension; + callback attribute subjectsPerAccessControlEntry; + callback attribute targetsPerAccessControlEntry; + callback attribute accessControlEntriesPerFabric; + callback attribute attributeList; + ram attribute featureMap default = 0; + callback attribute clusterRevision; + } + + server cluster BasicInformation { + emits event StartUp; + emits event ShutDown; + emits event Leave; + callback attribute dataModelRevision; + callback attribute vendorName; + callback attribute vendorID; + callback attribute productName; + callback attribute productID; + persist attribute nodeLabel; + callback attribute location; + callback attribute hardwareVersion; + callback attribute hardwareVersionString; + callback attribute softwareVersion; + callback attribute softwareVersionString; + callback attribute manufacturingDate; + callback attribute partNumber; + callback attribute productURL; + callback attribute productLabel; + callback attribute serialNumber; + persist attribute localConfigDisabled default = 0; + callback attribute uniqueID; + callback attribute capabilityMinima; + callback attribute specificationVersion; + callback attribute maxPathsPerInvoke; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 3; + } + + server cluster LocalizationConfiguration { + persist attribute activeLocale default = "en-US"; + callback attribute supportedLocales; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + } + + server cluster TimeFormatLocalization { + persist attribute hourFormat default = 0; + persist attribute activeCalendarType default = 0; + callback attribute supportedCalendarTypes; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + } + + server cluster GeneralCommissioning { + ram attribute breadcrumb default = 0x0000000000000000; + callback attribute basicCommissioningInfo; + callback attribute regulatoryConfig; + callback attribute locationCapability; + callback attribute supportsConcurrentConnection; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + + handle command ArmFailSafe; + handle command ArmFailSafeResponse; + handle command SetRegulatoryConfig; + handle command SetRegulatoryConfigResponse; + handle command CommissioningComplete; + handle command CommissioningCompleteResponse; + } + + server cluster NetworkCommissioning { + ram attribute maxNetworks; + callback attribute networks; + ram attribute scanMaxTimeSeconds; + ram attribute connectMaxTimeSeconds; + ram attribute interfaceEnabled; + ram attribute lastNetworkingStatus; + ram attribute lastNetworkID; + ram attribute lastConnectErrorValue; + ram attribute featureMap default = 2; + ram attribute clusterRevision default = 1; + + handle command ScanNetworks; + handle command ScanNetworksResponse; + handle command AddOrUpdateWiFiNetwork; + handle command AddOrUpdateThreadNetwork; + handle command RemoveNetwork; + handle command NetworkConfigResponse; + handle command ConnectNetwork; + handle command ConnectNetworkResponse; + handle command ReorderNetwork; + } + + server cluster GeneralDiagnostics { + emits event BootReason; + callback attribute networkInterfaces; + callback attribute rebootCount; + callback attribute upTime; + callback attribute totalOperationalHours; + callback attribute bootReason; + callback attribute activeHardwareFaults; + callback attribute activeRadioFaults; + callback attribute activeNetworkFaults; + callback attribute testEventTriggersEnabled default = false; + callback attribute featureMap; + callback attribute clusterRevision; + + handle command TestEventTrigger; + handle command TimeSnapshot; + handle command TimeSnapshotResponse; + } + + server cluster AdministratorCommissioning { + callback attribute windowStatus; + callback attribute adminFabricIndex; + callback attribute adminVendorId; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + + handle command OpenCommissioningWindow; + handle command OpenBasicCommissioningWindow; + handle command RevokeCommissioning; + } + + server cluster OperationalCredentials { + callback attribute NOCs; + callback attribute fabrics; + callback attribute supportedFabrics; + callback attribute commissionedFabrics; + callback attribute trustedRootCertificates; + callback attribute currentFabricIndex; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + + handle command AttestationRequest; + handle command AttestationResponse; + handle command CertificateChainRequest; + handle command CertificateChainResponse; + handle command CSRRequest; + handle command CSRResponse; + handle command AddNOC; + handle command UpdateNOC; + handle command NOCResponse; + handle command UpdateFabricLabel; + handle command RemoveFabric; + handle command AddTrustedRootCertificate; + } + + server cluster GroupKeyManagement { + callback attribute groupKeyMap; + callback attribute groupTable; + callback attribute maxGroupsPerFabric; + callback attribute maxGroupKeysPerFabric; + callback attribute featureMap; + callback attribute clusterRevision; + + handle command KeySetWrite; + handle command KeySetRead; + handle command KeySetReadResponse; + handle command KeySetRemove; + handle command KeySetReadAllIndices; + handle command KeySetReadAllIndicesResponse; + } + + server cluster FixedLabel { + callback attribute labelList; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + } + + server cluster UserLabel { + callback attribute labelList; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + } +} +endpoint 1 { + device type ma_thread_border_router = 4293984273, version 1; + + + server cluster Descriptor { + callback attribute deviceTypeList; + callback attribute serverList; + callback attribute clientList; + callback attribute partsList; + callback attribute generatedCommandList; + callback attribute acceptedCommandList; + callback attribute eventList; + callback attribute attributeList; + callback attribute featureMap; + callback attribute clusterRevision; + } + + server cluster ThreadNetworkDiagnostics { + callback attribute channel; + callback attribute routingRole; + callback attribute networkName; + callback attribute panId; + callback attribute extendedPanId; + callback attribute meshLocalPrefix; + callback attribute neighborTable; + callback attribute routeTable; + callback attribute partitionId; + callback attribute weighting; + callback attribute dataVersion; + callback attribute stableDataVersion; + callback attribute leaderRouterId; + callback attribute securityPolicy; + callback attribute channelPage0Mask; + callback attribute operationalDatasetComponents; + callback attribute activeNetworkFaultsList; + callback attribute generatedCommandList; + callback attribute acceptedCommandList; + callback attribute eventList; + callback attribute attributeList; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 2; + } + + server cluster ThreadBorderRouterManagement { + callback attribute borderRouterName; + callback attribute borderAgentId; + callback attribute threadVersion; + callback attribute interfaceEnabled; + callback attribute threadNode; + callback attribute activeDatasetTimestamp; + callback attribute generatedCommandList; + callback attribute acceptedCommandList; + callback attribute eventList; + callback attribute attributeList; + callback attribute featureMap; + ram attribute clusterRevision default = 1; + + handle command GetActiveDatasetRequest; + handle command GetPendingDatasetRequest; + handle command DatasetResponse; + handle command SetActiveDatasetRequest; + handle command SetPendingDatasetRequest; + handle command TopologyRequest; + handle command TopologyResponse; + } +} + + diff --git a/examples/thread-br-app/thread-br-common/thread-br-app.zap b/examples/thread-br-app/thread-br-common/thread-br-app.zap new file mode 100644 index 00000000000000..89f3d662a9dada --- /dev/null +++ b/examples/thread-br-app/thread-br-common/thread-br-app.zap @@ -0,0 +1,3081 @@ +{ + "fileFormat": 2, + "featureLevel": 102, + "creator": "zap", + "keyValuePairs": [ + { + "key": "commandDiscovery", + "value": "1" + }, + { + "key": "defaultResponsePolicy", + "value": "always" + }, + { + "key": "manufacturerCodes", + "value": "0x1002" + } + ], + "package": [ + { + "pathRelativity": "relativeToZap", + "path": "../../../src/app/zap-templates/zcl/zcl.json", + "type": "zcl-properties", + "category": "matter", + "version": 1, + "description": "Matter SDK ZCL data" + }, + { + "pathRelativity": "relativeToZap", + "path": "../../../src/app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" + } + ], + "endpointTypes": [ + { + "id": 1, + "name": "MA-rootdevice", + "deviceTypeRef": { + "code": 22, + "profileId": 259, + "label": "MA-rootdevice", + "name": "MA-rootdevice" + }, + "deviceTypes": [ + { + "code": 22, + "profileId": 259, + "label": "MA-rootdevice", + "name": "MA-rootdevice" + } + ], + "deviceVersions": [ + 1 + ], + "deviceIdentifiers": [ + 22 + ], + "deviceTypeName": "MA-rootdevice", + "deviceTypeCode": 22, + "deviceTypeProfileId": 259, + "clusters": [ + { + "name": "Descriptor", + "code": 29, + "mfgCode": null, + "define": "DESCRIPTOR_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "DeviceTypeList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ServerList", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClientList", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "PartsList", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Access Control", + "code": 31, + "mfgCode": null, + "define": "ACCESS_CONTROL_CLUSTER", + "side": "client", + "enabled": 1, + "attributes": [ + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Access Control", + "code": 31, + "mfgCode": null, + "define": "ACCESS_CONTROL_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "ACL", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Extension", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SubjectsPerAccessControlEntry", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TargetsPerAccessControlEntry", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AccessControlEntriesPerFabric", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ], + "events": [ + { + "name": "AccessControlEntryChanged", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "AccessControlExtensionChanged", + "code": 1, + "mfgCode": null, + "side": "server", + "included": 1 + } + ] + }, + { + "name": "Basic Information", + "code": 40, + "mfgCode": null, + "define": "BASIC_INFORMATION_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "DataModelRevision", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "VendorName", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "VendorID", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "vendor_id", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "ProductName", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "ProductID", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "NodeLabel", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "NVM", + "singleton": 1, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "Location", + "code": 6, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "HardwareVersion", + "code": 7, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "HardwareVersionString", + "code": 8, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "SoftwareVersion", + "code": 9, + "mfgCode": null, + "side": "server", + "type": "int32u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "SoftwareVersionString", + "code": 10, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "ManufacturingDate", + "code": 11, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "PartNumber", + "code": 12, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "ProductURL", + "code": 13, + "mfgCode": null, + "side": "server", + "type": "long_char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "ProductLabel", + "code": 14, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "SerialNumber", + "code": 15, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "LocalConfigDisabled", + "code": 16, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "NVM", + "singleton": 1, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "UniqueID", + "code": 18, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "CapabilityMinima", + "code": 19, + "mfgCode": null, + "side": "server", + "type": "CapabilityMinimaStruct", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SpecificationVersion", + "code": 21, + "mfgCode": null, + "side": "server", + "type": "int32u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "MaxPathsPerInvoke", + "code": 22, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 1, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 1, + "bounded": 0, + "defaultValue": "3", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ], + "events": [ + { + "name": "StartUp", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "ShutDown", + "code": 1, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "Leave", + "code": 2, + "mfgCode": null, + "side": "server", + "included": 1 + } + ] + }, + { + "name": "Localization Configuration", + "code": 43, + "mfgCode": null, + "define": "LOCALIZATION_CONFIGURATION_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "ActiveLocale", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "en-US", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SupportedLocales", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Time Format Localization", + "code": 44, + "mfgCode": null, + "define": "TIME_FORMAT_LOCALIZATION_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "HourFormat", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "HourFormatEnum", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveCalendarType", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "CalendarTypeEnum", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SupportedCalendarTypes", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "General Commissioning", + "code": 48, + "mfgCode": null, + "define": "GENERAL_COMMISSIONING_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "ArmFailSafe", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ArmFailSafeResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "SetRegulatoryConfig", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "SetRegulatoryConfigResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "CommissioningComplete", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "CommissioningCompleteResponse", + "code": 5, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "Breadcrumb", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "int64u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x0000000000000000", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "BasicCommissioningInfo", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "BasicCommissioningInfo", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "RegulatoryConfig", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "RegulatoryLocationTypeEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LocationCapability", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "RegulatoryLocationTypeEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SupportsConcurrentConnection", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "Network Commissioning", + "code": 49, + "mfgCode": null, + "define": "NETWORK_COMMISSIONING_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "ScanNetworks", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ScanNetworksResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "AddOrUpdateWiFiNetwork", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "AddOrUpdateThreadNetwork", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveNetwork", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "NetworkConfigResponse", + "code": 5, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "ConnectNetwork", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ConnectNetworkResponse", + "code": 7, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "ReorderNetwork", + "code": 8, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "MaxNetworks", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Networks", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ScanMaxTimeSeconds", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ConnectMaxTimeSeconds", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "InterfaceEnabled", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LastNetworkingStatus", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "NetworkCommissioningStatusEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LastNetworkID", + "code": 6, + "mfgCode": null, + "side": "server", + "type": "octet_string", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LastConnectErrorValue", + "code": 7, + "mfgCode": null, + "side": "server", + "type": "int32s", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "2", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "General Diagnostics", + "code": 51, + "mfgCode": null, + "define": "GENERAL_DIAGNOSTICS_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "TestEventTrigger", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "TimeSnapshot", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "TimeSnapshotResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "NetworkInterfaces", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "RebootCount", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "UpTime", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int64u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TotalOperationalHours", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int32u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "BootReason", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "BootReasonEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveHardwareFaults", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveRadioFaults", + "code": 6, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveNetworkFaults", + "code": 7, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TestEventTriggersEnabled", + "code": 8, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "false", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ], + "events": [ + { + "name": "BootReason", + "code": 3, + "mfgCode": null, + "side": "server", + "included": 1 + } + ] + }, + { + "name": "Administrator Commissioning", + "code": 60, + "mfgCode": null, + "define": "ADMINISTRATOR_COMMISSIONING_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "OpenCommissioningWindow", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "OpenBasicCommissioningWindow", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RevokeCommissioning", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "WindowStatus", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "CommissioningWindowStatusEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AdminFabricIndex", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "fabric_idx", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AdminVendorId", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "vendor_id", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Operational Credentials", + "code": 62, + "mfgCode": null, + "define": "OPERATIONAL_CREDENTIALS_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "AttestationRequest", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "AttestationResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "CertificateChainRequest", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "CertificateChainResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "CSRRequest", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "CSRResponse", + "code": 5, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "AddNOC", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "UpdateNOC", + "code": 7, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "NOCResponse", + "code": 8, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "UpdateFabricLabel", + "code": 9, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveFabric", + "code": 10, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "AddTrustedRootCertificate", + "code": 11, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "NOCs", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Fabrics", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "SupportedFabrics", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "CommissionedFabrics", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "TrustedRootCertificates", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "CurrentFabricIndex", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "Group Key Management", + "code": 63, + "mfgCode": null, + "define": "GROUP_KEY_MANAGEMENT_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "KeySetWrite", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "KeySetRead", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "KeySetReadResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "KeySetRemove", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "KeySetReadAllIndices", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "KeySetReadAllIndicesResponse", + "code": 5, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "GroupKeyMap", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "GroupTable", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "MaxGroupsPerFabric", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "MaxGroupKeysPerFabric", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "Fixed Label", + "code": 64, + "mfgCode": null, + "define": "FIXED_LABEL_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "LabelList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "User Label", + "code": 65, + "mfgCode": null, + "define": "USER_LABEL_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "LabelList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + } + ] + }, + { + "id": 2, + "name": "Anonymous Endpoint Type", + "deviceTypeRef": { + "code": 4293984273, + "profileId": 259, + "label": "MA-thread-border-router", + "name": "MA-thread-border-router" + }, + "deviceTypes": [ + { + "code": 4293984273, + "profileId": 259, + "label": "MA-thread-border-router", + "name": "MA-thread-border-router" + } + ], + "deviceVersions": [ + 1 + ], + "deviceIdentifiers": [ + 4293984273 + ], + "deviceTypeName": "MA-thread-border-router", + "deviceTypeCode": 4293984273, + "deviceTypeProfileId": 259, + "clusters": [ + { + "name": "Descriptor", + "code": 29, + "mfgCode": null, + "define": "DESCRIPTOR_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "DeviceTypeList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ServerList", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClientList", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "PartsList", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Thread Network Diagnostics", + "code": 53, + "mfgCode": null, + "define": "THREAD_NETWORK_DIAGNOSTICS_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "Channel", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "RoutingRole", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "RoutingRoleEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "NetworkName", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "PanId", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ExtendedPanId", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "int64u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "MeshLocalPrefix", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "octet_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "NeighborTable", + "code": 7, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "RouteTable", + "code": 8, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "PartitionId", + "code": 9, + "mfgCode": null, + "side": "server", + "type": "int32u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Weighting", + "code": 10, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "DataVersion", + "code": 11, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "StableDataVersion", + "code": 12, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LeaderRouterId", + "code": 13, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SecurityPolicy", + "code": 59, + "mfgCode": null, + "side": "server", + "type": "SecurityPolicy", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ChannelPage0Mask", + "code": 60, + "mfgCode": null, + "side": "server", + "type": "octet_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "OperationalDatasetComponents", + "code": 61, + "mfgCode": null, + "side": "server", + "type": "OperationalDatasetComponents", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveNetworkFaultsList", + "code": 62, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "2", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Thread Border Router Management", + "code": 1106, + "mfgCode": null, + "define": "THREAD_BORDER_ROUTER_MANAGEMENT", + "side": "server", + "enabled": 1, + "commands": [ + { + "name": "GetActiveDatasetRequest", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "GetPendingDatasetRequest", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "DatasetResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "SetActiveDatasetRequest", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "SetPendingDatasetRequest", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "TopologyRequest", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "TopologyResponse", + "code": 6, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "BorderRouterName", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "BorderAgentId", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "octet_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ThreadVersion", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "InterfaceEnabled", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ThreadNode", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "ThreadNodeStruct", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ActiveDatasetTimestamp", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "int64u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + } + ] + } + ], + "endpoints": [ + { + "endpointTypeName": "MA-rootdevice", + "endpointTypeIndex": 0, + "profileId": 259, + "endpointId": 0, + "networkId": 0, + "parentEndpointIdentifier": null + }, + { + "endpointTypeName": "Anonymous Endpoint Type", + "endpointTypeIndex": 1, + "profileId": 259, + "endpointId": 1, + "networkId": 0, + "parentEndpointIdentifier": null + } + ] +} \ No newline at end of file diff --git a/third_party/infineon/repos/matter-wpan-sdk b/third_party/infineon/repos/matter-wpan-sdk index 6086f0a77620a3..f6e196cbd982cf 160000 --- a/third_party/infineon/repos/matter-wpan-sdk +++ b/third_party/infineon/repos/matter-wpan-sdk @@ -1 +1 @@ -Subproject commit 6086f0a77620a33af7ef1ae95c1d6bd959f8a5e0 +Subproject commit f6e196cbd982cfd4c74ffca6ba4128dba298b8ac From 10a07df84811c9c0d6543173d8ccaf41a7de42d0 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Wed, 22 May 2024 20:17:02 +0800 Subject: [PATCH 4/4] add readme file for the thread br app example --- examples/thread-br-app/esp32/README.md | 82 ++++++++++++++++++ .../image/esp-thread-border-router-board.png | Bin 0 -> 822566 bytes 2 files changed, 82 insertions(+) create mode 100644 examples/thread-br-app/esp32/README.md create mode 100644 examples/thread-br-app/esp32/image/esp-thread-border-router-board.png diff --git a/examples/thread-br-app/esp32/README.md b/examples/thread-br-app/esp32/README.md new file mode 100644 index 00000000000000..528a420da56e7f --- /dev/null +++ b/examples/thread-br-app/esp32/README.md @@ -0,0 +1,82 @@ +# Matter ESP32 Thread Border Router Example + +A prototype application that demonstrates OpenThread Border Router on ESP32-S3 + ESP32-H2 +Thread Border Router DevKit Board. + +Please +[setup ESP-IDF and CHIP Environment](../../../docs/guides/esp32/setup_idf_chip.md) +and refer +[building and commissioning](../../../docs/guides/esp32/build_app_and_commission.md) +guides to get started. + +--- + +- [OpenThread Border Router DevKit Board](#openthread-border-router-board) +- [OpenThread RCP](#openthread-rcp) +- [OpenThread CLI](#openthread-cli) +- [Setup Thread Network](#setup-thread-network) +- [Commissioning Thread End Devices](#commissioning-thread-end-devices) + +--- + +### Thread Border Router Board + +The ESP Thread border router board provides an integrated module of an ESP32-S3 and an ESP32-H2. + +![br_dev_kit](./image/esp-thread-border-router-board.png) + +### OpenThread RCP + +We need to flash an OpenThread RCP(Radio Co-Processor) on ESP32-H2 of the Border Router Board before setting +up the Thread Border example. Connect the USB1 port of the Border Router Board to your host machine. Then +build and flash the RCP firmware + +``` +cd $IDF_PATH/examples/openthread/ot_rcp +idf.py set-target esp32-h2 +idf.py build +idf.py -p {port} erase-flash flash +``` + +### OpenThread CLI + +After you build this example and flash it to the ESP32-S3 of Border Router Board, you can access a standard +OpenThread CLI via the device console with a `matter otcli` prefix. + +For instance, you can get the state: +``` +> matter otcli state +Detached +Done +``` + +### Setup Thread Network + +You can choose to setup Thread network with the [OpenThread CLI](#openthread-cli). + +``` +> matter otcli dataset set active +> matter otcli dataset commit active +> matter otcli ifconfig up +> matter otcli thread start +``` + +Or you can send SetActiveDatasetRequest command to the Thread BR after commissioning it as a +Matter-Over-Wi-Fi device to setup the Thread network. + +``` +./chip-tool pairing ble-wifi 1 20202021 3840 +./chip-tool generalcommissioning arm-fail-safe 180 1 1 0 +./chip-tool threadborderroutermanagement set-active-dataset-request hex: 1 1 1 +``` + +The Thread BR with enable the Thread network interface and start Thread network after it receives +SetActiveDatasetRequest command. + +### Commissioning Thread End Devices + +After setting up the Thread network, you can commission a Thread End-device to the Thread network. + +``` +./chip-tool pairing ble-wifi 2 hex: +``` diff --git a/examples/thread-br-app/esp32/image/esp-thread-border-router-board.png b/examples/thread-br-app/esp32/image/esp-thread-border-router-board.png new file mode 100644 index 0000000000000000000000000000000000000000..fb2db7db60e593b367a94da207a8ff6e5b1989cd GIT binary patch literal 822566 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Ċ@*2Y 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 z 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¥WSt^8{f1<_!i*}?;DEO4z4a*n#ZgVYD)CG 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νm0z5{3v|N{1m3 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

uNRzFmo?Rup3XGA+yrwpz8Qip_okkmK}T$$;$7 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

q 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%0AkwiuR#)irXrp(B%>75qIKkJ( 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π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�d58(Qk_$qa+FF(TH!gmCz4mzFy4e(M^Jpgq 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