From cd03b40775ae15635932700c343816b5f94482e9 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Tue, 30 Nov 2021 15:04:11 -0500 Subject: [PATCH] Enable more attributes in TestCluster. (#12355) This enables attributes of the following types: * Signed and unsigned 24, 40, 48, 56-bit integers. * float and double. * A named enum. * A struct. * 8-bit and 16-bit signed and unsigned integers with min/max values set. Other sizes don't have min/max support yet. * Nullable versions of all of the above. This should hopefully let us start trying to write yaml tests for these things so we can figure out which parts work and which parts don't work. Other changes needed to make the above successfully go through codegen and generate code that compiles: * Add type mappings for float/double for java. * Add min/max definitions (set to -Infinity and Infinity) for float/double in chip-tool. * Remove the broken StructHelper.js file, which was not correctly identifying structs, and replace its use with "if_is_struct" in the one template that uses this codepath. * Fix checking for lists in asChipCallback to actually work properly. Most code that dealt with lists checked for isList explicitly and never actually used the output of asChipCallback, but we're using it in more places now. * Add checks for the "Unsupported" chipCallback type in various templates so we can add attributes of types not supported by that machinery (doubles, floats, structs, named enums) without codegen completely failing. Some things that are known not to work: 1) A bunch of clients (command-line chip-tool, java, "old-style" python, darwin) rely on having typed read/report callback functions for all attribute types they support, and we don't have those yet for float, double, named enums, and structs. Will need followups to make those work. For now the relevant codepaths are effectively disabled by conditioning on chipCallback.name being "Unsupported", so we can try to address these types one at a time as desired. 2) The ember-compatibility-functions code for reading/writing attributes does not support float and double. Those bits would need to be added to test the float/double attributes in a meaningful way. --- .../all-clusters-common/all-clusters-app.zap | 486 +- examples/chip-tool/templates/commands.zapt | 12 +- examples/chip-tool/templates/helper.js | 6 + .../templates/reporting-commands.zapt | 6 + .../test-cluster-server.cpp | 22 + .../zap-templates/common/ClustersHelper.js | 10 +- src/app/zap-templates/common/StructHelper.js | 28 - .../common/attributes/Accessors.js | 19 +- .../templates/app/CHIPClusters-src.zapt | 2 + .../templates/app/CHIPClusters.zapt | 6 +- .../app/attributes/Accessors-src.zapt | 13 +- .../templates/app/attributes/Accessors.zapt | 5 +- .../zcl/data-model/chip/test-cluster.xml | 56 +- .../data_model/controller-clusters.zap | 480 ++ .../java/templates/CHIPClusters-JNI.zapt | 2 + .../java/templates/CHIPClustersRead-JNI.zapt | 2 + .../java/templates/CHIPReadCallbacks-src.zapt | 6 + .../java/templates/CHIPReadCallbacks.zapt | 4 + .../java/templates/ChipClusters-java.zapt | 11 +- .../ClusterInfo-read-interaction.zapt | 3 + .../ClusterInfo-write-interaction.zapt | 3 + src/controller/java/templates/helper.js | 8 + .../java/zap-generated/CHIPCallbackTypes.h | 64 + .../java/zap-generated/CHIPClusters-JNI.cpp | 2972 +++++++++-- .../zap-generated/CHIPClustersRead-JNI.cpp | 1160 ++++- .../java/zap-generated/CHIPReadCallbacks.cpp | 920 +++- .../java/zap-generated/CHIPReadCallbacks.h | 288 ++ .../chip/devicecontroller/ChipClusters.java | 774 +++ .../devicecontroller/ClusterReadMapping.java | 320 ++ .../devicecontroller/ClusterWriteMapping.java | 408 ++ .../python/chip/clusters/CHIPClusters.py | 224 + .../python/chip/clusters/Objects.py | 512 ++ .../CHIP/templates/CHIPClustersObjc-src.zapt | 3 + .../CHIP/templates/CHIPClustersObjc.zapt | 2 + .../CHIP/templates/clusters-tests.zapt | 2 + .../CHIP/zap-generated/CHIPClustersObjc.h | 208 + .../CHIP/zap-generated/CHIPClustersObjc.mm | 2652 +++++++--- .../zap-generated/endpoint_config.h | 374 +- .../app-common/zap-generated/attribute-id.h | 32 + .../zap-generated/attributes/Accessors.cpp | 1553 +++++- .../zap-generated/attributes/Accessors.h | 180 + .../zap-generated/cluster-objects.h | 352 ++ .../app-common/zap-generated/ids/Attributes.h | 128 + .../zap-generated/cluster/Commands.h | 4602 ++++++++++++++--- .../zap-generated/reporting/Commands.h | 128 + .../zap-generated/CHIPClusters.cpp | 936 ++++ .../zap-generated/CHIPClusters.h | 1488 +++--- .../lighting-app/zap-generated/CHIPClusters.h | 24 +- .../pump-app/zap-generated/CHIPClusters.h | 18 +- .../zap-generated/CHIPClusters.h | 44 +- .../thermostat/zap-generated/CHIPClusters.h | 4 +- .../tv-app/zap-generated/CHIPClusters.h | 18 +- 52 files changed, 18448 insertions(+), 3132 deletions(-) delete mode 100644 src/app/zap-templates/common/StructHelper.js diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index c982a6f1f92318..f13397106486ec 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -15502,6 +15502,21 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int24u", + "code": 7, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int32u", "code": 8, @@ -15517,6 +15532,51 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int40u", + "code": 9, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int48u", + "code": 10, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int56u", + "code": 11, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int64u", "code": 12, @@ -15562,6 +15622,21 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int24s", + "code": 15, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int32s", "code": 16, @@ -15577,6 +15652,51 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int40s", + "code": 17, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int48s", + "code": 18, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int56s", + "code": 19, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int64s", "code": 20, @@ -15622,6 +15742,36 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "float_single", + "code": 23, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "float_double", + "code": 24, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "octet_string", "code": 25, @@ -15643,7 +15793,7 @@ "mfgCode": null, "side": "server", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -15658,7 +15808,7 @@ "mfgCode": null, "side": "server", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -15673,7 +15823,7 @@ "mfgCode": null, "side": "server", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -15787,6 +15937,96 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "enum_attr", + "code": 36, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "struct", + "code": 37, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int8u", + "code": 38, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "70", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int8s", + "code": 39, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int16u", + "code": 40, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "200", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int16s", + "code": 41, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "unsupported", "code": 255, @@ -15907,6 +16147,21 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int24u", + "code": 32775, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int32u", "code": 32776, @@ -15922,6 +16177,51 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int40u", + "code": 32777, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int48u", + "code": 32778, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int56u", + "code": 32779, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int64u", "code": 32780, @@ -15967,6 +16267,21 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int24s", + "code": 32783, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int32s", "code": 32784, @@ -15982,6 +16297,51 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int40s", + "code": 32785, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int48s", + "code": 32786, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int56s", + "code": 32787, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int64s", "code": 32788, @@ -16027,6 +16387,36 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_float_single", + "code": 32791, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_float_double", + "code": 32792, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_octet_string", "code": 32793, @@ -16057,6 +16447,96 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_enum_attr", + "code": 32804, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_struct", + "code": 32805, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int8u", + "code": 32806, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "70", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int8s", + "code": 32807, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int16u", + "code": 32808, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "200", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int16s", + "code": 32809, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "ClusterRevision", "code": 65533, diff --git a/examples/chip-tool/templates/commands.zapt b/examples/chip-tool/templates/commands.zapt index 7eed05a3f98edd..c13a406326e545 100644 --- a/examples/chip-tool/templates/commands.zapt +++ b/examples/chip-tool/templates/commands.zapt @@ -429,6 +429,8 @@ private: {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} +{{! TODO: Various types (floats, structs) not supported here. }} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} /* * Attribute {{asUpperCamelCase name}} */ @@ -475,7 +477,11 @@ public: Write{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}(): ModelCommand("write") { AddArgument("attr-name", "{{asDelimitedCommand (asUpperCamelCase name)}}"); - {{#if (isString type)}} + {{#if isArray}} + // {{label}} Array parsing is not supported yet + {{else if isStruct}} + // {{label}} Struct parsing is not supported yet + {{else if (isString type)}} AddArgument("attr-value", &mValue); {{else}} AddArgument("attr-value", {{asTypeMinValue type}}, {{asTypeMaxValue type}}, &mValue); @@ -558,6 +564,7 @@ private: {{/unless}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} @@ -574,6 +581,8 @@ void registerCluster{{asUpperCamelCase name}}(Commands & commands) make_unique<{{asUpperCamelCase clusterName}}{{asUpperCamelCase name}}>(), // {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} + {{! TODO: Various types (floats, structs) not supported here. }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} make_unique(), // {{#if isWritableAttribute}} {{! No list support for writing yet. Need to figure out how to @@ -587,6 +596,7 @@ void registerCluster{{asUpperCamelCase name}}(Commands & commands) make_unique(), // {{/unless}} {{/if}} + {{/unless}} {{/chip_server_cluster_attributes}} }; diff --git a/examples/chip-tool/templates/helper.js b/examples/chip-tool/templates/helper.js index 7810306e7f80a6..c5f1f0dcae7a4d 100644 --- a/examples/chip-tool/templates/helper.js +++ b/examples/chip-tool/templates/helper.js @@ -48,6 +48,9 @@ function asTypeMinValue(type) case 'uint32_t': case 'uint64_t': return '0'; + case 'float': + case 'double': + return `-std::numeric_limits<${basicType}>::infinity`; default: error = 'asTypeMinValue: Unhandled underlying type ' + zclType + ' for original type ' + type; throw error; @@ -82,6 +85,9 @@ function asTypeMaxValue(type) case 'uint32_t': case 'uint64_t': return 'UINT' + parseInt(basicType.slice(4)) + '_MAX'; + case 'float': + case 'double': + return `std::numeric_limits<${basicType}>::infinity`; default: return 'err'; error = 'asTypeMaxValue: Unhandled underlying type ' + zclType + ' for original type ' + type; diff --git a/examples/chip-tool/templates/reporting-commands.zapt b/examples/chip-tool/templates/reporting-commands.zapt index 2995440e76ac34..6ba2e8e29b1c53 100644 --- a/examples/chip-tool/templates/reporting-commands.zapt +++ b/examples/chip-tool/templates/reporting-commands.zapt @@ -20,8 +20,10 @@ public: {{#chip_server_cluster_attributes}} {{#if isReportableAttribute}} {{#unless isList}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} delete onReport{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}Callback; {{/unless}} +{{/unless}} {{/if}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} @@ -34,8 +36,10 @@ public: {{#chip_server_cluster_attributes}} {{#if isReportableAttribute}} {{#unless isList}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} callbacksMgr.AddReportCallback(remoteId, endpointId, {{asHex parent.code 4}}, {{asHex code 4}}, onReport{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}Callback->Cancel(), BasicAttributeFilter<{{chipCallback.name}}AttributeCallback>); {{/unless}} +{{/unless}} {{/if}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} @@ -81,8 +85,10 @@ private: {{#chip_server_cluster_attributes}} {{#if isReportableAttribute}} {{#unless isList}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} chip::Callback::Callback<{{chipCallback.name}}AttributeCallback> * onReport{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}Callback = new chip::Callback::Callback<{{chipCallback.name}}AttributeCallback>(On{{chipCallback.name}}AttributeResponse, this); {{/unless}} +{{/unless}} {{/if}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} diff --git a/src/app/clusters/test-cluster-server/test-cluster-server.cpp b/src/app/clusters/test-cluster-server/test-cluster-server.cpp index dbf24cd320b9b7..a130e30ed58ef9 100644 --- a/src/app/clusters/test-cluster-server/test-cluster-server.cpp +++ b/src/app/clusters/test-cluster-server/test-cluster-server.cpp @@ -78,6 +78,8 @@ class TestAttrAccess : public AttributeAccessInterface CHIP_ERROR WriteListStructOctetStringAttribute(AttributeValueDecoder & aDecoder); CHIP_ERROR ReadListNullablesAndOptionalsStructAttribute(AttributeValueEncoder & aEncoder); CHIP_ERROR WriteListNullablesAndOptionalsStructAttribute(AttributeValueDecoder & aDecoder); + CHIP_ERROR ReadStructAttribute(AttributeValueEncoder & aEncoder); + CHIP_ERROR WriteStructAttribute(AttributeValueDecoder & aDecoder); }; TestAttrAccess gAttrAccess; @@ -85,6 +87,9 @@ uint8_t gListUint8Data[kAttributeListLength]; OctetStringData gListOctetStringData[kAttributeListLength]; OctetStringData gListOperationalCert[kAttributeListLength]; Structs::TestListStructOctet::Type listStructOctetStringData[kAttributeListLength]; +Structs::SimpleStruct::Type gStructAttributeValue = { 0, false, SimpleEnum::EMBER_ZCL_SIMPLE_ENUM_VALUE_A, + ByteSpan(), CharSpan(), BitFlags(), + 0, 0 }; CHIP_ERROR TestAttrAccess::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) { @@ -102,6 +107,9 @@ CHIP_ERROR TestAttrAccess::Read(const ConcreteReadAttributePath & aPath, Attribu case ListNullablesAndOptionalsStruct::Id: { return ReadListNullablesAndOptionalsStructAttribute(aEncoder); } + case Struct::Id: { + return ReadStructAttribute(aEncoder); + } default: { break; } @@ -126,6 +134,9 @@ CHIP_ERROR TestAttrAccess::Write(const ConcreteDataAttributePath & aPath, Attrib case ListNullablesAndOptionalsStruct::Id: { return WriteListNullablesAndOptionalsStructAttribute(aDecoder); } + case Struct::Id: { + return WriteStructAttribute(aDecoder); + } default: { break; } @@ -260,6 +271,17 @@ CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(Attribu // TODO Add yaml test case for NullablesAndOptionalsStruct list return CHIP_NO_ERROR; } + +CHIP_ERROR TestAttrAccess::ReadStructAttribute(AttributeValueEncoder & aEncoder) +{ + return aEncoder.Encode(gStructAttributeValue); +} + +CHIP_ERROR TestAttrAccess::WriteStructAttribute(AttributeValueDecoder & aDecoder) +{ + return aDecoder.Decode(gStructAttributeValue); +} + } // namespace bool emberAfTestClusterClusterTestCallback(app::CommandHandler *, const app::ConcreteCommandPath & commandPath, diff --git a/src/app/zap-templates/common/ClustersHelper.js b/src/app/zap-templates/common/ClustersHelper.js index e487a5ef29a822..a3a3b903edf2e2 100644 --- a/src/app/zap-templates/common/ClustersHelper.js +++ b/src/app/zap-templates/common/ClustersHelper.js @@ -28,7 +28,6 @@ const zclQuery = require(zapPath + 'db/query-zcl.js') const { Deferred } = require('./Deferred.js'); const ListHelper = require('./ListHelper.js'); const StringHelper = require('./StringHelper.js'); -const StructHelper = require('./StructHelper.js'); const ChipTypesHelper = require('./ChipTypesHelper.js'); // @@ -161,10 +160,16 @@ function asChipCallback(item) return { name : 'CharString', type : 'const chip::CharSpan' }; } - if (ListHelper.isList(item.type)) { + if (item.isList) { return { name : 'List', type : null }; } + if (item.isEnum) { + // Unsupported or now, until we figure out what to do for callbacks for + // strongly typed enums. + return { name : 'Unsupported', type : null }; + } + const basicType = ChipTypesHelper.asBasicType(item.chipType); switch (basicType) { case 'int8_t': @@ -179,6 +184,7 @@ function asChipCallback(item) return { name : 'Int' + basicType.replace(/[^0-9]/g, '') + 'u', type : basicType }; case 'bool': return { name : 'Boolean', type : 'bool' }; + // TODO: Add float and double default: return { name : 'Unsupported', type : null }; } diff --git a/src/app/zap-templates/common/StructHelper.js b/src/app/zap-templates/common/StructHelper.js deleted file mode 100644 index 8e37a6ba056295..00000000000000 --- a/src/app/zap-templates/common/StructHelper.js +++ /dev/null @@ -1,28 +0,0 @@ -/* - * - * Copyright (c) 2021 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. - */ - -const kType = 'STRUCT'; - -function isStruct(type) -{ - return type.toUpperCase() == kType; -} - -// -// Module exports -// -exports.isStruct = isStruct; diff --git a/src/app/zap-templates/common/attributes/Accessors.js b/src/app/zap-templates/common/attributes/Accessors.js index a3a04f8df33021..14720743e2621a 100644 --- a/src/app/zap-templates/common/attributes/Accessors.js +++ b/src/app/zap-templates/common/attributes/Accessors.js @@ -18,8 +18,10 @@ const zapPath = '../../../../../third_party/zap/repo/dist/src-electron/'; const ListHelper = require('../../common/ListHelper.js'); const StringHelper = require('../../common/StringHelper.js'); -const StructHelper = require('../../common/StructHelper.js'); +const cHelper = require(zapPath + 'generator/helper-c.js') const zclHelper = require(zapPath + 'generator/helper-zcl.js') +const templateUtil = require(zapPath + 'generator/template-util.js') +const zclUtil = require(zapPath + 'util/zcl-util.js') // Not sure what to do with EUI64 yet. const unsupportedTypes = [ 'EUI64' ]; @@ -38,10 +40,8 @@ function canHaveSimpleAccessors(attr) return false; } - if (StructHelper.isStruct(attr.type)) { - return false; - } - + // We can't check for being a struct synchronously, so that's handled manually + // in the template. if (isUnsupportedType(attr.type)) { return false; } @@ -87,9 +87,18 @@ async function accessorTraitType(type) return zclHelper.asUnderlyingZclType.call(this, type, { 'hash' : {} }); } +async function typeAsDelimitedMacro(type) +{ + const { db } = this.global; + const pkgId = await templateUtil.ensureZclPackageId(this); + const typeInfo = await zclUtil.determineType(db, type, pkgId); + return cHelper.asDelimitedMacro.call(this, typeInfo.atomicType); +} + // // Module exports // exports.canHaveSimpleAccessors = canHaveSimpleAccessors; exports.accessorGetterType = accessorGetterType; exports.accessorTraitType = accessorTraitType; +exports.typeAsDelimitedMacro = typeAsDelimitedMacro; diff --git a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt index 5c49b83443ec4d..1535aa26d47817 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt @@ -76,6 +76,7 @@ exit: {{/chip_cluster_commands}} // {{asUpperCamelCase name}} Cluster Attributes {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} CHIP_ERROR {{asUpperCamelCase parent.name}}Cluster::ReadAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { app::AttributePathParams attributePath; @@ -115,6 +116,7 @@ CHIP_ERROR {{asUpperCamelCase parent.name}}Cluster::ReportAttribute{{asUpperCame {{/unless}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} diff --git a/src/app/zap-templates/templates/app/CHIPClusters.zapt b/src/app/zap-templates/templates/app/CHIPClusters.zapt index 77da2fa5450716..70ec1ed8d15230 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters.zapt @@ -30,22 +30,20 @@ public: // Cluster Attributes {{#chip_server_cluster_attributes}} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} CHIP_ERROR ReadAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - {{/chip_server_cluster_attributes}} - {{#chip_server_cluster_attributes}} {{#if isWritableAttribute}} {{#unless isList}} CHIP_ERROR WriteAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, {{chipType}} value); {{/unless}} {{/if}} - {{/chip_server_cluster_attributes}} - {{#chip_server_cluster_attributes}} {{#if isReportableAttribute}} {{#unless isList}} CHIP_ERROR SubscribeAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onReportCallback); {{/unless}} {{/if}} + {{/unless}} {{/chip_server_cluster_attributes}} {{#chip_cluster_commands}} {{#first}} diff --git a/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt b/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt index 875fb489ec845d..803cda80946dc8 100644 --- a/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt +++ b/src/app/zap-templates/templates/app/attributes/Accessors-src.zapt @@ -27,7 +27,8 @@ namespace Attributes { {{/first}} {{#if clusterRef}} -{{#if (canHaveSimpleAccessors this)}} +{{#if_is_struct type}} +{{else if (canHaveSimpleAccessors this)}} namespace {{asUpperCamelCase label}} { {{#*inline "clusterId"}}Clusters::{{asUpperCamelCase parent.label}}::Id{{/inline}} @@ -92,7 +93,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value) uint8_t zclString[{{maxLength}} + {{>sizingBytes}}]; emberAfCopyInt{{#if (isShortString type)}}8{{else}}16{{/if}}u(zclString, 0, static_cast<{{>lengthType}}>(value.size())); memcpy(&zclString[{{>sizingBytes}}], value.data(), value.size()); - return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{asDelimitedMacro type}}_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE); {{else}} if (!NumericAttributeTraits<{{accessorTraitType type}}>::CanRepresentValue(/* isNullable = */ {{isNullable}}, value)) { @@ -101,7 +102,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value) NumericAttributeTraits<{{accessorTraitType type}}>::StorageType storageValue; NumericAttributeTraits<{{accessorTraitType type}}>::WorkingToStorage(value, storageValue); uint8_t * writable = NumericAttributeTraits<{{accessorTraitType type}}>::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{asDelimitedMacro type}}_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE); {{/if}} } @@ -110,12 +111,12 @@ EmberAfStatus SetNull(chip::EndpointId endpoint) { {{#if (isString type)}} uint8_t zclString[{{>sizingBytes}}] = { {{#if (isShortString type)}}0xFF{{else}}0xFF, 0xFF{{/if}} }; - return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{asDelimitedMacro type}}_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, zclString, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE); {{else}} NumericAttributeTraits<{{accessorTraitType type}}>::StorageType value; NumericAttributeTraits<{{accessorTraitType type}}>::SetNull(value); uint8_t * writable = NumericAttributeTraits<{{accessorTraitType type}}>::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{asDelimitedMacro type}}_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, {{>clusterId}}, Id, writable, ZCL_{{typeAsDelimitedMacro type}}_ATTRIBUTE_TYPE); {{/if}} } @@ -131,7 +132,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable<{{asUnder } // namespace {{asUpperCamelCase label}} -{{/if}} +{{/if_is_struct}} {{/if}} {{#last}} } // namespace Attributes diff --git a/src/app/zap-templates/templates/app/attributes/Accessors.zapt b/src/app/zap-templates/templates/app/attributes/Accessors.zapt index f8c7147620e642..64bbda59b04337 100644 --- a/src/app/zap-templates/templates/app/attributes/Accessors.zapt +++ b/src/app/zap-templates/templates/app/attributes/Accessors.zapt @@ -24,7 +24,8 @@ namespace Attributes { {{/first}} {{#if clusterRef}} -{{#if (canHaveSimpleAccessors this)}} +{{#if_is_struct type}} +{{else if (canHaveSimpleAccessors this)}} namespace {{asUpperCamelCase label}} { EmberAfStatus Get(chip::EndpointId endpoint, {{accessorGetterType this}} value); // {{type}} {{isArray}} EmberAfStatus Set(chip::EndpointId endpoint, {{asUnderlyingZclType type}} value); @@ -34,7 +35,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable<{{asUnder {{/if}} } // namespace {{asUpperCamelCase label}} -{{/if}} +{{/if_is_struct}} {{/if}} {{#last}} } // namespace Attributes diff --git a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml index 78715c6b13ba2e..46a3e7a9b5eade 100644 --- a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml @@ -107,29 +107,28 @@ limitations under the License. bitmap64 int8u int16u - + int24u int32u - - - + int40u + int48u + int56u int64u int8s int16s - + int24s int32s - - - + int40s + int48s + int56s int64s enum8 enum16 - - + float_single + float_double octet_string list_int8u list_octet_string list_struct_octet_string - long_octet_string char_string long_char_string @@ -139,9 +138,12 @@ limitations under the License. writable="true" optional="false" default="0">vendor_id list_nullables_and_optionals_struct - - + enum_attr + struct + range_restricted_int8u + range_restricted_int8s + range_restricted_int16u + range_restricted_int16s nullable_boolean nullable_bitmap8 @@ -150,26 +152,32 @@ limitations under the License. nullable_bitmap64 nullable_int8u nullable_int16u - + nullable_int24u nullable_int32u - - - + nullable_int40u + nullable_int48u + nullable_int56u nullable_int64u nullable_int8s nullable_int16s - + nullable_int24s nullable_int32s - - - + nullable_int40s + nullable_int48s + nullable_int56s nullable_int64s nullable_enum8 nullable_enum16 - - + nullable_float_single + nullable_float_double nullable_octet_string nullable_char_string + nullable_enum_attr + nullable_struct + nullable_range_restricted_int8u + nullable_range_restricted_int8s + nullable_range_restricted_int16u + nullable_range_restricted_int16s unsupported diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 72ef81e0dd91d3..59782c76e42c66 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -11776,6 +11776,21 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int24u", + "code": 7, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int32u", "code": 8, @@ -11791,6 +11806,51 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int40u", + "code": 9, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int48u", + "code": 10, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int56u", + "code": 11, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int64u", "code": 12, @@ -11836,6 +11896,21 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int24s", + "code": 15, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int32s", "code": 16, @@ -11851,6 +11926,51 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "int40s", + "code": 17, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int48s", + "code": 18, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "int56s", + "code": 19, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "int64s", "code": 20, @@ -11896,6 +12016,36 @@ "maxInterval": 65344, "reportableChange": 0 }, + { + "name": "float_single", + "code": 23, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "float_double", + "code": 24, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "octet_string", "code": 25, @@ -12061,6 +12211,96 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "enum_attr", + "code": 36, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "struct", + "code": 37, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int8u", + "code": 38, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "200", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int8s", + "code": 39, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "-5", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int16u", + "code": 40, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "70000", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "range_restricted_int16s", + "code": 41, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "-5", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "unsupported", "code": 255, @@ -12181,6 +12421,21 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int24u", + "code": 32775, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int32u", "code": 32776, @@ -12196,6 +12451,51 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int40u", + "code": 32777, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int48u", + "code": 32778, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int56u", + "code": 32779, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int64u", "code": 32780, @@ -12241,6 +12541,21 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int24s", + "code": 32783, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int32s", "code": 32784, @@ -12256,6 +12571,51 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_int40s", + "code": 32785, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int48s", + "code": 32786, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_int56s", + "code": 32787, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_int64s", "code": 32788, @@ -12301,6 +12661,36 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_float_single", + "code": 32791, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_float_double", + "code": 32792, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "nullable_octet_string", "code": 32793, @@ -12331,6 +12721,96 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "nullable_enum_attr", + "code": 32804, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_struct", + "code": 32805, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int8u", + "code": 32806, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "200", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int8s", + "code": 32807, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "-5", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int16u", + "code": 32808, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "70000", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "nullable_range_restricted_int16s", + "code": 32809, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "-5", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "ClusterRevision", "code": 65533, diff --git a/src/controller/java/templates/CHIPClusters-JNI.zapt b/src/controller/java/templates/CHIPClusters-JNI.zapt index aec7ea3a5a8c7c..60463b0f244fb1 100644 --- a/src/controller/java/templates/CHIPClusters-JNI.zapt +++ b/src/controller/java/templates/CHIPClusters-JNI.zapt @@ -77,6 +77,7 @@ JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, {{asLowerCamelCase name}}) } {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#if isWritableAttribute}} {{! TODO: Lists not supported in attribute writes yet. }} {{#unless isList}} @@ -148,6 +149,7 @@ JNI_METHOD(void, {{asCamelCased ../name false}}Cluster, report{{asCamelCased nam } {{/unless}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} {{/if}} diff --git a/src/controller/java/templates/CHIPClustersRead-JNI.zapt b/src/controller/java/templates/CHIPClustersRead-JNI.zapt index 7c61a7c7a19cef..1b3bee8644f06b 100644 --- a/src/controller/java/templates/CHIPClustersRead-JNI.zapt +++ b/src/controller/java/templates/CHIPClustersRead-JNI.zapt @@ -16,6 +16,7 @@ {{#chip_client_clusters}} {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, read{{asUpperCamelCase name}}Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -48,6 +49,7 @@ JNI_METHOD(void, {{asUpperCamelCase ../name}}Cluster, read{{asUpperCamelCase nam onFailure.release(); } +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} {{/if}} \ No newline at end of file diff --git a/src/controller/java/templates/CHIPReadCallbacks-src.zapt b/src/controller/java/templates/CHIPReadCallbacks-src.zapt index b09192eb9b47a6..a18431cdd071e4 100644 --- a/src/controller/java/templates/CHIPReadCallbacks-src.zapt +++ b/src/controller/java/templates/CHIPReadCallbacks-src.zapt @@ -11,6 +11,8 @@ #include {{#chip_server_global_responses}} +{{! TODO: Add support for struct-typed attributes }} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} CHIP{{chipCallback.name}}AttributeCallback::CHIP{{chipCallback.name}}AttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback<{{chipCallback.name}}AttributeCallback>(CallbackFn, this), keepAlive(keepAlive) @@ -78,10 +80,13 @@ void CHIP{{chipCallback.name}}AttributeCallback::CallbackFn(void * context, {{ch env->CallVoidMethod(javaCallbackRef, javaMethod, valueStr.jniValue()); {{/if}} } +{{/unless}} {{/chip_server_global_responses}} {{#chip_client_clusters}} {{#chip_server_cluster_attributes}} +{{! TODO: Add support for struct-typed attributes }} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} {{! NOTE: Some of our helpers rely on broken ZAP APIs that sniff for "isArray" when we are just trying to work with the type of an array element. Fix @@ -341,6 +346,7 @@ void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallb } {{/if_in_global_responses}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} diff --git a/src/controller/java/templates/CHIPReadCallbacks.zapt b/src/controller/java/templates/CHIPReadCallbacks.zapt index 56dbebd89dccda..af0f4163ded96f 100644 --- a/src/controller/java/templates/CHIPReadCallbacks.zapt +++ b/src/controller/java/templates/CHIPReadCallbacks.zapt @@ -6,6 +6,7 @@ #include {{#chip_server_global_responses}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} class CHIP{{chipCallback.name}}AttributeCallback : public chip::Callback::Callback<{{chipCallback.name}}AttributeCallback> { public: CHIP{{chipCallback.name}}AttributeCallback(jobject javaCallback, bool keepAlive = false); @@ -25,10 +26,12 @@ private: jobject javaCallbackRef; bool keepAlive; }; +{{/unless}} {{/chip_server_global_responses}} {{#chip_client_clusters}} {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#if_in_global_responses}} {{else}} class CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback : public chip::Callback::Callback @@ -53,6 +56,7 @@ private: }; {{/if_in_global_responses}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/chip_client_clusters}} diff --git a/src/controller/java/templates/ChipClusters-java.zapt b/src/controller/java/templates/ChipClusters-java.zapt index a85fd0be71039e..798201818ae322 100644 --- a/src/controller/java/templates/ChipClusters-java.zapt +++ b/src/controller/java/templates/ChipClusters-java.zapt @@ -98,6 +98,8 @@ public class ChipClusters { {{/chip_cluster_responses}} {{#chip_server_cluster_attributes}} + {{! TODO: Add support for struct-typed attributes }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#if isList}} {{#if isStruct}} public static class {{asUpperCamelCase name}}Attribute { @@ -203,8 +205,11 @@ public class ChipClusters { } {{/if}} {{/if_in_global_responses}} + {{/unless}} {{/chip_server_cluster_attributes}} {{#chip_server_cluster_attributes}} + {{! TODO: Add support for struct-typed attributes }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} public void read{{asUpperCamelCase name}}Attribute( {{#if_in_global_responses}} @@ -235,9 +240,12 @@ public class ChipClusters { } {{/unless}} {{/if}} + {{/unless}} {{/chip_server_cluster_attributes}} {{#chip_server_cluster_attributes}} - + {{! TODO: Add support for struct-typed attributes }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} + private native void read{{asUpperCamelCase name}}Attribute(long chipClusterPtr, {{#if_in_global_responses}} {{convertAttributeCallbackTypeToJavaName chipCallback.type}}AttributeCallback callback @@ -259,6 +267,7 @@ public class ChipClusters { private native void report{{asCamelCased name false}}Attribute(long chipClusterPtr, {{convertAttributeCallbackTypeToJavaName chipCallback.type}}AttributeCallback callback); {{/unless}} {{/if}} + {{/unless}} {{/chip_server_cluster_attributes}} } {{#not_last}} diff --git a/src/controller/java/templates/ClusterInfo-read-interaction.zapt b/src/controller/java/templates/ClusterInfo-read-interaction.zapt index defb1e1ebf3418..da80b5f9a294fa 100644 --- a/src/controller/java/templates/ClusterInfo-read-interaction.zapt +++ b/src/controller/java/templates/ClusterInfo-read-interaction.zapt @@ -16,6 +16,8 @@ public class ClusterReadMapping { {{#chip_client_clusters}} Map read{{asUpperCamelCase name}}InteractionInfo = new LinkedHashMap<>(); {{#chip_server_cluster_attributes}} + {{! TODO: Add support for struct-typed attributes }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} Map read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}CommandParams = new LinkedHashMap(); InteractionInfo read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { @@ -35,6 +37,7 @@ public class ClusterReadMapping { read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}CommandParams ); read{{asUpperCamelCase ../name}}InteractionInfo.put("read{{asUpperCamelCase name}}Attribute", read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeInteractionInfo); + {{/unless}} {{/chip_server_cluster_attributes}} readAttributeMap.put("{{asLowerCamelCase name}}", read{{asUpperCamelCase name}}InteractionInfo); {{/chip_client_clusters}} diff --git a/src/controller/java/templates/ClusterInfo-write-interaction.zapt b/src/controller/java/templates/ClusterInfo-write-interaction.zapt index 9e713524d7144f..96907cae0a7381 100644 --- a/src/controller/java/templates/ClusterInfo-write-interaction.zapt +++ b/src/controller/java/templates/ClusterInfo-write-interaction.zapt @@ -16,6 +16,8 @@ public class ClusterWriteMapping { {{#chip_client_clusters}} Map write{{asUpperCamelCase name}}InteractionInfo = new LinkedHashMap<>(); {{#chip_server_cluster_attributes}} + {{! TODO: Add support for struct-typed attributes }} + {{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#if isWritableAttribute}} {{#unless isList}} Map write{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}CommandParams = new LinkedHashMap(); @@ -35,6 +37,7 @@ public class ClusterWriteMapping { write{{asUpperCamelCase ../name}}InteractionInfo.put("write{{asUpperCamelCase name}}Attribute", write{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeInteractionInfo); {{/unless}} {{/if}} + {{/unless}} {{/chip_server_cluster_attributes}} writeAttributeMap.put("{{asLowerCamelCase name}}", write{{asUpperCamelCase name}}InteractionInfo); {{/chip_client_clusters}} diff --git a/src/controller/java/templates/helper.js b/src/controller/java/templates/helper.js index 84cefc0c82475b..8fffe460fcbb70 100644 --- a/src/controller/java/templates/helper.js +++ b/src/controller/java/templates/helper.js @@ -201,6 +201,14 @@ function convertCTypeToJniSignature(cType, useBoxedTypes) return 'Ljava/lang/Integer;'; case 'Long': return 'Ljava/lang/Long;'; + case 'double': + return 'D'; + case 'Double': + return 'Ljava/lang/Double;'; + case 'float': + return 'F'; + case 'Float': + return 'Ljava/lang/Float;'; default: error = 'Unhandled Java type ' + javaType + ' for C type ' + cType; throw error; diff --git a/src/controller/java/zap-generated/CHIPCallbackTypes.h b/src/controller/java/zap-generated/CHIPCallbackTypes.h index 8be601d6d76b6c..0773055a059bb9 100644 --- a/src/controller/java/zap-generated/CHIPCallbackTypes.h +++ b/src/controller/java/zap-generated/CHIPCallbackTypes.h @@ -890,22 +890,42 @@ typedef void (*CHIPTestClusterClusterInt8uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int8u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt16uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int16u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt24uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int24u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt32uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int32u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt40uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int40u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt48uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int48u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt56uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int56u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt64uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int64u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt8sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int8s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt16sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int16s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt24sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int24s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt32sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int32s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt40sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int40s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt48sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int48s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterInt56sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Int56s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterInt64sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Int64s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterEnum8AttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Enum8::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterEnum16AttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Enum16::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterFloatSingleAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::FloatSingle::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterFloatDoubleAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::FloatDouble::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterOctetStringAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::OctetString::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterListInt8uAttributeCallbackType)( @@ -928,6 +948,18 @@ typedef void (*CHIPTestClusterClusterVendorIdAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterListNullablesAndOptionalsStructAttributeCallbackType)( void *, const chip::app::Clusters::TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType &); +typedef void (*CHIPTestClusterClusterEnumAttrAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::EnumAttr::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterStructAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::Struct::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterRangeRestrictedInt8uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterRangeRestrictedInt8sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterRangeRestrictedInt16uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterRangeRestrictedInt16sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterUnsupportedAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableBooleanAttributeCallbackType)( @@ -944,26 +976,58 @@ typedef void (*CHIPTestClusterClusterNullableInt8uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt8u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt16uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt16u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt24uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt24u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt32uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt32u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt40uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt40u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt48uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt48u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt56uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt56u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt64uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt64u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt8sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt8s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt16sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt16s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt24sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt24s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt32sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt32s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt40sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt40s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt48sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt48s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableInt56sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableInt56s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableInt64sAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableInt64s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableEnum8AttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableEnum8::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableEnum16AttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableEnum16::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableFloatSingleAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableFloatSingle::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableFloatDoubleAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableFloatDouble::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableOctetStringAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableOctetString::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterNullableCharStringAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::NullableCharString::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableEnumAttrAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableEnumAttr::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableStructAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableStruct::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableRangeRestrictedInt8uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableRangeRestrictedInt8sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableRangeRestrictedInt16uAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterNullableRangeRestrictedInt16sAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterClusterRevisionAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::ClusterRevision::TypeInfo::DecodableArgType); diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp index bfa2721834f9bc..323a90210f28c7 100644 --- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp @@ -25493,11 +25493,11 @@ JNI_METHOD(void, TestClusterCluster, reportInt16uAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt32uAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt24uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int32u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int24u::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -25530,7 +25530,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt32uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt32uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt24uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -25552,7 +25552,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt32uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt32u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt24u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -25562,7 +25562,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt32uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt24uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; std::unique_ptr onReport( @@ -25577,7 +25577,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt32uAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt32u(onReport->Cancel()); + err = cppCluster->ReportAttributeInt24u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -25585,11 +25585,11 @@ JNI_METHOD(void, TestClusterCluster, reportInt32uAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt64uAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt32uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int64u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int32u::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -25622,7 +25622,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt64uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt64uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt32uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -25644,7 +25644,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt64uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt64u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt32u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -25654,11 +25654,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt64uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -25669,7 +25669,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt64uAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt64u(onReport->Cancel()); + err = cppCluster->ReportAttributeInt32u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -25677,14 +25677,14 @@ JNI_METHOD(void, TestClusterCluster, reportInt64uAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt8sAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt40uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int8s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int40u::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -25714,7 +25714,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt8sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt8sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt40uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -25736,8 +25736,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt8sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt8s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt40u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -25746,11 +25746,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt8sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt40uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -25761,7 +25761,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt8sAttribute)(JNIEnv * env, jobject chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt8s(onReport->Cancel()); + err = cppCluster->ReportAttributeInt40u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -25769,14 +25769,14 @@ JNI_METHOD(void, TestClusterCluster, reportInt8sAttribute)(JNIEnv * env, jobject onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt16sAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt48uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int16s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int48u::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -25806,7 +25806,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt16sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt16sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt48uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -25828,7 +25828,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt16sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt16s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt48u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -25838,11 +25838,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt16sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt48uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -25853,7 +25853,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt16sAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt16s(onReport->Cancel()); + err = cppCluster->ReportAttributeInt48u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -25861,11 +25861,11 @@ JNI_METHOD(void, TestClusterCluster, reportInt16sAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt32sAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt56uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int32s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int56u::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -25898,7 +25898,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt32sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt32sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt56uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -25920,7 +25920,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt32sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt32s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt56u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -25930,11 +25930,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt32sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt56uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -25945,7 +25945,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt32sAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt32s(onReport->Cancel()); + err = cppCluster->ReportAttributeInt56u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -25953,11 +25953,11 @@ JNI_METHOD(void, TestClusterCluster, reportInt32sAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeInt64sAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt64uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int64s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int64u::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -25990,7 +25990,7 @@ JNI_METHOD(void, TestClusterCluster, writeInt64sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeInt64sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt64uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26012,7 +26012,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt64sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeInt64s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt64u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -26022,11 +26022,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeInt64sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26037,7 +26037,7 @@ JNI_METHOD(void, TestClusterCluster, reportInt64sAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeInt64s(onReport->Cancel()); + err = cppCluster->ReportAttributeInt64u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26045,11 +26045,11 @@ JNI_METHOD(void, TestClusterCluster, reportInt64sAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeEnum8Attribute) +JNI_METHOD(void, TestClusterCluster, writeInt8sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Enum8::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int8s::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); @@ -26082,7 +26082,7 @@ JNI_METHOD(void, TestClusterCluster, writeEnum8Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeEnum8Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt8sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26104,7 +26104,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeEnum8Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeEnum8(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt8s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -26114,11 +26114,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeEnum8Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26129,7 +26129,7 @@ JNI_METHOD(void, TestClusterCluster, reportEnum8Attribute)(JNIEnv * env, jobject chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeEnum8(onReport->Cancel()); + err = cppCluster->ReportAttributeInt8s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26137,11 +26137,11 @@ JNI_METHOD(void, TestClusterCluster, reportEnum8Attribute)(JNIEnv * env, jobject onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeEnum16Attribute) +JNI_METHOD(void, TestClusterCluster, writeInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Enum16::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int16s::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); @@ -26174,7 +26174,7 @@ JNI_METHOD(void, TestClusterCluster, writeEnum16Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeEnum16Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26196,7 +26196,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeEnum16Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeEnum16(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt16s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -26206,11 +26206,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeEnum16Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26221,7 +26221,7 @@ JNI_METHOD(void, TestClusterCluster, reportEnum16Attribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeEnum16(onReport->Cancel()); + err = cppCluster->ReportAttributeInt16s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26229,14 +26229,14 @@ JNI_METHOD(void, TestClusterCluster, reportEnum16Attribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeOctetStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) +JNI_METHOD(void, TestClusterCluster, writeInt24sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::OctetString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int24s::TypeInfo; TypeInfo::Type cppValue; - cppValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -26266,7 +26266,7 @@ JNI_METHOD(void, TestClusterCluster, writeOctetStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeOctetStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt24sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26288,8 +26288,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeOctetString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt24s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26298,11 +26298,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeOctetStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt24sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26313,7 +26313,7 @@ JNI_METHOD(void, TestClusterCluster, reportOctetStringAttribute)(JNIEnv * env, j chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeOctetString(onReport->Cancel()); + err = cppCluster->ReportAttributeInt24s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26321,14 +26321,14 @@ JNI_METHOD(void, TestClusterCluster, reportOctetStringAttribute)(JNIEnv * env, j onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeLongOctetStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) +JNI_METHOD(void, TestClusterCluster, writeInt32sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongOctetString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int32s::TypeInfo; TypeInfo::Type cppValue; - cppValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -26358,7 +26358,7 @@ JNI_METHOD(void, TestClusterCluster, writeLongOctetStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeLongOctetStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt32sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26380,8 +26380,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeLongOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeLongOctetString(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt32s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26390,11 +26390,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeLongOctetStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportLongOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26405,7 +26405,7 @@ JNI_METHOD(void, TestClusterCluster, reportLongOctetStringAttribute)(JNIEnv * en chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeLongOctetString(onReport->Cancel()); + err = cppCluster->ReportAttributeInt32s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26413,14 +26413,14 @@ JNI_METHOD(void, TestClusterCluster, reportLongOctetStringAttribute)(JNIEnv * en onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeCharStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) +JNI_METHOD(void, TestClusterCluster, writeInt40sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::CharString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int40s::TypeInfo; TypeInfo::Type cppValue; - cppValue = chip::JniUtfString(env, static_cast(value)).charSpan(); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -26450,7 +26450,7 @@ JNI_METHOD(void, TestClusterCluster, writeCharStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeCharStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt40sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26472,8 +26472,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeCharStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeCharString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt40s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26482,11 +26482,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeCharStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt40sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26497,7 +26497,7 @@ JNI_METHOD(void, TestClusterCluster, reportCharStringAttribute)(JNIEnv * env, jo chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeCharString(onReport->Cancel()); + err = cppCluster->ReportAttributeInt40s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26505,14 +26505,14 @@ JNI_METHOD(void, TestClusterCluster, reportCharStringAttribute)(JNIEnv * env, jo onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeLongCharStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) +JNI_METHOD(void, TestClusterCluster, writeInt48sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongCharString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int48s::TypeInfo; TypeInfo::Type cppValue; - cppValue = chip::JniUtfString(env, static_cast(value)).charSpan(); + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -26542,7 +26542,7 @@ JNI_METHOD(void, TestClusterCluster, writeLongCharStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeLongCharStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt48sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26564,8 +26564,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeLongCharStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeLongCharString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt48s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26574,11 +26574,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeLongCharStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportLongCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt48sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26589,7 +26589,7 @@ JNI_METHOD(void, TestClusterCluster, reportLongCharStringAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeLongCharString(onReport->Cancel()); + err = cppCluster->ReportAttributeInt48s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26597,11 +26597,11 @@ JNI_METHOD(void, TestClusterCluster, reportLongCharStringAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeEpochUsAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt56sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int56s::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -26634,7 +26634,7 @@ JNI_METHOD(void, TestClusterCluster, writeEpochUsAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeEpochUsAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt56sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26656,8 +26656,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeEpochUsAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeEpochUs(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeInt56s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26666,11 +26666,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeEpochUsAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportEpochUsAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt56sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26681,7 +26681,7 @@ JNI_METHOD(void, TestClusterCluster, reportEpochUsAttribute)(JNIEnv * env, jobje chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeEpochUs(onReport->Cancel()); + err = cppCluster->ReportAttributeInt56s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26689,11 +26689,11 @@ JNI_METHOD(void, TestClusterCluster, reportEpochUsAttribute)(JNIEnv * env, jobje onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeEpochSAttribute) +JNI_METHOD(void, TestClusterCluster, writeInt64sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int64s::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); @@ -26726,7 +26726,7 @@ JNI_METHOD(void, TestClusterCluster, writeEpochSAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeEpochSAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeInt64sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26748,7 +26748,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeEpochSAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeEpochS(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeInt64s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -26758,11 +26758,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeEpochSAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportEpochSAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26773,7 +26773,7 @@ JNI_METHOD(void, TestClusterCluster, reportEpochSAttribute)(JNIEnv * env, jobjec chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeEpochS(onReport->Cancel()); + err = cppCluster->ReportAttributeInt64s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26781,11 +26781,11 @@ JNI_METHOD(void, TestClusterCluster, reportEpochSAttribute)(JNIEnv * env, jobjec onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeVendorIdAttribute) +JNI_METHOD(void, TestClusterCluster, writeEnum8Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Enum8::TypeInfo; TypeInfo::Type cppValue; cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); @@ -26818,7 +26818,7 @@ JNI_METHOD(void, TestClusterCluster, writeVendorIdAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeVendorIdAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeEnum8Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26840,8 +26840,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeVendorIdAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeVendorId(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeEnum8(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26850,11 +26850,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeVendorIdAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportVendorIdAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26865,7 +26865,7 @@ JNI_METHOD(void, TestClusterCluster, reportVendorIdAttribute)(JNIEnv * env, jobj chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeVendorId(onReport->Cancel()); + err = cppCluster->ReportAttributeEnum8(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26873,14 +26873,14 @@ JNI_METHOD(void, TestClusterCluster, reportVendorIdAttribute)(JNIEnv * env, jobj onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeUnsupportedAttribute) +JNI_METHOD(void, TestClusterCluster, writeEnum16Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Enum16::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast(chip::JniReferences::GetInstance().BooleanToPrimitive(value)); + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -26910,7 +26910,7 @@ JNI_METHOD(void, TestClusterCluster, writeUnsupportedAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeUnsupportedAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeEnum16Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -26932,8 +26932,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeUnsupportedAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeUnsupported(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeEnum16(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -26942,11 +26942,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeUnsupportedAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportUnsupportedAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -26957,7 +26957,7 @@ JNI_METHOD(void, TestClusterCluster, reportUnsupportedAttribute)(JNIEnv * env, j chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeUnsupported(onReport->Cancel()); + err = cppCluster->ReportAttributeEnum16(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -26965,19 +26965,14 @@ JNI_METHOD(void, TestClusterCluster, reportUnsupportedAttribute)(JNIEnv * env, j onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableBooleanAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +JNI_METHOD(void, TestClusterCluster, writeOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBoolean::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::OctetString::TypeInfo; TypeInfo::Type cppValue; - bool valueValue; - if (value != nullptr) - { - valueValue = chip::JniReferences::GetInstance().BooleanToPrimitive(value); - } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27007,7 +27002,2190 @@ JNI_METHOD(void, TestClusterCluster, writeNullableBooleanAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableBooleanAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeOctetString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeOctetString(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeLongOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongOctetString::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeLongOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeLongOctetString(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportLongOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeLongOctetString(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::CharString::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = chip::JniUtfString(env, static_cast(value)).charSpan(); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeCharString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeCharString(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeLongCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongCharString::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = chip::JniUtfString(env, static_cast(value)).charSpan(); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeLongCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeLongCharString(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportLongCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeLongCharString(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeEpochUsAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeEpochUsAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeEpochUs(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportEpochUsAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeEpochUs(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeEpochSAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().LongToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeEpochSAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeEpochS(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportEpochSAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeEpochS(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeVendorIdAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeVendorIdAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeVendorId(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportVendorIdAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeVendorId(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeRangeRestrictedInt8u( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeRangeRestrictedInt8u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeRangeRestrictedInt8s( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeRangeRestrictedInt8s(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeRangeRestrictedInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeRangeRestrictedInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeRangeRestrictedInt16u( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportRangeRestrictedInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeRangeRestrictedInt16u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeRangeRestrictedInt16sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeRangeRestrictedInt16sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeRangeRestrictedInt16s( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportRangeRestrictedInt16sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeRangeRestrictedInt16s(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeUnsupportedAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().BooleanToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeUnsupportedAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeUnsupported(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportUnsupportedAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeUnsupported(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableBooleanAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBoolean::TypeInfo; + TypeInfo::Type cppValue; + + bool valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().BooleanToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableBooleanAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableBoolean(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableBooleanAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableBoolean(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableBitmap8Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap8::TypeInfo; + TypeInfo::Type cppValue; + + uint8_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap8Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableBitmap8(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableBitmap8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableBitmap8(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableBitmap16Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap16::TypeInfo; + TypeInfo::Type cppValue; + + uint16_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap16Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableBitmap16(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableBitmap16Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableBitmap16(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableBitmap32Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap32::TypeInfo; + TypeInfo::Type cppValue; + + uint32_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap32Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableBitmap32(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableBitmap32Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableBitmap32(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableBitmap64Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap64::TypeInfo; + TypeInfo::Type cppValue; + + uint64_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap64Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableBitmap64(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableBitmap64Attribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableBitmap64(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8u::TypeInfo; + TypeInfo::Type cppValue; + + uint8_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt8u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt8uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt8u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16u::TypeInfo; + TypeInfo::Type cppValue; + + uint16_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt16u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt16uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt16u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt24uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt24u::TypeInfo; + TypeInfo::Type cppValue; + + uint32_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt24uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt24u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt24uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt24u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt32uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32u::TypeInfo; + TypeInfo::Type cppValue; + + uint32_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt32u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt32u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt40uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt40u::TypeInfo; + TypeInfo::Type cppValue; + + uint64_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt40uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt40u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt40uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt40u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt48uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt48u::TypeInfo; + TypeInfo::Type cppValue; + + uint64_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt48uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt48u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt48uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt48u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt56uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt56u::TypeInfo; + TypeInfo::Type cppValue; + + uint64_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt56uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27029,8 +29207,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBooleanAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableBoolean(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt56u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27039,11 +29217,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBooleanAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableBooleanAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt56uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27054,7 +29232,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBooleanAttribute)(JNIEnv * en chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableBoolean(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt56u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27062,19 +29240,116 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBooleanAttribute)(JNIEnv * en onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableBitmap8Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt64uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap8::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64u::TypeInfo; TypeInfo::Type cppValue; - uint8_t valueValue; + uint64_t valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableInt64u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableInt64u(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8s::TypeInfo; + TypeInfo::Type cppValue; + + int8_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27104,7 +29379,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableBitmap8Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap8Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27126,8 +29401,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap8Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableBitmap8(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt8s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27136,11 +29411,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap8Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableBitmap8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27151,7 +29426,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap8Attribute)(JNIEnv * en chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableBitmap8(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt8s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27159,19 +29434,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap8Attribute)(JNIEnv * en onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableBitmap16Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap16::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16s::TypeInfo; TypeInfo::Type cppValue; - uint16_t valueValue; + int16_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27201,7 +29476,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableBitmap16Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap16Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27223,8 +29498,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap16Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableBitmap16(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt16s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27233,12 +29508,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap16Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableBitmap16Attribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27249,7 +29523,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap16Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableBitmap16(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt16s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27257,19 +29531,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap16Attribute) onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableBitmap32Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt24sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap32::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt24s::TypeInfo; TypeInfo::Type cppValue; - uint32_t valueValue; + int32_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27299,7 +29573,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableBitmap32Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap32Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt24sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27321,8 +29595,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap32Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableBitmap32(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt24s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27331,12 +29605,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap32Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableBitmap32Attribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt24sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27347,7 +29620,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap32Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableBitmap32(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt24s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27355,19 +29628,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap32Attribute) onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableBitmap64Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt32sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap64::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32s::TypeInfo; TypeInfo::Type cppValue; - uint64_t valueValue; + int32_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27397,7 +29670,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableBitmap64Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap64Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27419,8 +29692,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap64Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableBitmap64(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt32s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27429,12 +29702,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableBitmap64Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableBitmap64Attribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27445,7 +29717,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap64Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableBitmap64(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt32s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27453,19 +29725,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableBitmap64Attribute) onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt8uAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt40sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt40s::TypeInfo; TypeInfo::Type cppValue; - uint8_t valueValue; + int64_t valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27495,7 +29767,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt8uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt40sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27517,8 +29789,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt8u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableInt40s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -27527,11 +29799,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt8uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt40sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27542,7 +29814,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt8uAttribute)(JNIEnv * env, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt8u(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt40s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27550,19 +29822,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt8uAttribute)(JNIEnv * env, onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt16uAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt48sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt48s::TypeInfo; TypeInfo::Type cppValue; - uint16_t valueValue; + int64_t valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27592,7 +29864,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt16uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt48sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27614,7 +29886,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt16u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeNullableInt48s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -27624,11 +29896,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt16uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt48sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27639,7 +29911,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt16uAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt16u(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt48s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27647,19 +29919,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt16uAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt32uAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt56sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt56s::TypeInfo; TypeInfo::Type cppValue; - uint32_t valueValue; + int64_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27689,7 +29961,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt32uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt56sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27711,7 +29983,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt32u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeNullableInt56s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -27721,11 +29993,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt56sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27736,7 +30008,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt32uAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt32u(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt56s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27744,19 +30016,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt32uAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt64uAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableInt64sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64u::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64s::TypeInfo; TypeInfo::Type cppValue; - uint64_t valueValue; + int64_t valueValue; if (value != nullptr) { valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27786,7 +30058,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt64uAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64uAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27808,7 +30080,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64uAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt64u(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeNullableInt64s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -27818,11 +30090,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64uAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27833,7 +30105,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt64uAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt64u(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableInt64s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27841,19 +30113,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt64uAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt8sAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableEnum8Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum8::TypeInfo; TypeInfo::Type cppValue; - int8_t valueValue; + decltype(cppValue) valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + valueValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27883,7 +30155,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt8sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum8Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -27905,7 +30177,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt8s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeNullableEnum8(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -27915,11 +30187,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt8sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -27930,7 +30202,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt8sAttribute)(JNIEnv * env, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt8s(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableEnum8(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -27938,19 +30210,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt8sAttribute)(JNIEnv * env, onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt16sAttribute) +JNI_METHOD(void, TestClusterCluster, writeNullableEnum16Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum16::TypeInfo; TypeInfo::Type cppValue; - int16_t valueValue; + decltype(cppValue) valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); + valueValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -27980,7 +30252,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt16sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum16Attribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28002,7 +30274,7 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt16s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + err = cppCluster->SubscribeAttributeNullableEnum16(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( @@ -28012,11 +30284,11 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt16sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28027,7 +30299,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt16sAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt16s(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableEnum16(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28035,19 +30307,20 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt16sAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt32sAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +JNI_METHOD(void, TestClusterCluster, writeNullableOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableOctetString::TypeInfo; TypeInfo::Type cppValue; - int32_t valueValue; + chip::ByteSpan valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + valueValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() + : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -28077,7 +30350,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt32sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableOctetStringAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28099,8 +30372,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt32s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableOctetString(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28109,11 +30382,12 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt32sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28124,7 +30398,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt32sAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt32s(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableOctetString(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28132,19 +30406,20 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt32sAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableInt64sAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +JNI_METHOD(void, TestClusterCluster, writeNullableCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64s::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableCharString::TypeInfo; TypeInfo::Type cppValue; - int64_t valueValue; + chip::CharSpan valueValue; if (value != nullptr) { - valueValue = chip::JniReferences::GetInstance().LongToPrimitive(value); + valueValue = chip::JniUtfString(env, static_cast(value)).charSpan(); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() + : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -28174,7 +30449,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableInt64sAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64sAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableCharStringAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28196,8 +30471,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64sAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableInt64s(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableCharString(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28206,11 +30481,12 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableInt64sAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28221,7 +30497,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt64sAttribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableInt64s(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableCharString(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28229,17 +30505,17 @@ JNI_METHOD(void, TestClusterCluster, reportNullableInt64sAttribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableEnum8Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableRangeRestrictedInt8uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum8::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; TypeInfo::Type cppValue; - decltype(cppValue) valueValue; + uint8_t valueValue; if (value != nullptr) { - valueValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); @@ -28271,7 +30547,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableEnum8Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum8Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableRangeRestrictedInt8uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28293,8 +30569,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum8Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableEnum8(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableRangeRestrictedInt8u( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28303,7 +30579,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum8Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; std::unique_ptr onReport( @@ -28318,7 +30595,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableEnum8Attribute)(JNIEnv * env, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableEnum8(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableRangeRestrictedInt8u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28326,19 +30603,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableEnum8Attribute)(JNIEnv * env, onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableEnum16Attribute) +JNI_METHOD(void, TestClusterCluster, writeNullableRangeRestrictedInt8sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum16::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; TypeInfo::Type cppValue; - decltype(cppValue) valueValue; + int8_t valueValue; if (value != nullptr) { - valueValue = static_cast(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -28368,7 +30645,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableEnum16Attribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum16Attribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableRangeRestrictedInt8sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28390,8 +30667,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum16Attribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableEnum16(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), - static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableRangeRestrictedInt8s( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28400,11 +30677,12 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableEnum16Attribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, reportNullableRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28415,7 +30693,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableEnum16Attribute)(JNIEnv * env chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableEnum16(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableRangeRestrictedInt8s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28423,20 +30701,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableEnum16Attribute)(JNIEnv * env onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableOctetStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) +JNI_METHOD(void, TestClusterCluster, writeNullableRangeRestrictedInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableOctetString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; TypeInfo::Type cppValue; - chip::ByteSpan valueValue; + uint16_t valueValue; if (value != nullptr) { - valueValue = chip::JniByteArray(env, static_cast(value)).byteSpan(); + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() - : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -28466,7 +30743,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableOctetStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableOctetStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableRangeRestrictedInt16uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28488,8 +30765,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableOctetString(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableRangeRestrictedInt16u( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28498,12 +30775,12 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableOctetStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableOctetStringAttribute) +JNI_METHOD(void, TestClusterCluster, reportNullableRangeRestrictedInt16uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28514,7 +30791,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableOctetString(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableRangeRestrictedInt16u(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); @@ -28522,20 +30799,19 @@ JNI_METHOD(void, TestClusterCluster, reportNullableOctetStringAttribute) onReport.release(); } -JNI_METHOD(void, TestClusterCluster, writeNullableCharStringAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jstring value) +JNI_METHOD(void, TestClusterCluster, writeNullableRangeRestrictedInt16sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableCharString::TypeInfo; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; TypeInfo::Type cppValue; - chip::CharSpan valueValue; + int16_t valueValue; if (value != nullptr) { - valueValue = chip::JniUtfString(env, static_cast(value)).charSpan(); + valueValue = chip::JniReferences::GetInstance().IntegerToPrimitive(value); } - cppValue = value == nullptr ? chip::app::DataModel::Nullable() - : chip::app::DataModel::Nullable(valueValue); + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); std::unique_ptr onSuccess( Platform::New(callback), Platform::Delete); @@ -28565,7 +30841,7 @@ JNI_METHOD(void, TestClusterCluster, writeNullableCharStringAttribute) onSuccess.release(); onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, subscribeNullableCharStringAttribute) +JNI_METHOD(void, TestClusterCluster, subscribeNullableRangeRestrictedInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) { chip::DeviceLayer::StackLock lock; @@ -28587,8 +30863,8 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableCharStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->SubscribeAttributeNullableCharString(onSuccess->Cancel(), onFailure->Cancel(), - static_cast(minInterval), static_cast(maxInterval)); + err = cppCluster->SubscribeAttributeNullableRangeRestrictedInt16s( + onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), static_cast(maxInterval)); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error subscribing to attribute", err)); @@ -28597,12 +30873,12 @@ JNI_METHOD(void, TestClusterCluster, subscribeNullableCharStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, reportNullableCharStringAttribute) +JNI_METHOD(void, TestClusterCluster, reportNullableRangeRestrictedInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - std::unique_ptr onReport( - Platform::New(callback, true), Platform::Delete); + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); VerifyOrReturn(onReport.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); @@ -28613,7 +30889,7 @@ JNI_METHOD(void, TestClusterCluster, reportNullableCharStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - err = cppCluster->ReportAttributeNullableCharString(onReport->Cancel()); + err = cppCluster->ReportAttributeNullableRangeRestrictedInt16s(onReport->Cancel()); VerifyOrReturn(err == CHIP_NO_ERROR, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error registering for attribute reporting", err)); diff --git a/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp index dbe1f03f36ecc1..b3c847251245ec 100644 --- a/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp @@ -11751,6 +11751,40 @@ JNI_METHOD(void, TestClusterCluster, readInt16uAttribute)(JNIEnv * env, jobject onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readInt24uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int24u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -11785,6 +11819,108 @@ JNI_METHOD(void, TestClusterCluster, readInt32uAttribute)(JNIEnv * env, jobject onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readInt40uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int40u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readInt48uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int48u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readInt56uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int56u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -11887,6 +12023,40 @@ JNI_METHOD(void, TestClusterCluster, readInt16sAttribute)(JNIEnv * env, jobject onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readInt24sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int24s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -11921,6 +12091,108 @@ JNI_METHOD(void, TestClusterCluster, readInt32sAttribute)(JNIEnv * env, jobject onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readInt40sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int40s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readInt48sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int48s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readInt56sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Int56s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -12153,8 +12425,568 @@ JNI_METHOD(void, TestClusterCluster, readListStructOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - auto successFn = chip::Callback::Callback::FromCancelable( - onSuccess->Cancel()); + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readLongOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongOctetString::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::CharString::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readLongCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongCharString::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readEpochUsAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readEpochSAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readVendorIdAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readListNullablesAndOptionalsStructAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readRangeRestrictedInt16uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readRangeRestrictedInt16sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readUnsupportedAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readNullableBooleanAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBoolean::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readNullableBitmap8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap8::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readNullableBitmap16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap16::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readNullableBitmap32Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap32::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12165,13 +12997,13 @@ JNI_METHOD(void, TestClusterCluster, readListStructOctetStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readLongOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableBitmap64Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongOctetString::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap64::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12189,7 +13021,7 @@ JNI_METHOD(void, TestClusterCluster, readLongOctetStringAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12200,13 +13032,13 @@ JNI_METHOD(void, TestClusterCluster, readLongOctetStringAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt8uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::CharString::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12224,7 +13056,7 @@ JNI_METHOD(void, TestClusterCluster, readCharStringAttribute)(JNIEnv * env, jobj env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12235,13 +13067,13 @@ JNI_METHOD(void, TestClusterCluster, readCharStringAttribute)(JNIEnv * env, jobj onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readLongCharStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt16uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::LongCharString::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12259,7 +13091,7 @@ JNI_METHOD(void, TestClusterCluster, readLongCharStringAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12270,12 +13102,13 @@ JNI_METHOD(void, TestClusterCluster, readLongCharStringAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readEpochUsAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt24uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochUs::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt24u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12293,7 +13126,7 @@ JNI_METHOD(void, TestClusterCluster, readEpochUsAttribute)(JNIEnv * env, jobject env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12304,12 +13137,13 @@ JNI_METHOD(void, TestClusterCluster, readEpochUsAttribute)(JNIEnv * env, jobject onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readEpochSAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::EpochS::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12327,7 +13161,7 @@ JNI_METHOD(void, TestClusterCluster, readEpochSAttribute)(JNIEnv * env, jobject env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12338,13 +13172,13 @@ JNI_METHOD(void, TestClusterCluster, readEpochSAttribute)(JNIEnv * env, jobject onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readVendorIdAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt40uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::VendorId::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt40u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12362,7 +13196,7 @@ JNI_METHOD(void, TestClusterCluster, readVendorIdAttribute)(JNIEnv * env, jobjec env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12373,15 +13207,13 @@ JNI_METHOD(void, TestClusterCluster, readVendorIdAttribute)(JNIEnv * env, jobjec onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readListNullablesAndOptionalsStructAttribute) -(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt48uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt48u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12399,8 +13231,7 @@ JNI_METHOD(void, TestClusterCluster, readListNullablesAndOptionalsStructAttribut env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable( - onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12411,12 +13242,13 @@ JNI_METHOD(void, TestClusterCluster, readListNullablesAndOptionalsStructAttribut onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readUnsupportedAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt56uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::Unsupported::TypeInfo; - std::unique_ptr onSuccess( - chip::Platform::New(callback, false), chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt56u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12434,7 +13266,7 @@ JNI_METHOD(void, TestClusterCluster, readUnsupportedAttribute)(JNIEnv * env, job env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12445,13 +13277,13 @@ JNI_METHOD(void, TestClusterCluster, readUnsupportedAttribute)(JNIEnv * env, job onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableBooleanAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBoolean::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12469,7 +13301,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableBooleanAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12480,13 +13312,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableBooleanAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableBitmap8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap8::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12504,7 +13336,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap8Attribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12515,13 +13347,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap8Attribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableBitmap16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap16::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12539,7 +13371,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap16Attribute)(JNIEnv * env env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12550,13 +13382,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap16Attribute)(JNIEnv * env onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableBitmap32Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt24sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap32::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt24s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12574,7 +13406,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap32Attribute)(JNIEnv * env env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12585,13 +13417,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap32Attribute)(JNIEnv * env onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableBitmap64Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableBitmap64::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12609,7 +13441,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap64Attribute)(JNIEnv * env env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12620,13 +13452,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableBitmap64Attribute)(JNIEnv * env onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt8uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt40sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8u::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt40s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12644,7 +13476,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt8uAttribute)(JNIEnv * env, j env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12655,13 +13487,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt8uAttribute)(JNIEnv * env, j onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt16uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt48sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16u::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt48s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12679,7 +13511,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt16uAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12690,13 +13522,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt16uAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt32uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt56sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32u::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt56s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12714,7 +13546,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt32uAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12725,13 +13557,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt32uAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt64uAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64u::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12749,7 +13581,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt64uAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12760,13 +13592,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt64uAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt8sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt8s::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum8::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12784,7 +13616,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt8sAttribute)(JNIEnv * env, j env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12795,13 +13627,13 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt8sAttribute)(JNIEnv * env, j onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt16sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt16s::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum16::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12819,7 +13651,7 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt16sAttribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12830,13 +13662,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt16sAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt32sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt32s::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableOctetString::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12853,8 +13687,8 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt32sAttribute)(JNIEnv * env, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12865,13 +13699,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt32sAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableInt64sAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableCharStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableInt64s::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableCharString::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12888,8 +13724,8 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt64sAttribute)(JNIEnv * env, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12900,13 +13736,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableInt64sAttribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableEnum8Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableRangeRestrictedInt8uAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum8::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12924,7 +13762,8 @@ JNI_METHOD(void, TestClusterCluster, readNullableEnum8Attribute)(JNIEnv * env, j env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12935,13 +13774,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableEnum8Attribute)(JNIEnv * env, j onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableEnum16Attribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +JNI_METHOD(void, TestClusterCluster, readNullableRangeRestrictedInt8sAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableEnum16::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12959,7 +13800,8 @@ JNI_METHOD(void, TestClusterCluster, readNullableEnum16Attribute)(JNIEnv * env, env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); auto successFn = - chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -12970,15 +13812,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableEnum16Attribute)(JNIEnv * env, onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableOctetStringAttribute) +JNI_METHOD(void, TestClusterCluster, readNullableRangeRestrictedInt16uAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableOctetString::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -12995,8 +13837,9 @@ JNI_METHOD(void, TestClusterCluster, readNullableOctetStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - auto successFn = chip::Callback::Callback::FromCancelable( - onSuccess->Cancel()); + auto successFn = + chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( @@ -13007,15 +13850,15 @@ JNI_METHOD(void, TestClusterCluster, readNullableOctetStringAttribute) onFailure.release(); } -JNI_METHOD(void, TestClusterCluster, readNullableCharStringAttribute) +JNI_METHOD(void, TestClusterCluster, readNullableRangeRestrictedInt16sAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; - using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableCharString::TypeInfo; - std::unique_ptr - onSuccess(chip::Platform::New(callback, false), - chip::Platform::Delete); + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); VerifyOrReturn(onSuccess.get() != nullptr, chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); @@ -13032,8 +13875,9 @@ JNI_METHOD(void, TestClusterCluster, readNullableCharStringAttribute) chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); - auto successFn = chip::Callback::Callback::FromCancelable( - onSuccess->Cancel()); + auto successFn = + chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); VerifyOrReturn( diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 86610544197f0d..859131159632c4 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -5417,6 +5417,67 @@ void CHIPTestClusterNullableInt16uAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } +CHIPTestClusterNullableInt24uAttributeCallback::CHIPTestClusterNullableInt24uAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableInt24uAttributeCallback::~CHIPTestClusterNullableInt24uAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableInt24uAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPTestClusterNullableInt32uAttributeCallback::CHIPTestClusterNullableInt32uAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), @@ -5478,9 +5539,9 @@ void CHIPTestClusterNullableInt32uAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableInt64uAttributeCallback::CHIPTestClusterNullableInt64uAttributeCallback(jobject javaCallback, +CHIPTestClusterNullableInt40uAttributeCallback::CHIPTestClusterNullableInt40uAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5497,7 +5558,7 @@ CHIPTestClusterNullableInt64uAttributeCallback::CHIPTestClusterNullableInt64uAtt } } -CHIPTestClusterNullableInt64uAttributeCallback::~CHIPTestClusterNullableInt64uAttributeCallback() +CHIPTestClusterNullableInt40uAttributeCallback::~CHIPTestClusterNullableInt40uAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5508,7 +5569,7 @@ CHIPTestClusterNullableInt64uAttributeCallback::~CHIPTestClusterNullableInt64uAt env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableInt64uAttributeCallback::CallbackFn(void * context, +void CHIPTestClusterNullableInt40uAttributeCallback::CallbackFn(void * context, const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; @@ -5517,8 +5578,8 @@ void CHIPTestClusterNullableInt64uAttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5539,8 +5600,10 @@ void CHIPTestClusterNullableInt64uAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableInt8sAttributeCallback::CHIPTestClusterNullableInt8sAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +CHIPTestClusterNullableInt48uAttributeCallback::CHIPTestClusterNullableInt48uAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5556,7 +5619,7 @@ CHIPTestClusterNullableInt8sAttributeCallback::CHIPTestClusterNullableInt8sAttri } } -CHIPTestClusterNullableInt8sAttributeCallback::~CHIPTestClusterNullableInt8sAttributeCallback() +CHIPTestClusterNullableInt48uAttributeCallback::~CHIPTestClusterNullableInt48uAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5567,7 +5630,8 @@ CHIPTestClusterNullableInt8sAttributeCallback::~CHIPTestClusterNullableInt8sAttr env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableInt8sAttributeCallback::CallbackFn(void * context, const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt48uAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5575,8 +5639,8 @@ void CHIPTestClusterNullableInt8sAttributeCallback::CallbackFn(void * context, c jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5584,22 +5648,22 @@ void CHIPTestClusterNullableInt8sAttributeCallback::CallbackFn(void * context, c ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - std::string javaValueClassName = "java/lang/Integer"; - std::string javaValueCtorSignature = "(I)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), - value.Value(), javaValue); + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableInt16sAttributeCallback::CHIPTestClusterNullableInt16sAttributeCallback(jobject javaCallback, +CHIPTestClusterNullableInt56uAttributeCallback::CHIPTestClusterNullableInt56uAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5616,7 +5680,7 @@ CHIPTestClusterNullableInt16sAttributeCallback::CHIPTestClusterNullableInt16sAtt } } -CHIPTestClusterNullableInt16sAttributeCallback::~CHIPTestClusterNullableInt16sAttributeCallback() +CHIPTestClusterNullableInt56uAttributeCallback::~CHIPTestClusterNullableInt56uAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5627,8 +5691,8 @@ CHIPTestClusterNullableInt16sAttributeCallback::~CHIPTestClusterNullableInt16sAt env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableInt16sAttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt56uAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5636,8 +5700,8 @@ void CHIPTestClusterNullableInt16sAttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5645,22 +5709,22 @@ void CHIPTestClusterNullableInt16sAttributeCallback::CallbackFn(void * context, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - std::string javaValueClassName = "java/lang/Integer"; - std::string javaValueCtorSignature = "(I)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), - value.Value(), javaValue); + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableInt32sAttributeCallback::CHIPTestClusterNullableInt32sAttributeCallback(jobject javaCallback, +CHIPTestClusterNullableInt64uAttributeCallback::CHIPTestClusterNullableInt64uAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5677,7 +5741,7 @@ CHIPTestClusterNullableInt32sAttributeCallback::CHIPTestClusterNullableInt32sAtt } } -CHIPTestClusterNullableInt32sAttributeCallback::~CHIPTestClusterNullableInt32sAttributeCallback() +CHIPTestClusterNullableInt64uAttributeCallback::~CHIPTestClusterNullableInt64uAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5688,8 +5752,8 @@ CHIPTestClusterNullableInt32sAttributeCallback::~CHIPTestClusterNullableInt32sAt env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableInt32sAttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt64uAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5697,8 +5761,8 @@ void CHIPTestClusterNullableInt32sAttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5713,16 +5777,14 @@ void CHIPTestClusterNullableInt32sAttributeCallback::CallbackFn(void * context, std::string javaValueClassName = "java/lang/Long"; std::string javaValueCtorSignature = "(J)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), - value.Value(), javaValue); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableInt64sAttributeCallback::CHIPTestClusterNullableInt64sAttributeCallback(jobject javaCallback, - bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), - keepAlive(keepAlive) +CHIPTestClusterNullableInt8sAttributeCallback::CHIPTestClusterNullableInt8sAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5738,7 +5800,7 @@ CHIPTestClusterNullableInt64sAttributeCallback::CHIPTestClusterNullableInt64sAtt } } -CHIPTestClusterNullableInt64sAttributeCallback::~CHIPTestClusterNullableInt64sAttributeCallback() +CHIPTestClusterNullableInt8sAttributeCallback::~CHIPTestClusterNullableInt8sAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5749,8 +5811,7 @@ CHIPTestClusterNullableInt64sAttributeCallback::~CHIPTestClusterNullableInt64sAt env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableInt64sAttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt8sAttributeCallback::CallbackFn(void * context, const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5758,8 +5819,8 @@ void CHIPTestClusterNullableInt64sAttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5767,21 +5828,23 @@ void CHIPTestClusterNullableInt64sAttributeCallback::CallbackFn(void * context, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - std::string javaValueClassName = "java/lang/Long"; - std::string javaValueCtorSignature = "(J)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), - value.Value(), javaValue); + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableEnum8AttributeCallback::CHIPTestClusterNullableEnum8AttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +CHIPTestClusterNullableInt16sAttributeCallback::CHIPTestClusterNullableInt16sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5797,7 +5860,7 @@ CHIPTestClusterNullableEnum8AttributeCallback::CHIPTestClusterNullableEnum8Attri } } -CHIPTestClusterNullableEnum8AttributeCallback::~CHIPTestClusterNullableEnum8AttributeCallback() +CHIPTestClusterNullableInt16sAttributeCallback::~CHIPTestClusterNullableInt16sAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5808,8 +5871,8 @@ CHIPTestClusterNullableEnum8AttributeCallback::~CHIPTestClusterNullableEnum8Attr env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableEnum8AttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt16sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5817,8 +5880,8 @@ void CHIPTestClusterNullableEnum8AttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5833,15 +5896,15 @@ void CHIPTestClusterNullableEnum8AttributeCallback::CallbackFn(void * context, std::string javaValueClassName = "java/lang/Integer"; std::string javaValueCtorSignature = "(I)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableEnum16AttributeCallback::CHIPTestClusterNullableEnum16AttributeCallback(jobject javaCallback, +CHIPTestClusterNullableInt24sAttributeCallback::CHIPTestClusterNullableInt24sAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5858,7 +5921,7 @@ CHIPTestClusterNullableEnum16AttributeCallback::CHIPTestClusterNullableEnum16Att } } -CHIPTestClusterNullableEnum16AttributeCallback::~CHIPTestClusterNullableEnum16AttributeCallback() +CHIPTestClusterNullableInt24sAttributeCallback::~CHIPTestClusterNullableInt24sAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5869,8 +5932,8 @@ CHIPTestClusterNullableEnum16AttributeCallback::~CHIPTestClusterNullableEnum16At env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableEnum16AttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt24sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5878,8 +5941,8 @@ void CHIPTestClusterNullableEnum16AttributeCallback::CallbackFn(void * context, jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5887,22 +5950,22 @@ void CHIPTestClusterNullableEnum16AttributeCallback::CallbackFn(void * context, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - std::string javaValueClassName = "java/lang/Integer"; - std::string javaValueCtorSignature = "(I)V"; - chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), - value.Value(), javaValue); + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableOctetStringAttributeCallback::CHIPTestClusterNullableOctetStringAttributeCallback(jobject javaCallback, - bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), +CHIPTestClusterNullableInt32sAttributeCallback::CHIPTestClusterNullableInt32sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5919,7 +5982,7 @@ CHIPTestClusterNullableOctetStringAttributeCallback::CHIPTestClusterNullableOcte } } -CHIPTestClusterNullableOctetStringAttributeCallback::~CHIPTestClusterNullableOctetStringAttributeCallback() +CHIPTestClusterNullableInt32sAttributeCallback::~CHIPTestClusterNullableInt32sAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5930,8 +5993,8 @@ CHIPTestClusterNullableOctetStringAttributeCallback::~CHIPTestClusterNullableOct env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableOctetStringAttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt32sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5939,8 +6002,8 @@ void CHIPTestClusterNullableOctetStringAttributeCallback::CallbackFn(void * cont jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -5948,20 +6011,22 @@ void CHIPTestClusterNullableOctetStringAttributeCallback::CallbackFn(void * cont ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - chip::ByteArray javaValueByteArray(env, value.Value()); - javaValue = javaValueByteArray.jniValue(); + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } -CHIPTestClusterNullableCharStringAttributeCallback::CHIPTestClusterNullableCharStringAttributeCallback(jobject javaCallback, - bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), +CHIPTestClusterNullableInt40sAttributeCallback::CHIPTestClusterNullableInt40sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -5978,7 +6043,7 @@ CHIPTestClusterNullableCharStringAttributeCallback::CHIPTestClusterNullableCharS } } -CHIPTestClusterNullableCharStringAttributeCallback::~CHIPTestClusterNullableCharStringAttributeCallback() +CHIPTestClusterNullableInt40sAttributeCallback::~CHIPTestClusterNullableInt40sAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5989,8 +6054,8 @@ CHIPTestClusterNullableCharStringAttributeCallback::~CHIPTestClusterNullableChar env->DeleteGlobalRef(javaCallbackRef); } -void CHIPTestClusterNullableCharStringAttributeCallback::CallbackFn(void * context, - const chip::app::DataModel::Nullable & value) +void CHIPTestClusterNullableInt40sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -5998,8 +6063,8 @@ void CHIPTestClusterNullableCharStringAttributeCallback::CallbackFn(void * conte jobject javaCallbackRef; VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. javaCallbackRef = cppCallback.get()->javaCallbackRef; @@ -6007,13 +6072,680 @@ void CHIPTestClusterNullableCharStringAttributeCallback::CallbackFn(void * conte ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); jmethodID javaMethod; - err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/String;)V", &javaMethod); + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); jobject javaValue; - chip::UtfString javaValueUtfString(env, value.Value()); - javaValue = javaValueUtfString.jniValue(); + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableInt48sAttributeCallback::CHIPTestClusterNullableInt48sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableInt48sAttributeCallback::~CHIPTestClusterNullableInt48sAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableInt48sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableInt56sAttributeCallback::CHIPTestClusterNullableInt56sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableInt56sAttributeCallback::~CHIPTestClusterNullableInt56sAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableInt56sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableInt64sAttributeCallback::CHIPTestClusterNullableInt64sAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableInt64sAttributeCallback::~CHIPTestClusterNullableInt64sAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableInt64sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableEnum8AttributeCallback::CHIPTestClusterNullableEnum8AttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableEnum8AttributeCallback::~CHIPTestClusterNullableEnum8AttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableEnum8AttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableEnum16AttributeCallback::CHIPTestClusterNullableEnum16AttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableEnum16AttributeCallback::~CHIPTestClusterNullableEnum16AttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableEnum16AttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableOctetStringAttributeCallback::CHIPTestClusterNullableOctetStringAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableOctetStringAttributeCallback::~CHIPTestClusterNullableOctetStringAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableOctetStringAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "([B)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + chip::ByteArray javaValueByteArray(env, value.Value()); + javaValue = javaValueByteArray.jniValue(); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableCharStringAttributeCallback::CHIPTestClusterNullableCharStringAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableCharStringAttributeCallback::~CHIPTestClusterNullableCharStringAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableCharStringAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/String;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + chip::UtfString javaValueUtfString(env, value.Value()); + javaValue = javaValueUtfString.jniValue(); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback::CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback::~CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback::CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback::~CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback::CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback::~CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback::CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback::~CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.h b/src/controller/java/zap-generated/CHIPReadCallbacks.h index 42c1b6fd3fb3f2..df5d0d16359ef3 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.h +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.h @@ -1485,6 +1485,30 @@ class CHIPTestClusterNullableInt16uAttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableInt24uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt24uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt24uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt24uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPTestClusterNullableInt32uAttributeCallback : public chip::Callback::Callback { @@ -1509,6 +1533,78 @@ class CHIPTestClusterNullableInt32uAttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableInt40uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt40uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt40uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt40uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableInt48uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt48uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt48uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt48uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableInt56uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt56uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt56uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt56uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPTestClusterNullableInt64uAttributeCallback : public chip::Callback::Callback { @@ -1581,6 +1677,30 @@ class CHIPTestClusterNullableInt16sAttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableInt24sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt24sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt24sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt24sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPTestClusterNullableInt32sAttributeCallback : public chip::Callback::Callback { @@ -1605,6 +1725,78 @@ class CHIPTestClusterNullableInt32sAttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableInt40sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt40sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt40sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt40sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableInt48sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt48sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt48sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt48sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableInt56sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableInt56sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableInt56sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableInt56sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPTestClusterNullableInt64sAttributeCallback : public chip::Callback::Callback { @@ -1725,6 +1917,102 @@ class CHIPTestClusterNullableCharStringAttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableRangeRestrictedInt8uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableRangeRestrictedInt8sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableRangeRestrictedInt16uAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableRangeRestrictedInt16sAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPThreadNetworkDiagnosticsNeighborTableListAttributeCallback : public chip::Callback::Callback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index d7d62617896d00..a04e06e88de17f 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -11084,12 +11084,36 @@ public interface NullableInt16uAttributeCallback { void onError(Exception ex); } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + public interface NullableInt32uAttributeCallback { void onSuccess(@Nullable Long value); void onError(Exception ex); } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + public interface NullableInt64uAttributeCallback { void onSuccess(@Nullable Long value); @@ -11108,12 +11132,36 @@ public interface NullableInt16sAttributeCallback { void onError(Exception ex); } + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + public interface NullableInt32sAttributeCallback { void onSuccess(@Nullable Long value); void onError(Exception ex); } + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + } + public interface NullableInt64sAttributeCallback { void onSuccess(@Nullable Long value); @@ -11144,6 +11192,30 @@ public interface NullableCharStringAttributeCallback { void onError(Exception ex); } + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + } + + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + } + + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + } + + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + } + public void readBooleanAttribute(BooleanAttributeCallback callback) { readBooleanAttribute(chipClusterPtr, callback); } @@ -11263,6 +11335,23 @@ public void reportInt16uAttribute(IntegerAttributeCallback callback) { reportInt16uAttribute(chipClusterPtr, callback); } + public void readInt24uAttribute(LongAttributeCallback callback) { + readInt24uAttribute(chipClusterPtr, callback); + } + + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { + writeInt24uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt24uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt24uAttribute(LongAttributeCallback callback) { + reportInt24uAttribute(chipClusterPtr, callback); + } + public void readInt32uAttribute(LongAttributeCallback callback) { readInt32uAttribute(chipClusterPtr, callback); } @@ -11280,6 +11369,57 @@ public void reportInt32uAttribute(LongAttributeCallback callback) { reportInt32uAttribute(chipClusterPtr, callback); } + public void readInt40uAttribute(LongAttributeCallback callback) { + readInt40uAttribute(chipClusterPtr, callback); + } + + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { + writeInt40uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt40uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt40uAttribute(LongAttributeCallback callback) { + reportInt40uAttribute(chipClusterPtr, callback); + } + + public void readInt48uAttribute(LongAttributeCallback callback) { + readInt48uAttribute(chipClusterPtr, callback); + } + + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { + writeInt48uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt48uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt48uAttribute(LongAttributeCallback callback) { + reportInt48uAttribute(chipClusterPtr, callback); + } + + public void readInt56uAttribute(LongAttributeCallback callback) { + readInt56uAttribute(chipClusterPtr, callback); + } + + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { + writeInt56uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt56uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt56uAttribute(LongAttributeCallback callback) { + reportInt56uAttribute(chipClusterPtr, callback); + } + public void readInt64uAttribute(LongAttributeCallback callback) { readInt64uAttribute(chipClusterPtr, callback); } @@ -11331,6 +11471,23 @@ public void reportInt16sAttribute(IntegerAttributeCallback callback) { reportInt16sAttribute(chipClusterPtr, callback); } + public void readInt24sAttribute(LongAttributeCallback callback) { + readInt24sAttribute(chipClusterPtr, callback); + } + + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { + writeInt24sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt24sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt24sAttribute(LongAttributeCallback callback) { + reportInt24sAttribute(chipClusterPtr, callback); + } + public void readInt32sAttribute(LongAttributeCallback callback) { readInt32sAttribute(chipClusterPtr, callback); } @@ -11348,6 +11505,57 @@ public void reportInt32sAttribute(LongAttributeCallback callback) { reportInt32sAttribute(chipClusterPtr, callback); } + public void readInt40sAttribute(LongAttributeCallback callback) { + readInt40sAttribute(chipClusterPtr, callback); + } + + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { + writeInt40sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt40sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt40sAttribute(LongAttributeCallback callback) { + reportInt40sAttribute(chipClusterPtr, callback); + } + + public void readInt48sAttribute(LongAttributeCallback callback) { + readInt48sAttribute(chipClusterPtr, callback); + } + + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { + writeInt48sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt48sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt48sAttribute(LongAttributeCallback callback) { + reportInt48sAttribute(chipClusterPtr, callback); + } + + public void readInt56sAttribute(LongAttributeCallback callback) { + readInt56sAttribute(chipClusterPtr, callback); + } + + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { + writeInt56sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeInt56sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportInt56sAttribute(LongAttributeCallback callback) { + reportInt56sAttribute(chipClusterPtr, callback); + } + public void readInt64sAttribute(LongAttributeCallback callback) { readInt64sAttribute(chipClusterPtr, callback); } @@ -11536,6 +11744,76 @@ public void readListNullablesAndOptionalsStructAttribute( readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } + public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { + readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { + reportRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + + public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { + readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { + reportRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + + public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { + readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { + reportRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + + public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { + readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { + reportRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + public void readUnsupportedAttribute(BooleanAttributeCallback callback) { readUnsupportedAttribute(chipClusterPtr, callback); } @@ -11679,6 +11957,24 @@ public void reportNullableInt16uAttribute(IntegerAttributeCallback callback) { reportNullableInt16uAttribute(chipClusterPtr, callback); } + public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { + readNullableInt24uAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt24uAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt24uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt24uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt24uAttribute(LongAttributeCallback callback) { + reportNullableInt24uAttribute(chipClusterPtr, callback); + } + public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { readNullableInt32uAttribute(chipClusterPtr, callback); } @@ -11697,6 +11993,60 @@ public void reportNullableInt32uAttribute(LongAttributeCallback callback) { reportNullableInt32uAttribute(chipClusterPtr, callback); } + public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { + readNullableInt40uAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt40uAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt40uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt40uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt40uAttribute(LongAttributeCallback callback) { + reportNullableInt40uAttribute(chipClusterPtr, callback); + } + + public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { + readNullableInt48uAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt48uAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt48uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt48uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt48uAttribute(LongAttributeCallback callback) { + reportNullableInt48uAttribute(chipClusterPtr, callback); + } + + public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { + readNullableInt56uAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt56uAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt56uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt56uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt56uAttribute(LongAttributeCallback callback) { + reportNullableInt56uAttribute(chipClusterPtr, callback); + } + public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { readNullableInt64uAttribute(chipClusterPtr, callback); } @@ -11751,6 +12101,24 @@ public void reportNullableInt16sAttribute(IntegerAttributeCallback callback) { reportNullableInt16sAttribute(chipClusterPtr, callback); } + public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { + readNullableInt24sAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt24sAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt24sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt24sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt24sAttribute(LongAttributeCallback callback) { + reportNullableInt24sAttribute(chipClusterPtr, callback); + } + public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { readNullableInt32sAttribute(chipClusterPtr, callback); } @@ -11769,6 +12137,60 @@ public void reportNullableInt32sAttribute(LongAttributeCallback callback) { reportNullableInt32sAttribute(chipClusterPtr, callback); } + public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { + readNullableInt40sAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt40sAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt40sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt40sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt40sAttribute(LongAttributeCallback callback) { + reportNullableInt40sAttribute(chipClusterPtr, callback); + } + + public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { + readNullableInt48sAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt48sAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt48sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt48sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt48sAttribute(LongAttributeCallback callback) { + reportNullableInt48sAttribute(chipClusterPtr, callback); + } + + public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { + readNullableInt56sAttribute(chipClusterPtr, callback); + } + + public void writeNullableInt56sAttribute( + DefaultClusterCallback callback, @Nullable Long value) { + writeNullableInt56sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableInt56sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableInt56sAttribute(LongAttributeCallback callback) { + reportNullableInt56sAttribute(chipClusterPtr, callback); + } + public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { readNullableInt64sAttribute(chipClusterPtr, callback); } @@ -11859,6 +12281,86 @@ public void reportNullableCharStringAttribute(CharStringAttributeCallback callba reportNullableCharStringAttribute(chipClusterPtr, callback); } + public void readNullableRangeRestrictedInt8uAttribute( + NullableRangeRestrictedInt8uAttributeCallback callback) { + readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, @Nullable Integer value) { + writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { + reportNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + + public void readNullableRangeRestrictedInt8sAttribute( + NullableRangeRestrictedInt8sAttributeCallback callback) { + readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, @Nullable Integer value) { + writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { + reportNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + + public void readNullableRangeRestrictedInt16uAttribute( + NullableRangeRestrictedInt16uAttributeCallback callback) { + readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, @Nullable Integer value) { + writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { + reportNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + + public void readNullableRangeRestrictedInt16sAttribute( + NullableRangeRestrictedInt16sAttributeCallback callback) { + readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, @Nullable Integer value) { + writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { + reportNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } @@ -11952,6 +12454,16 @@ private native void subscribeInt16uAttribute( private native void reportInt16uAttribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt24uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); private native void writeInt32uAttribute( @@ -11962,6 +12474,36 @@ private native void subscribeInt32uAttribute( private native void reportInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt40uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt48uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt56uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); private native void writeInt64uAttribute( @@ -11994,6 +12536,16 @@ private native void subscribeInt16sAttribute( private native void reportInt16sAttribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt24sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); private native void writeInt32sAttribute( @@ -12004,6 +12556,36 @@ private native void subscribeInt32sAttribute( private native void reportInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt40sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt48sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Long value); + + private native void subscribeInt56sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); + private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); private native void writeInt64sAttribute( @@ -12128,6 +12710,54 @@ private native void reportVendorIdAttribute( private native void readListNullablesAndOptionalsStructAttribute( long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); + private native void readRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Integer value); + + private native void subscribeRangeRestrictedInt8uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Integer value); + + private native void subscribeRangeRestrictedInt8sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Integer value); + + private native void subscribeRangeRestrictedInt16uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Integer value); + + private native void subscribeRangeRestrictedInt16sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + private native void readUnsupportedAttribute( long chipClusterPtr, BooleanAttributeCallback callback); @@ -12224,6 +12854,18 @@ private native void subscribeNullableInt16uAttribute( private native void reportNullableInt16uAttribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readNullableInt24uAttribute( + long chipClusterPtr, NullableInt24uAttributeCallback callback); + + private native void writeNullableInt24uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt24uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt24uAttribute( + long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt32uAttribute( long chipClusterPtr, NullableInt32uAttributeCallback callback); @@ -12236,6 +12878,42 @@ private native void subscribeNullableInt32uAttribute( private native void reportNullableInt32uAttribute( long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt40uAttribute( + long chipClusterPtr, NullableInt40uAttributeCallback callback); + + private native void writeNullableInt40uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt40uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt40uAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void readNullableInt48uAttribute( + long chipClusterPtr, NullableInt48uAttributeCallback callback); + + private native void writeNullableInt48uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt48uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt48uAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void readNullableInt56uAttribute( + long chipClusterPtr, NullableInt56uAttributeCallback callback); + + private native void writeNullableInt56uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt56uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt56uAttribute( + long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt64uAttribute( long chipClusterPtr, NullableInt64uAttributeCallback callback); @@ -12272,6 +12950,18 @@ private native void subscribeNullableInt16sAttribute( private native void reportNullableInt16sAttribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readNullableInt24sAttribute( + long chipClusterPtr, NullableInt24sAttributeCallback callback); + + private native void writeNullableInt24sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt24sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt24sAttribute( + long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt32sAttribute( long chipClusterPtr, NullableInt32sAttributeCallback callback); @@ -12284,6 +12974,42 @@ private native void subscribeNullableInt32sAttribute( private native void reportNullableInt32sAttribute( long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt40sAttribute( + long chipClusterPtr, NullableInt40sAttributeCallback callback); + + private native void writeNullableInt40sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt40sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt40sAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void readNullableInt48sAttribute( + long chipClusterPtr, NullableInt48sAttributeCallback callback); + + private native void writeNullableInt48sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt48sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt48sAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void readNullableInt56sAttribute( + long chipClusterPtr, NullableInt56sAttributeCallback callback); + + private native void writeNullableInt56sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Long value); + + private native void subscribeNullableInt56sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableInt56sAttribute( + long chipClusterPtr, LongAttributeCallback callback); + private native void readNullableInt64sAttribute( long chipClusterPtr, NullableInt64sAttributeCallback callback); @@ -12344,6 +13070,54 @@ private native void subscribeNullableCharStringAttribute( private native void reportNullableCharStringAttribute( long chipClusterPtr, CharStringAttributeCallback callback); + private native void readNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer value); + + private native void subscribeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer value); + + private native void subscribeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer value); + + private native void subscribeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void readNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer value); + + private native void subscribeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + private native void readClusterRevisionAttribute( long chipClusterPtr, IntegerAttributeCallback callback); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 6fd0677571103f..4460a1f84597d8 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -4368,6 +4368,18 @@ public Map> getReadAttributeMap() { readTestClusterInt16uCommandParams); readTestClusterInteractionInfo.put( "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); Map readTestClusterInt32uCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterInt32uAttributeInteractionInfo = @@ -4380,6 +4392,42 @@ public Map> getReadAttributeMap() { readTestClusterInt32uCommandParams); readTestClusterInteractionInfo.put( "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); Map readTestClusterInt64uCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterInt64uAttributeInteractionInfo = @@ -4416,6 +4464,18 @@ public Map> getReadAttributeMap() { readTestClusterInt16sCommandParams); readTestClusterInteractionInfo.put( "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); Map readTestClusterInt32sCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterInt32sAttributeInteractionInfo = @@ -4428,6 +4488,42 @@ public Map> getReadAttributeMap() { readTestClusterInt32sCommandParams); readTestClusterInteractionInfo.put( "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); Map readTestClusterInt64sCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterInt64sAttributeInteractionInfo = @@ -4608,6 +4704,62 @@ public Map> getReadAttributeMap() { readTestClusterInteractionInfo.put( "readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8uAttribute", + readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8sAttribute", + readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16uAttribute", + readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16sAttribute", + readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = @@ -4711,6 +4863,19 @@ public Map> getReadAttributeMap() { readTestClusterNullableInt16uCommandParams); readTestClusterInteractionInfo.put( "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24uAttribute( + (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = @@ -4724,6 +4889,45 @@ public Map> getReadAttributeMap() { readTestClusterNullableInt32uCommandParams); readTestClusterInteractionInfo.put( "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40uAttribute( + (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48uAttribute( + (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56uAttribute( + (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = @@ -4763,6 +4967,19 @@ public Map> getReadAttributeMap() { readTestClusterNullableInt16sCommandParams); readTestClusterInteractionInfo.put( "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24sAttribute( + (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = @@ -4776,6 +4993,45 @@ public Map> getReadAttributeMap() { readTestClusterNullableInt32sCommandParams); readTestClusterInteractionInfo.put( "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40sAttribute( + (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48sAttribute( + (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56sAttribute( + (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTestClusterNullableInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = @@ -4845,6 +5101,70 @@ public Map> getReadAttributeMap() { readTestClusterInteractionInfo.put( "readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8uAttribute", + readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8sAttribute", + readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16uAttribute", + readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16sAttribute", + readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index 4955c3f1e16f10..d7317a01460b36 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -909,6 +909,22 @@ public Map> getWriteAttributeMap() { writeTestClusterInt16uCommandParams); writeTestClusterInteractionInfo.put( "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); CommandParameterInfo testClusterint32uCommandParameterInfo = @@ -925,6 +941,54 @@ public Map> getWriteAttributeMap() { writeTestClusterInt32uCommandParams); writeTestClusterInteractionInfo.put( "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); CommandParameterInfo testClusterint64uCommandParameterInfo = @@ -973,6 +1037,22 @@ public Map> getWriteAttributeMap() { writeTestClusterInt16sCommandParams); writeTestClusterInteractionInfo.put( "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); CommandParameterInfo testClusterint32sCommandParameterInfo = @@ -989,6 +1069,54 @@ public Map> getWriteAttributeMap() { writeTestClusterInt32sCommandParams); writeTestClusterInteractionInfo.put( "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); CommandParameterInfo testClusterint64sCommandParameterInfo = @@ -1152,6 +1280,78 @@ public Map> getWriteAttributeMap() { writeTestClusterVendorIdCommandParams); writeTestClusterInteractionInfo.put( "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put( + "value", testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8uAttribute", + writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put( + "value", testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8sAttribute", + writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put( + "value", testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16uAttribute", + writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put( + "value", testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16sAttribute", + writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); CommandParameterInfo testClusterunsupportedCommandParameterInfo = @@ -1288,6 +1488,23 @@ public Map> getWriteAttributeMap() { writeTestClusterNullableInt16uCommandParams); writeTestClusterInteractionInfo.put( "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt24uCommandParams.put( + "value", testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); CommandParameterInfo testClusternullableInt32uCommandParameterInfo = @@ -1305,6 +1522,57 @@ public Map> getWriteAttributeMap() { writeTestClusterNullableInt32uCommandParams); writeTestClusterInteractionInfo.put( "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt40uCommandParams.put( + "value", testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt48uCommandParams.put( + "value", testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt56uCommandParams.put( + "value", testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); CommandParameterInfo testClusternullableInt64uCommandParameterInfo = @@ -1356,6 +1624,23 @@ public Map> getWriteAttributeMap() { writeTestClusterNullableInt16sCommandParams); writeTestClusterInteractionInfo.put( "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt24sCommandParams.put( + "value", testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); CommandParameterInfo testClusternullableInt32sCommandParameterInfo = @@ -1373,6 +1658,57 @@ public Map> getWriteAttributeMap() { writeTestClusterNullableInt32sCommandParams); writeTestClusterInteractionInfo.put( "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt40sCommandParams.put( + "value", testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt48sCommandParams.put( + "value", testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = + new CommandParameterInfo("value", long.class); + writeTestClusterNullableInt56sCommandParams.put( + "value", testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); CommandParameterInfo testClusternullableInt64sCommandParameterInfo = @@ -1460,6 +1796,78 @@ public Map> getWriteAttributeMap() { writeTestClusterInteractionInfo.put( "writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( + "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8uAttribute", + writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( + "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8sAttribute", + writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( + "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16uAttribute", + writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", int.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( + "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16sAttribute", + writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); Map writeThermostatInteractionInfo = new LinkedHashMap<>(); Map writeThermostatOccupiedCoolingSetpointCommandParams = diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index f23de9067db3fd..c97cea41b998f2 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -3826,6 +3826,13 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00000007: { + "attributeName": "Int24u", + "attributeId": 0x00000007, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00000008: { "attributeName": "Int32u", "attributeId": 0x00000008, @@ -3833,6 +3840,27 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00000009: { + "attributeName": "Int40u", + "attributeId": 0x00000009, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000000A: { + "attributeName": "Int48u", + "attributeId": 0x0000000A, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000000B: { + "attributeName": "Int56u", + "attributeId": 0x0000000B, + "type": "int", + "reportable": True, + "writable": True, + }, 0x0000000C: { "attributeName": "Int64u", "attributeId": 0x0000000C, @@ -3854,6 +3882,13 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x0000000F: { + "attributeName": "Int24s", + "attributeId": 0x0000000F, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00000010: { "attributeName": "Int32s", "attributeId": 0x00000010, @@ -3861,6 +3896,27 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00000011: { + "attributeName": "Int40s", + "attributeId": 0x00000011, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000012: { + "attributeName": "Int48s", + "attributeId": 0x00000012, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000013: { + "attributeName": "Int56s", + "attributeId": 0x00000013, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00000014: { "attributeName": "Int64s", "attributeId": 0x00000014, @@ -3882,6 +3938,20 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00000017: { + "attributeName": "FloatSingle", + "attributeId": 0x00000017, + "type": "", + "reportable": True, + "writable": True, + }, + 0x00000018: { + "attributeName": "FloatDouble", + "attributeId": 0x00000018, + "type": "", + "reportable": True, + "writable": True, + }, 0x00000019: { "attributeName": "OctetString", "attributeId": 0x00000019, @@ -3958,6 +4028,48 @@ class ChipClusters: "type": "", "reportable": True, }, + 0x00000024: { + "attributeName": "EnumAttr", + "attributeId": 0x00000024, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000025: { + "attributeName": "Struct", + "attributeId": 0x00000025, + "type": "", + "reportable": True, + "writable": True, + }, + 0x00000026: { + "attributeName": "RangeRestrictedInt8u", + "attributeId": 0x00000026, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000027: { + "attributeName": "RangeRestrictedInt8s", + "attributeId": 0x00000027, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000028: { + "attributeName": "RangeRestrictedInt16u", + "attributeId": 0x00000028, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000029: { + "attributeName": "RangeRestrictedInt16s", + "attributeId": 0x00000029, + "type": "int", + "reportable": True, + "writable": True, + }, 0x000000FF: { "attributeName": "Unsupported", "attributeId": 0x000000FF, @@ -4014,6 +4126,13 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00008007: { + "attributeName": "NullableInt24u", + "attributeId": 0x00008007, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00008008: { "attributeName": "NullableInt32u", "attributeId": 0x00008008, @@ -4021,6 +4140,27 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00008009: { + "attributeName": "NullableInt40u", + "attributeId": 0x00008009, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000800A: { + "attributeName": "NullableInt48u", + "attributeId": 0x0000800A, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000800B: { + "attributeName": "NullableInt56u", + "attributeId": 0x0000800B, + "type": "int", + "reportable": True, + "writable": True, + }, 0x0000800C: { "attributeName": "NullableInt64u", "attributeId": 0x0000800C, @@ -4042,6 +4182,13 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x0000800F: { + "attributeName": "NullableInt24s", + "attributeId": 0x0000800F, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00008010: { "attributeName": "NullableInt32s", "attributeId": 0x00008010, @@ -4049,6 +4196,27 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00008011: { + "attributeName": "NullableInt40s", + "attributeId": 0x00008011, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008012: { + "attributeName": "NullableInt48s", + "attributeId": 0x00008012, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008013: { + "attributeName": "NullableInt56s", + "attributeId": 0x00008013, + "type": "int", + "reportable": True, + "writable": True, + }, 0x00008014: { "attributeName": "NullableInt64s", "attributeId": 0x00008014, @@ -4070,6 +4238,20 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00008017: { + "attributeName": "NullableFloatSingle", + "attributeId": 0x00008017, + "type": "", + "reportable": True, + "writable": True, + }, + 0x00008018: { + "attributeName": "NullableFloatDouble", + "attributeId": 0x00008018, + "type": "", + "reportable": True, + "writable": True, + }, 0x00008019: { "attributeName": "NullableOctetString", "attributeId": 0x00008019, @@ -4084,6 +4266,48 @@ class ChipClusters: "reportable": True, "writable": True, }, + 0x00008024: { + "attributeName": "NullableEnumAttr", + "attributeId": 0x00008024, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008025: { + "attributeName": "NullableStruct", + "attributeId": 0x00008025, + "type": "", + "reportable": True, + "writable": True, + }, + 0x00008026: { + "attributeName": "NullableRangeRestrictedInt8u", + "attributeId": 0x00008026, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008027: { + "attributeName": "NullableRangeRestrictedInt8s", + "attributeId": 0x00008027, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008028: { + "attributeName": "NullableRangeRestrictedInt16u", + "attributeId": 0x00008028, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00008029: { + "attributeName": "NullableRangeRestrictedInt16s", + "attributeId": 0x00008029, + "type": "int", + "reportable": True, + "writable": True, + }, 0x0000FFFD: { "attributeName": "ClusterRevision", "attributeId": 0x0000FFFD, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index d5745ee482a8b7..bc5a0ca2cf60ad 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -25054,6 +25054,22 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = None + @dataclass + class Int24u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000007 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + @dataclass class Int32u(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25070,6 +25086,54 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = None + @dataclass + class Int40u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000009 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + + @dataclass + class Int48u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000000A + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + + @dataclass + class Int56u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000000B + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + @dataclass class Int64u(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25118,6 +25182,22 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'int' = None + @dataclass + class Int24s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000000F + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + @dataclass class Int32s(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25134,6 +25214,54 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'int' = None + @dataclass + class Int40s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000011 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + + @dataclass + class Int48s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000012 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + + @dataclass + class Int56s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000013 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + @dataclass class Int64s(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25182,6 +25310,38 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = None + @dataclass + class FloatSingle(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000017 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=float) + + value: 'float' = None + + @dataclass + class FloatDouble(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000018 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=float) + + value: 'float' = None + @dataclass class OctetString(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25358,6 +25518,102 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.List[TestCluster.Structs.NullablesAndOptionalsStruct]' = None + @dataclass + class EnumAttr(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000024 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=TestCluster.Enums.SimpleEnum) + + value: 'TestCluster.Enums.SimpleEnum' = None + + @dataclass + class Struct(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000025 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=TestCluster.Structs.SimpleStruct) + + value: 'TestCluster.Structs.SimpleStruct' = None + + @dataclass + class RangeRestrictedInt8u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000026 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + + @dataclass + class RangeRestrictedInt8s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000027 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + + @dataclass + class RangeRestrictedInt16u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000028 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = None + + @dataclass + class RangeRestrictedInt16s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000029 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=int) + + value: 'int' = None + @dataclass class Unsupported(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25486,6 +25742,22 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, uint]' = None + @dataclass + class NullableInt24u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008007 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + @dataclass class NullableInt32u(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25502,6 +25774,54 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, uint]' = None + @dataclass + class NullableInt40u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008009 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + + @dataclass + class NullableInt48u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000800A + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + + @dataclass + class NullableInt56u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000800B + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + @dataclass class NullableInt64u(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25550,6 +25870,22 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, int]' = None + @dataclass + class NullableInt24s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000800F + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + @dataclass class NullableInt32s(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25566,6 +25902,54 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, int]' = None + @dataclass + class NullableInt40s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008011 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + + @dataclass + class NullableInt48s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008012 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + + @dataclass + class NullableInt56s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008013 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + @dataclass class NullableInt64s(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25614,6 +25998,38 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, uint]' = None + @dataclass + class NullableFloatSingle(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008017 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, float]) + + value: 'typing.Union[Nullable, float]' = None + + @dataclass + class NullableFloatDouble(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008018 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, float]) + + value: 'typing.Union[Nullable, float]' = None + @dataclass class NullableOctetString(ClusterAttributeDescriptor): @ChipUtility.classproperty @@ -25646,6 +26062,102 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'typing.Union[Nullable, str]' = None + @dataclass + class NullableEnumAttr(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008024 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, TestCluster.Enums.SimpleEnum]) + + value: 'typing.Union[Nullable, TestCluster.Enums.SimpleEnum]' = None + + @dataclass + class NullableStruct(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008025 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, TestCluster.Structs.SimpleStruct]) + + value: 'typing.Union[Nullable, TestCluster.Structs.SimpleStruct]' = None + + @dataclass + class NullableRangeRestrictedInt8u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008026 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + + @dataclass + class NullableRangeRestrictedInt8s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008027 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + + @dataclass + class NullableRangeRestrictedInt16u(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008028 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = None + + @dataclass + class NullableRangeRestrictedInt16s(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x050F + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00008029 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, int]) + + value: 'typing.Union[Nullable, int]' = None + @dataclass class FeatureMap(ClusterAttributeDescriptor): @ChipUtility.classproperty diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt index 875ec714f8df4d..9ffdade3e8569a 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt @@ -77,6 +77,8 @@ using namespace chip::app::Clusters; {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} +{{! TODO: Need to add support for struct-type attibutes here, and enum-typed ones }} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#*inline "attribute"}}Attribute{{asUpperCamelCase name}}{{/inline}} {{#*inline "callbackName"}} {{~#if isList~}} @@ -158,6 +160,7 @@ using namespace chip::app::Clusters; {{/unless}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} @end diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt index 2111a645f08aa5..50daa8f0b6c88a 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt @@ -37,6 +37,7 @@ NS_ASSUME_NONNULL_BEGIN {{/chip_cluster_commands}} {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} {{#*inline "attribute"}}Attribute{{asUpperCamelCase name}}{{/inline}} - (void)read{{>attribute}}WithCompletionHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))completionHandler; {{#if isWritableAttribute}} @@ -48,6 +49,7 @@ NS_ASSUME_NONNULL_BEGIN - (void) report{{>attribute}}WithResponseHandler:(void (^)({{asObjectiveCClass type parent.name}} * _Nullable value, NSError * _Nullable error))responseHandler; {{/unless}} {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} @end diff --git a/src/darwin/Framework/CHIP/templates/clusters-tests.zapt b/src/darwin/Framework/CHIP/templates/clusters-tests.zapt index f9b2ca96b9ea65..673997bacd1bf9 100644 --- a/src/darwin/Framework/CHIP/templates/clusters-tests.zapt +++ b/src/darwin/Framework/CHIP/templates/clusters-tests.zapt @@ -171,6 +171,7 @@ CHIPDevice * GetConnectedDevice() {{#unless (isStrEqual "Basic" name)}} {{#unless (isStrEqual "Thermostat" name)}} {{#chip_server_cluster_attributes}} +{{#unless (isStrEqual chipCallback.name "Unsupported")}} - (void)testSendCluster{{asUpperCamelCase parent.name}}ReadAttribute{{asUpperCamelCase name}}WithCompletionHandler { XCTestExpectation * expectation = [self expectationWithDescription:@"{{asUpperCamelCase parent.name}}ReadAttribute{{asUpperCamelCase name}}WithCompletionHandler"]; @@ -209,6 +210,7 @@ CHIPDevice * GetConnectedDevice() [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } {{/if}} +{{/unless}} {{/chip_server_cluster_attributes}} {{/unless}} {{/unless}} diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index 6417bfa862a6c0..a4ef7ac8ba2d6e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -3350,6 +3350,13 @@ NS_ASSUME_NONNULL_BEGIN responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt24uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt24uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt32uWithMinInterval:(uint16_t)minInterval @@ -3357,6 +3364,27 @@ NS_ASSUME_NONNULL_BEGIN responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeInt32uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt40uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt40uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt48uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt48uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt56uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt56uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt64uWithMinInterval:(uint16_t)minInterval @@ -3378,6 +3406,13 @@ NS_ASSUME_NONNULL_BEGIN responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt24sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt24sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt32sWithMinInterval:(uint16_t)minInterval @@ -3385,6 +3420,27 @@ NS_ASSUME_NONNULL_BEGIN responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeInt32sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt40sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt40sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt48sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt48sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeInt56sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeInt56sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeInt64sWithMinInterval:(uint16_t)minInterval @@ -3481,6 +3537,46 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + - (void)readAttributeUnsupportedWithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; @@ -3553,6 +3649,15 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableInt16uWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt24uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt24uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; @@ -3562,6 +3667,33 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableInt32uWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt40uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt40uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt48uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt48uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt56uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt56uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; @@ -3589,6 +3721,15 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableInt16sWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt24sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt24sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; @@ -3598,6 +3739,33 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableInt32sWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt40sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt40sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt48sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt48sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableInt56sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableInt56sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler; @@ -3643,6 +3811,46 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableCharStringWithResponseHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + - (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; - (void)subscribeAttributeClusterRevisionWithMinInterval:(uint16_t)minInterval diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index 94410333b0ac6d..6174ab3f5832fc 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -17317,7 +17317,7 @@ new CHIPInt16uAttributeCallbackBridge( true); } -- (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { new CHIPInt32uAttributeCallbackBridge( self.callbackQueue, @@ -17325,14 +17325,14 @@ new CHIPInt32uAttributeCallbackBridge( completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17341,7 +17341,7 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo; TypeInfo::Type cppValue; cppValue = value.unsignedIntValue; auto successFn = Callback::FromCancelable(success); @@ -17350,16 +17350,16 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeInt32uWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt24uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt32u(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeInt24u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt32uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt24uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { new CHIPInt32uAttributeCallbackBridge( self.callbackQueue, @@ -17367,27 +17367,27 @@ new CHIPInt32uAttributeCallbackBridge( responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt32u(success); + return self.cppCluster.ReportAttributeInt24u(success); }, true); } -- (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( + new CHIPInt32uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17396,53 +17396,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.unsignedLongLongValue; + cppValue = value.unsignedIntValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeInt64uWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt32uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt64u(success, failure, minInterval, maxInterval); + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt32u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt64uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt32uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt64uAttributeCallbackBridge( + new CHIPInt32uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt64u(success); + return self.cppCluster.ReportAttributeInt32u(success); }, true); } -- (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17451,53 +17451,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.charValue; + cppValue = value.unsignedLongLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeInt8sWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeInt40uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt8s(success, failure, minInterval, maxInterval); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt40u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt40uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt8sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt8s(success); + return self.cppCluster.ReportAttributeInt40u(success); }, true); } -- (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17506,53 +17506,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.shortValue; + cppValue = value.unsignedLongLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeInt16sWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt48uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt16s(success, failure, minInterval, maxInterval); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt48u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt48uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt16sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt16s(success); + return self.cppCluster.ReportAttributeInt48u(success); }, true); } -- (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17561,53 +17561,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.intValue; + cppValue = value.unsignedLongLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeInt32sWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt56uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt32s(success, failure, minInterval, maxInterval); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt56u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt32sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt56uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt32sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt32s(success); + return self.cppCluster.ReportAttributeInt56u(success); }, true); } -- (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17616,53 +17616,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.longLongValue; + cppValue = value.unsignedLongLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeInt64sWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt64uWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeInt64s(success, failure, minInterval, maxInterval); + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt64u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeInt64sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt64uWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt64sAttributeCallbackBridge( + new CHIPInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeInt64s(success); + return self.cppCluster.ReportAttributeInt64u(success); }, true); } -- (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt8uAttributeCallbackBridge( + new CHIPInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17671,53 +17671,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast>(value.unsignedCharValue); + cppValue = value.charValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeEnum8WithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt8sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnum8(success, failure, minInterval, maxInterval); + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt8s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeEnum8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt8uAttributeCallbackBridge( + new CHIPInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnum8(success); + return self.cppCluster.ReportAttributeInt8s(success); }, true); } -- (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt16uAttributeCallbackBridge( + new CHIPInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17726,54 +17726,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast>(value.unsignedShortValue); + cppValue = value.shortValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeEnum16WithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeInt16sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEnum16(success, failure, minInterval, maxInterval); + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt16s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeEnum16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt16uAttributeCallbackBridge( + new CHIPInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEnum16(success); + return self.cppCluster.ReportAttributeInt16s(success); }, true); } -- (void)readAttributeOctetStringWithCompletionHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPOctetStringAttributeCallbackBridge( + new CHIPInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17782,54 +17781,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo; TypeInfo::Type cppValue; - cppValue = [self asByteSpan:value]; + cppValue = value.intValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeOctetStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeInt24sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeOctetString(success, failure, minInterval, maxInterval); + new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt24s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt24sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPOctetStringAttributeCallbackBridge( + new CHIPInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeOctetString(success); + return self.cppCluster.ReportAttributeInt24s(success); }, true); } -- (void)readAttributeListInt8uWithCompletionHandler:(void (^)( - NSArray * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPTestClusterListInt8uListAttributeCallbackBridge( + new CHIPInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17838,108 +17836,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo; TypeInfo::Type cppValue; - { - using ListType_0 = std::remove_reference_t; - using ListMemberType_0 = ListMemberTypeGetter::Type; - if (value.count != 0) { - auto * listHolder_0 = new ListHolder(value.count); - if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { - return CHIP_ERROR_INVALID_ARGUMENT; - } - listFreer.add(listHolder_0); - for (size_t i_0 = 0; i_0 < value.count; ++i_0) { - if (![value[i_0] isKindOfClass:[NSNumber class]]) { - // Wrong kind of value. - return CHIP_ERROR_INVALID_ARGUMENT; - } - auto element_0 = (NSNumber *) value[i_0]; - listHolder_0->mList[i_0] = element_0.unsignedCharValue; - } - cppValue = ListType_0(listHolder_0->mList, value.count); - } else { - cppValue = ListType_0(); - } - } + cppValue = value.intValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)subscribeAttributeInt32sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPTestClusterListOctetStringListAttributeCallbackBridge( + new CHIPInt32sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt32s(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeInt32sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); + responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.ReportAttributeInt32s(success); + }, + true); } -- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPDefaultSuccessCallbackBridge( - self.callbackQueue, - ^(NSError * _Nullable error, id _Nullable ignored) { - completionHandler(error); - }, - ^(Cancelable * success, Cancelable * failure) { - ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; - TypeInfo::Type cppValue; - { - using ListType_0 = std::remove_reference_t; - using ListMemberType_0 = ListMemberTypeGetter::Type; - if (value.count != 0) { - auto * listHolder_0 = new ListHolder(value.count); - if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { - return CHIP_ERROR_INVALID_ARGUMENT; - } - listFreer.add(listHolder_0); - for (size_t i_0 = 0; i_0 < value.count; ++i_0) { - if (![value[i_0] isKindOfClass:[NSData class]]) { - // Wrong kind of value. - return CHIP_ERROR_INVALID_ARGUMENT; - } - auto element_0 = (NSData *) value[i_0]; - listHolder_0->mList[i_0] = [self asByteSpan:element_0]; - } - cppValue = ListType_0(listHolder_0->mList, value.count); - } else { - cppValue = ListType_0(); - } - } - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - -- (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, - NSError * _Nullable error))completionHandler -{ - new CHIPTestClusterListStructOctetStringListAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -17948,54 +17891,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo; TypeInfo::Type cppValue; - { - using ListType_0 = std::remove_reference_t; - using ListMemberType_0 = ListMemberTypeGetter::Type; - if (value.count != 0) { - auto * listHolder_0 = new ListHolder(value.count); - if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { - return CHIP_ERROR_INVALID_ARGUMENT; - } - listFreer.add(listHolder_0); - for (size_t i_0 = 0; i_0 < value.count; ++i_0) { - if (![value[i_0] isKindOfClass:[CHIPTestClusterClusterTestListStructOctet class]]) { - // Wrong kind of value. - return CHIP_ERROR_INVALID_ARGUMENT; - } - auto element_0 = (CHIPTestClusterClusterTestListStructOctet *) value[i_0]; - listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedLongLongValue; - listHolder_0->mList[i_0].operationalCert = [self asByteSpan:element_0.operationalCert]; - } - cppValue = ListType_0(listHolder_0->mList, value.count); - } else { - cppValue = ListType_0(); - } - } + cppValue = value.longLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))completionHandler +- (void)subscribeAttributeInt40sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPOctetStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt40s(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeInt40sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPInt64sAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeInt40s(success); + }, + true); +} + +- (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18004,55 +17946,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo; TypeInfo::Type cppValue; - cppValue = [self asByteSpan:value]; + cppValue = value.longLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeLongOctetStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeInt48sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLongOctetString(success, failure, minInterval, maxInterval); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt48s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeLongOctetStringWithResponseHandler:(void (^)( - NSData * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt48sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPOctetStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLongOctetString(success); + return self.cppCluster.ReportAttributeInt48s(success); }, true); } -- (void)readAttributeCharStringWithCompletionHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18061,55 +18001,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo; TypeInfo::Type cppValue; - cppValue = [self asCharSpan:value]; + cppValue = value.longLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeCharStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeInt56sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeCharString(success, failure, minInterval, maxInterval); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt56s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt56sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPCharStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeCharString(success); + return self.cppCluster.ReportAttributeInt56s(success); }, true); } -- (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPCharStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18118,54 +18056,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; + using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo; TypeInfo::Type cppValue; - cppValue = [self asCharSpan:value]; + cppValue = value.longLongValue; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeLongCharStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeInt64sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeLongCharString(success, failure, minInterval, maxInterval); + new CHIPInt64sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeInt64s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeLongCharStringWithResponseHandler:(void (^)( - NSString * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeInt64sWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPCharStringAttributeCallbackBridge( + new CHIPInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeLongCharString(success); + return self.cppCluster.ReportAttributeInt64s(success); }, true); } -- (void)readAttributeEpochUsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt64uAttributeCallbackBridge( + new CHIPInt8uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18174,53 +18111,53 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; + using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.unsignedLongLongValue; + cppValue = static_cast>(value.unsignedCharValue); auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeEpochUsWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeEnum8WithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEpochUs(success, failure, minInterval, maxInterval); + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeEnum8(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeEpochUsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeEnum8WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt64uAttributeCallbackBridge( + new CHIPInt8uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEpochUs(success); + return self.cppCluster.ReportAttributeEnum8(success); }, true); } -- (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPInt32uAttributeCallbackBridge( + new CHIPInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18229,54 +18166,54 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; + using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.unsignedIntValue; + cppValue = static_cast>(value.unsignedShortValue); auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeEpochSWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeEpochS(success, failure, minInterval, maxInterval); + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeEnum16(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeEpochSWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeEnum16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt32uAttributeCallbackBridge( + new CHIPInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeEpochS(success); + return self.cppCluster.ReportAttributeEnum16(success); }, true); } -- (void)readAttributeVendorIdWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeOctetStringWithCompletionHandler:(void (^)( + NSData * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPVendorIdAttributeCallbackBridge( + new CHIPOctetStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18285,70 +18222,1553 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; + using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo; TypeInfo::Type cppValue; - cppValue = static_cast>(value.unsignedShortValue); + cppValue = [self asByteSpan:value]; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeVendorId(success, failure, minInterval, maxInterval); + new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeOctetString(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPInt16uAttributeCallbackBridge( + new CHIPOctetStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeVendorId(success); + return self.cppCluster.ReportAttributeOctetString(success); }, true); } -- (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeListInt8uWithCompletionHandler:(void (^)( + NSArray * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPTestClusterListInt8uListAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo; + TypeInfo::Type cppValue; + { + using ListType_0 = std::remove_reference_t; + using ListMemberType_0 = ListMemberTypeGetter::Type; + if (value.count != 0) { + auto * listHolder_0 = new ListHolder(value.count); + if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { + return CHIP_ERROR_INVALID_ARGUMENT; + } + listFreer.add(listHolder_0); + for (size_t i_0 = 0; i_0 < value.count; ++i_0) { + if (![value[i_0] isKindOfClass:[NSNumber class]]) { + // Wrong kind of value. + return CHIP_ERROR_INVALID_ARGUMENT; + } + auto element_0 = (NSNumber *) value[i_0]; + listHolder_0->mList[i_0] = element_0.unsignedCharValue; + } + cppValue = ListType_0(listHolder_0->mList, value.count); + } else { + cppValue = ListType_0(); + } + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPTestClusterListOctetStringListAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo; + TypeInfo::Type cppValue; + { + using ListType_0 = std::remove_reference_t; + using ListMemberType_0 = ListMemberTypeGetter::Type; + if (value.count != 0) { + auto * listHolder_0 = new ListHolder(value.count); + if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { + return CHIP_ERROR_INVALID_ARGUMENT; + } + listFreer.add(listHolder_0); + for (size_t i_0 = 0; i_0 < value.count; ++i_0) { + if (![value[i_0] isKindOfClass:[NSData class]]) { + // Wrong kind of value. + return CHIP_ERROR_INVALID_ARGUMENT; + } + auto element_0 = (NSData *) value[i_0]; + listHolder_0->mList[i_0] = [self asByteSpan:element_0]; + } + cppValue = ListType_0(listHolder_0->mList, value.count); + } else { + cppValue = ListType_0(); + } + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPTestClusterListStructOctetStringListAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo; + TypeInfo::Type cppValue; + { + using ListType_0 = std::remove_reference_t; + using ListMemberType_0 = ListMemberTypeGetter::Type; + if (value.count != 0) { + auto * listHolder_0 = new ListHolder(value.count); + if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { + return CHIP_ERROR_INVALID_ARGUMENT; + } + listFreer.add(listHolder_0); + for (size_t i_0 = 0; i_0 < value.count; ++i_0) { + if (![value[i_0] isKindOfClass:[CHIPTestClusterClusterTestListStructOctet class]]) { + // Wrong kind of value. + return CHIP_ERROR_INVALID_ARGUMENT; + } + auto element_0 = (CHIPTestClusterClusterTestListStructOctet *) value[i_0]; + listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedLongLongValue; + listHolder_0->mList[i_0].operationalCert = [self asByteSpan:element_0.operationalCert]; + } + cppValue = ListType_0(listHolder_0->mList, value.count); + } else { + cppValue = ListType_0(); + } + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)( + NSData * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPOctetStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo; + TypeInfo::Type cppValue; + cppValue = [self asByteSpan:value]; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeLongOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPOctetStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeLongOctetString(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeLongOctetStringWithResponseHandler:(void (^)( + NSData * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPOctetStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeLongOctetString(success); + }, + true); +} + +- (void)readAttributeCharStringWithCompletionHandler:(void (^)( + NSString * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPCharStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::CharString::TypeInfo; + TypeInfo::Type cppValue; + cppValue = [self asCharSpan:value]; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeCharStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeCharString(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeCharStringWithResponseHandler:(void (^)( + NSString * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPCharStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeCharString(success); + }, + true); +} + +- (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPCharStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo; + TypeInfo::Type cppValue; + cppValue = [self asCharSpan:value]; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeLongCharStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPCharStringAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeLongCharString(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeLongCharStringWithResponseHandler:(void (^)( + NSString * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPCharStringAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeLongCharString(success); + }, + true); +} + +- (void)readAttributeEpochUsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.unsignedLongLongValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeEpochUsWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeEpochUs(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeEpochUsWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeEpochUs(success); + }, + true); +} + +- (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.unsignedIntValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeEpochSWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeEpochS(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeEpochSWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeEpochS(success); + }, + true); +} + +- (void)readAttributeVendorIdWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPVendorIdAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo; + TypeInfo::Type cppValue; + cppValue = static_cast>(value.unsignedShortValue); + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeVendorIdWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeVendorId(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeVendorIdWithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeVendorId(success); + }, + true); +} + +- (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.unsignedCharValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeRangeRestrictedInt8u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeRangeRestrictedInt8u(success); + }, + true); +} + +- (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPInt8sAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.charValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt8sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeRangeRestrictedInt8s(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPInt8sAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeRangeRestrictedInt8s(success); + }, + true); +} + +- (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.unsignedShortValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeRangeRestrictedInt16u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeRangeRestrictedInt16u(success); + }, + true); +} + +- (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPInt16sAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value + completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.shortValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeRangeRestrictedInt16s(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPInt16sAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeRangeRestrictedInt16s(success); + }, + true); +} + +- (void)readAttributeUnsupportedWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPBooleanAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.boolValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeUnsupportedWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeUnsupported(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeUnsupportedWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPBooleanAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeUnsupported(success); + }, + true); +} + +- (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableBooleanAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.boolValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableBooleanWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableBooleanAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableBoolean(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableBooleanWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableBooleanAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableBoolean(success); + }, + true); +} + +- (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedCharValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableBitmap8WithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableBitmap8(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableBitmap8WithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableBitmap8(success); + }, + true); +} + +- (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedShortValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableBitmap16WithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableBitmap16(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableBitmap16(success); + }, + true); +} + +- (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedIntValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableBitmap32WithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableBitmap32(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableBitmap32(success); + }, + true); +} + +- (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedLongLongValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableBitmap64WithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableBitmap64(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableBitmap64(success); + }, + true); +} + +- (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedCharValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt8u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt8uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt8uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableInt8u(success); + }, + true); +} + +- (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedShortValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt16uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt16u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt16uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt16uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableInt16u(success); + }, + true); +} + +- (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedIntValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt24uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt24u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt24uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableInt24u(success); + }, + true); +} + +- (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedIntValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt32uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt32u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt32uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt32uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableInt32u(success); + }, + true); +} + +- (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedLongLongValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt40uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt40u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt40uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableInt40u(success); + }, + true); +} + +- (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedLongLongValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableInt48uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt48u(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableInt48uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { - completionHandler(value, error); + responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo; - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); - }); + return self.cppCluster.ReportAttributeNullableInt48u(success); + }, + true); } -- (void)readAttributeUnsupportedWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPBooleanAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18357,55 +19777,61 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo; TypeInfo::Type cppValue; - cppValue = value.boolValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedLongLongValue; + } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)subscribeAttributeUnsupportedWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt56uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeUnsupported(success, failure, minInterval, maxInterval); - }); + new CHIPNullableInt64uAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableInt56u(success, failure, minInterval, maxInterval); + }); } -- (void)reportAttributeUnsupportedWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt56uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPBooleanAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeUnsupported(success); + return self.cppCluster.ReportAttributeNullableInt56u(success); }, true); } -- (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableBooleanAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18414,13 +19840,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.boolValue; + nonNullValue_0 = value.unsignedLongLongValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18428,47 +19854,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableBooleanWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt64uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableBooleanAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBoolean(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt64u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableBooleanWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt64uWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableBooleanAttributeCallbackBridge( + new CHIPNullableInt64uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBoolean(success); + return self.cppCluster.ReportAttributeNullableInt64u(success); }, true); } -- (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18477,13 +19903,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedCharValue; + nonNullValue_0 = value.charValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18491,47 +19917,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableBitmap8WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt8sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap8(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt8s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableBitmap8WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt8sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap8(success); + return self.cppCluster.ReportAttributeNullableInt8s(success); }, true); } -- (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18540,13 +19966,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedShortValue; + nonNullValue_0 = value.shortValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18554,47 +19980,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableBitmap16WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt16sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap16(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt16s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableBitmap16WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt16sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap16(success); + return self.cppCluster.ReportAttributeNullableInt16s(success); }, true); } -- (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18603,13 +20029,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedIntValue; + nonNullValue_0 = value.intValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18617,47 +20043,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableBitmap32WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt24sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap32(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt24s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableBitmap32WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt24sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap32(success); + return self.cppCluster.ReportAttributeNullableInt24s(success); }, true); } -- (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18666,13 +20092,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedLongLongValue; + nonNullValue_0 = value.intValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18680,47 +20106,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableBitmap64WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt32sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableBitmap64(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt32s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableBitmap64WithResponseHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt32sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt32sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableBitmap64(success); + return self.cppCluster.ReportAttributeNullableInt32s(success); }, true); } -- (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18729,13 +20155,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedCharValue; + nonNullValue_0 = value.longLongValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18743,47 +20169,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt8uWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableInt40sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt8u(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt40s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt8uWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableInt40sWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt8uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt8u(success); + return self.cppCluster.ReportAttributeNullableInt40s(success); }, true); } -- (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, +- (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18792,13 +20218,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedShortValue; + nonNullValue_0 = value.longLongValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18806,47 +20232,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt16uWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeNullableInt48sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt16u(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt48s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt16uWithResponseHandler:(void (^)( +- (void)reportAttributeNullableInt48sWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt16u(success); + return self.cppCluster.ReportAttributeNullableInt48s(success); }, true); } -- (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, +- (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18855,13 +20281,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedIntValue; + nonNullValue_0 = value.longLongValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18869,47 +20295,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt32uWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeNullableInt56sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt32u(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt56s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt32uWithResponseHandler:(void (^)( +- (void)reportAttributeNullableInt56sWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt32uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt32u(success); + return self.cppCluster.ReportAttributeNullableInt56s(success); }, true); } -- (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, +- (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18918,13 +20344,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.unsignedLongLongValue; + nonNullValue_0 = value.longLongValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18932,47 +20358,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt64uWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeNullableInt64sWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt64u(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableInt64s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt64uWithResponseHandler:(void (^)( +- (void)reportAttributeNullableInt64sWithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt64uAttributeCallbackBridge( + new CHIPNullableInt64sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt64u(success); + return self.cppCluster.ReportAttributeNullableInt64s(success); }, true); } -- (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)( +- (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt8sAttributeCallbackBridge( + new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -18981,13 +20407,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.charValue; + nonNullValue_0 = static_cast>(value.unsignedCharValue); } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -18995,47 +20421,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt8sWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeNullableEnum8WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt8sAttributeCallbackBridge( + new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt8s(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableEnum8(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt8sWithResponseHandler:(void (^)( +- (void)reportAttributeNullableEnum8WithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt8sAttributeCallbackBridge( + new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt8s(success); + return self.cppCluster.ReportAttributeNullableEnum8(success); }, true); } -- (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, +- (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler { - new CHIPNullableInt16sAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19044,13 +20470,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.shortValue; + nonNullValue_0 = static_cast>(value.unsignedShortValue); } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19058,47 +20484,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt16sWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeNullableEnum16WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt16sAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt16s(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableEnum16(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt16sWithResponseHandler:(void (^)( +- (void)reportAttributeNullableEnum16WithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler { - new CHIPNullableInt16sAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt16s(success); + return self.cppCluster.ReportAttributeNullableEnum16(success); }, true); } -- (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt32sAttributeCallbackBridge( + new CHIPNullableOctetStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19107,13 +20533,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.intValue; + nonNullValue_0 = [self asByteSpan:value]; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19121,47 +20547,47 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt32sWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableOctetStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt32sAttributeCallbackBridge( + new CHIPNullableOctetStringAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt32s(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableOctetString(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt32sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, + NSError * _Nullable error))responseHandler { - new CHIPNullableInt32sAttributeCallbackBridge( + new CHIPNullableOctetStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt32s(success); + return self.cppCluster.ReportAttributeNullableOctetString(success); }, true); } -- (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt64sAttributeCallbackBridge( + new CHIPNullableCharStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19170,13 +20596,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = value.longLongValue; + nonNullValue_0 = [self asCharSpan:value]; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19184,32 +20610,32 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableInt64sWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableCharStringWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt64sAttributeCallbackBridge( + new CHIPNullableCharStringAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableInt64s(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableCharString(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableInt64sWithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableCharStringWithResponseHandler:(void (^)(NSString * _Nullable value, + NSError * _Nullable error))responseHandler { - new CHIPNullableInt64sAttributeCallbackBridge( + new CHIPNullableCharStringAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableInt64s(success); + return self.cppCluster.ReportAttributeNullableCharString(success); }, true); } -- (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +- (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, @@ -19217,14 +20643,15 @@ new CHIPNullableInt8uAttributeCallbackBridge( completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19233,13 +20660,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = static_cast>(value.unsignedCharValue); + nonNullValue_0 = value.unsignedCharValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19247,18 +20674,18 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableEnum8WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableRangeRestrictedInt8uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableEnum8(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt8u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableEnum8WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableRangeRestrictedInt8uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler { new CHIPNullableInt8uAttributeCallbackBridge( self.callbackQueue, @@ -19266,28 +20693,29 @@ new CHIPNullableInt8uAttributeCallbackBridge( responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableEnum8(success); + return self.cppCluster.ReportAttributeNullableRangeRestrictedInt8u(success); }, true); } -- (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19296,13 +20724,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = static_cast>(value.unsignedShortValue); + nonNullValue_0 = value.charValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19310,47 +20738,48 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableEnum16WithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableRangeRestrictedInt8sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableEnum16(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt8s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableEnum16WithResponseHandler:(void (^)( - NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableRangeRestrictedInt8sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler { - new CHIPNullableInt16uAttributeCallbackBridge( + new CHIPNullableInt8sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableEnum16(success); + return self.cppCluster.ReportAttributeNullableRangeRestrictedInt8s(success); }, true); } -- (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableOctetStringAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19359,13 +20788,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = [self asByteSpan:value]; + nonNullValue_0 = value.unsignedShortValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19373,47 +20802,48 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableOctetStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableRangeRestrictedInt16uWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableOctetStringAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableOctetString(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt16u(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableOctetStringWithResponseHandler:(void (^)(NSData * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableRangeRestrictedInt16uWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler { - new CHIPNullableOctetStringAttributeCallbackBridge( + new CHIPNullableInt16uAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableOctetString(success); + return self.cppCluster.ReportAttributeNullableRangeRestrictedInt16u(success); }, true); } -- (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))completionHandler +- (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler { - new CHIPNullableCharStringAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { completionHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; - auto successFn = Callback::FromCancelable(success); + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; + auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); }); } -- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value completionHandler:(StatusCompletion)completionHandler +- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler { new CHIPDefaultSuccessCallbackBridge( self.callbackQueue, @@ -19422,13 +20852,13 @@ new CHIPDefaultSuccessCallbackBridge( }, ^(Cancelable * success, Cancelable * failure) { ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo; + using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo; TypeInfo::Type cppValue; if (value == nil) { cppValue.SetNull(); } else { auto & nonNullValue_0 = cppValue.SetNonNull(); - nonNullValue_0 = [self asCharSpan:value]; + nonNullValue_0 = value.shortValue; } auto successFn = Callback::FromCancelable(success); auto failureFn = Callback::FromCancelable(failure); @@ -19436,26 +20866,26 @@ new CHIPDefaultSuccessCallbackBridge( }); } -- (void)subscribeAttributeNullableCharStringWithMinInterval:(uint16_t)minInterval - maxInterval:(uint16_t)maxInterval - responseHandler:(ResponseHandler)responseHandler +- (void)subscribeAttributeNullableRangeRestrictedInt16sWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler { - new CHIPNullableCharStringAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.SubscribeAttributeNullableCharString(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeNullableRangeRestrictedInt16s(success, failure, minInterval, maxInterval); }); } -- (void)reportAttributeNullableCharStringWithResponseHandler:(void (^)(NSString * _Nullable value, - NSError * _Nullable error))responseHandler +- (void)reportAttributeNullableRangeRestrictedInt16sWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler { - new CHIPNullableCharStringAttributeCallbackBridge( + new CHIPNullableInt16sAttributeCallbackBridge( self.callbackQueue, ^(NSError * _Nullable error, id _Nullable value) { responseHandler(value, error); }, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ReportAttributeNullableCharString(success); + return self.cppCluster.ReportAttributeNullableRangeRestrictedInt16s(success); }, true); } diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h index e5159ecc6e8a47..9738394927b6c5 100644 --- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h +++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h @@ -536,88 +536,113 @@ /* 3281 - bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3289 - int32u, */ \ + /* 3289 - int24u, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3292 - int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3293 - int64u, */ \ + /* 3296 - int40u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3301 - int48u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3307 - int56u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3314 - int64u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3301 - int32s, */ \ + /* 3322 - int24s, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3325 - int32s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3305 - int64s, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3329 - int40s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3313 - list_int8u, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3334 - int48s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3323 - list_octet_string, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3340 - int56s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3577 - list_struct_octet_string, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3347 - int64s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3831 - epoch_us, */ \ + /* 3355 - float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3359 - float_double, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3367 - epoch_us, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3839 - epoch_s, */ \ + /* 3375 - epoch_s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3843 - nullable_bitmap32, */ \ + /* 3379 - nullable_bitmap32, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3847 - nullable_bitmap64, */ \ + /* 3383 - nullable_bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3855 - nullable_int32u, */ \ + /* 3391 - nullable_int24u, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3394 - nullable_int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3859 - nullable_int64u, */ \ + /* 3398 - nullable_int40u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3403 - nullable_int48u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3409 - nullable_int56u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3416 - nullable_int64u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3424 - nullable_int24s, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3427 - nullable_int32s, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3431 - nullable_int40s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3436 - nullable_int48s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3442 - nullable_int56s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3449 - nullable_int64s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3867 - nullable_int32s, */ \ + /* 3457 - nullable_float_single, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3871 - nullable_int64s, */ \ + /* 3461 - nullable_float_double, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server), big-endian */ \ \ - /* 3879 - measurement type, */ \ + /* 3469 - measurement type, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3883 - total active power, */ \ + /* 3473 - total active power, */ \ 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 2, Cluster: On/Off (server), big-endian */ \ \ - /* 3887 - FeatureMap, */ \ + /* 3477 - FeatureMap, */ \ 0x00, 0x00, 0x00, 0x00, \ } @@ -1134,94 +1159,119 @@ /* 3281 - bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3289 - int32u, */ \ + /* 3289 - int24u, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3292 - int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3293 - int64u, */ \ + /* 3296 - int40u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3301 - int48u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3307 - int56u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3314 - int64u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3301 - int32s, */ \ + /* 3322 - int24s, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3325 - int32s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3305 - int64s, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3329 - int40s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3313 - list_int8u, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3334 - int48s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3323 - list_octet_string, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3340 - int56s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3577 - list_struct_octet_string, */ \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + /* 3347 - int64s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3831 - epoch_us, */ \ + /* 3355 - float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3359 - float_double, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3367 - epoch_us, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3839 - epoch_s, */ \ + /* 3375 - epoch_s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3843 - nullable_bitmap32, */ \ + /* 3379 - nullable_bitmap32, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3847 - nullable_bitmap64, */ \ + /* 3383 - nullable_bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3855 - nullable_int32u, */ \ + /* 3391 - nullable_int24u, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3394 - nullable_int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3859 - nullable_int64u, */ \ + /* 3398 - nullable_int40u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3403 - nullable_int48u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3409 - nullable_int56u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3416 - nullable_int64u, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3424 - nullable_int24s, */ \ + 0x00, 0x00, 0x00, \ + \ + /* 3427 - nullable_int32s, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3431 - nullable_int40s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3436 - nullable_int48s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3442 - nullable_int56s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3449 - nullable_int64s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3867 - nullable_int32s, */ \ + /* 3457 - nullable_float_single, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3871 - nullable_int64s, */ \ + /* 3461 - nullable_float_double, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server), little-endian */ \ \ - /* 3879 - measurement type, */ \ + /* 3469 - measurement type, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3883 - total active power, */ \ + /* 3473 - total active power, */ \ 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 2, Cluster: On/Off (server), little-endian */ \ \ - /* 3887 - FeatureMap, */ \ + /* 3477 - FeatureMap, */ \ 0x00, 0x00, 0x00, 0x00, \ } #endif // BIGENDIAN_CPU -#define GENERATED_DEFAULTS_COUNT (122) +#define GENERATED_DEFAULTS_COUNT (139) #define ZAP_TYPE(type) ZCL_##type##_ATTRIBUTE_TYPE #define ZAP_LONG_DEFAULTS_INDEX(index) \ @@ -1242,7 +1292,7 @@ } // This is an array of EmberAfAttributeMinMaxValue structures. -#define GENERATED_MIN_MAX_DEFAULT_COUNT 27 +#define GENERATED_MIN_MAX_DEFAULT_COUNT 35 #define GENERATED_MIN_MAX_DEFAULTS \ { \ \ @@ -1291,14 +1341,24 @@ { (uint16_t) 0x0, (uint16_t) 0x0, (uint16_t) 0xFEFF }, /* color point g y */ \ { (uint16_t) 0x0, (uint16_t) 0x0, (uint16_t) 0xFEFF }, /* color point b x */ \ { (uint16_t) 0x0, (uint16_t) 0x0, (uint16_t) 0xFEFF }, /* color point b y */ \ + { (uint16_t) 0x0, (uint16_t) 0x0, (uint16_t) 0xFEFF }, /* start up color temperature mireds */ \ + \ + /* Endpoint: 1, Cluster: Test Cluster (server) */ \ + { (uint16_t) 0x46, (uint16_t) 0x14, (uint16_t) 0x64 }, /* range_restricted_int8u */ \ + { (uint16_t) 0x0, (uint16_t) -0x28, (uint16_t) 0x32 }, /* range_restricted_int8s */ \ + { (uint16_t) 0xC8, (uint16_t) 0x64, (uint16_t) 0x3E8 }, /* range_restricted_int16u */ \ + { (uint16_t) 0x0, (uint16_t) -0x96, (uint16_t) 0xC8 }, /* range_restricted_int16s */ \ + { (uint16_t) 0x46, (uint16_t) 0x14, (uint16_t) 0x64 }, /* nullable_range_restricted_int8u */ \ + { (uint16_t) 0x0, (uint16_t) -0x28, (uint16_t) 0x32 }, /* nullable_range_restricted_int8s */ \ + { (uint16_t) 0xC8, (uint16_t) 0x64, (uint16_t) 0x3E8 }, /* nullable_range_restricted_int16u */ \ { \ - (uint16_t) 0x0, (uint16_t) 0x0, (uint16_t) 0xFEFF \ - } /* start up color temperature mireds */ \ + (uint16_t) 0x0, (uint16_t) -0x96, (uint16_t) 0xC8 \ + } /* nullable_range_restricted_int16s */ \ } #define ZAP_ATTRIBUTE_MASK(mask) ATTRIBUTE_MASK_##mask // This is an array of EmberAfAttributeMetadata structures. -#define GENERATED_ATTRIBUTE_COUNT 528 +#define GENERATED_ATTRIBUTE_COUNT 560 #define GENERATED_ATTRIBUTES \ { \ \ @@ -1928,29 +1988,52 @@ { 0x0004, ZAP_TYPE(BITMAP64), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3281) }, /* bitmap64 */ \ { 0x0005, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int8u */ \ { 0x0006, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int16u */ \ - { 0x0008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3289) }, /* int32u */ \ - { 0x000C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3293) }, /* int64u */ \ + { 0x0007, ZAP_TYPE(INT24U), 3, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3289) }, /* int24u */ \ + { 0x0008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3292) }, /* int32u */ \ + { 0x0009, ZAP_TYPE(INT40U), 5, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3296) }, /* int40u */ \ + { 0x000A, ZAP_TYPE(INT48U), 6, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3301) }, /* int48u */ \ + { 0x000B, ZAP_TYPE(INT56U), 7, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3307) }, /* int56u */ \ + { 0x000C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3314) }, /* int64u */ \ { 0x000D, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int8s */ \ { 0x000E, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int16s */ \ - { 0x0010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3301) }, /* int32s */ \ - { 0x0014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3305) }, /* int64s */ \ + { 0x000F, ZAP_TYPE(INT24S), 3, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3322) }, /* int24s */ \ + { 0x0010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3325) }, /* int32s */ \ + { 0x0011, ZAP_TYPE(INT40S), 5, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3329) }, /* int40s */ \ + { 0x0012, ZAP_TYPE(INT48S), 6, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3334) }, /* int48s */ \ + { 0x0013, ZAP_TYPE(INT56S), 7, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3340) }, /* int56s */ \ + { 0x0014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3347) }, /* int64s */ \ { 0x0015, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum8 */ \ { 0x0016, ZAP_TYPE(ENUM16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum16 */ \ + { 0x0017, ZAP_TYPE(SINGLE), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3355) }, /* float_single */ \ + { 0x0018, ZAP_TYPE(DOUBLE), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3359) }, /* float_double */ \ { 0x0019, ZAP_TYPE(OCTET_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* octet_string */ \ - { 0x001A, ZAP_TYPE(ARRAY), 10, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3313) }, /* list_int8u */ \ - { 0x001B, ZAP_TYPE(ARRAY), 254, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3323) }, /* list_octet_string */ \ - { 0x001C, ZAP_TYPE(ARRAY), 254, ZAP_ATTRIBUTE_MASK(WRITABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3577) }, /* list_struct_octet_string */ \ + { 0x001A, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_EMPTY_DEFAULT() }, /* list_int8u */ \ + { 0x001B, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_EMPTY_DEFAULT() }, /* list_octet_string */ \ + { 0x001C, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_EMPTY_DEFAULT() }, /* list_struct_octet_string */ \ { 0x001D, ZAP_TYPE(LONG_OCTET_STRING), 1002, ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_EMPTY_DEFAULT() }, /* long_octet_string */ \ { 0x001E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* char_string */ \ { 0x001F, ZAP_TYPE(LONG_CHAR_STRING), 1002, ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_EMPTY_DEFAULT() }, /* long_char_string */ \ - { 0x0020, ZAP_TYPE(EPOCH_US), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3831) }, /* epoch_us */ \ - { 0x0021, ZAP_TYPE(EPOCH_S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3839) }, /* epoch_s */ \ + { 0x0020, ZAP_TYPE(EPOCH_US), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3367) }, /* epoch_us */ \ + { 0x0021, ZAP_TYPE(EPOCH_S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3375) }, /* epoch_s */ \ { 0x0022, ZAP_TYPE(VENDOR_ID), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* vendor_id */ \ { 0x0023, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE), \ ZAP_EMPTY_DEFAULT() }, /* list_nullables_and_optionals_struct */ \ + { 0x0024, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* enum_attr */ \ + { 0x0025, ZAP_TYPE(STRUCT), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_EMPTY_DEFAULT() }, /* struct */ \ + { 0x0026, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(27) }, /* range_restricted_int8u */ \ + { 0x0027, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(28) }, /* range_restricted_int8s */ \ + { 0x0028, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(29) }, /* range_restricted_int16u */ \ + { 0x0029, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(30) }, /* range_restricted_int16s */ \ { 0x8000, ZAP_TYPE(BOOLEAN), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(false) }, /* nullable_boolean */ \ { 0x8001, ZAP_TYPE(BITMAP8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ @@ -1958,38 +2041,75 @@ { 0x8002, ZAP_TYPE(BITMAP16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_bitmap16 */ \ { 0x8003, ZAP_TYPE(BITMAP32), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3843) }, /* nullable_bitmap32 */ \ + ZAP_LONG_DEFAULTS_INDEX(3379) }, /* nullable_bitmap32 */ \ { 0x8004, ZAP_TYPE(BITMAP64), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3847) }, /* nullable_bitmap64 */ \ + ZAP_LONG_DEFAULTS_INDEX(3383) }, /* nullable_bitmap64 */ \ { 0x8005, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int8u */ \ { 0x8006, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int16u */ \ + { 0x8007, ZAP_TYPE(INT24U), 3, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3391) }, /* nullable_int24u */ \ { 0x8008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3855) }, /* nullable_int32u */ \ + ZAP_LONG_DEFAULTS_INDEX(3394) }, /* nullable_int32u */ \ + { 0x8009, ZAP_TYPE(INT40U), 5, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3398) }, /* nullable_int40u */ \ + { 0x800A, ZAP_TYPE(INT48U), 6, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3403) }, /* nullable_int48u */ \ + { 0x800B, ZAP_TYPE(INT56U), 7, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3409) }, /* nullable_int56u */ \ { 0x800C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3859) }, /* nullable_int64u */ \ + ZAP_LONG_DEFAULTS_INDEX(3416) }, /* nullable_int64u */ \ { 0x800D, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int8s */ \ { 0x800E, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int16s */ \ + { 0x800F, ZAP_TYPE(INT24S), 3, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3424) }, /* nullable_int24s */ \ { 0x8010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3867) }, /* nullable_int32s */ \ + ZAP_LONG_DEFAULTS_INDEX(3427) }, /* nullable_int32s */ \ + { 0x8011, ZAP_TYPE(INT40S), 5, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3431) }, /* nullable_int40s */ \ + { 0x8012, ZAP_TYPE(INT48S), 6, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3436) }, /* nullable_int48s */ \ + { 0x8013, ZAP_TYPE(INT56S), 7, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3442) }, /* nullable_int56s */ \ { 0x8014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3871) }, /* nullable_int64s */ \ + ZAP_LONG_DEFAULTS_INDEX(3449) }, /* nullable_int64s */ \ { 0x8015, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_enum8 */ \ { 0x8016, ZAP_TYPE(ENUM16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_enum16 */ \ + { 0x8017, ZAP_TYPE(SINGLE), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3457) }, /* nullable_float_single */ \ + { 0x8018, ZAP_TYPE(DOUBLE), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3461) }, /* nullable_float_double */ \ { 0x8019, ZAP_TYPE(OCTET_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_EMPTY_DEFAULT() }, /* nullable_octet_string */ \ { 0x801E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_EMPTY_DEFAULT() }, /* nullable_char_string */ \ + ZAP_EMPTY_DEFAULT() }, /* nullable_char_string */ \ + { 0x8024, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_EMPTY_DEFAULT() }, /* nullable_enum_attr */ \ + { 0x8025, ZAP_TYPE(STRUCT), 0, \ + ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_EMPTY_DEFAULT() }, /* nullable_struct */ \ + { 0x8026, ZAP_TYPE(INT8U), 1, \ + ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(31) }, /* nullable_range_restricted_int8u */ \ + { 0x8027, ZAP_TYPE(INT8S), 1, \ + ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(32) }, /* nullable_range_restricted_int8s */ \ + { 0x8028, ZAP_TYPE(INT16U), 2, \ + ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(33) }, /* nullable_range_restricted_int16u */ \ + { 0x8029, ZAP_TYPE(INT16S), 2, \ + ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_MIN_MAX_DEFAULTS_INDEX(34) }, /* nullable_range_restricted_int16s */ \ { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server) */ \ - { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3879) }, /* measurement type */ \ - { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3883) }, /* total active power */ \ + { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3469) }, /* measurement type */ \ + { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3473) }, /* total active power */ \ { 0x0505, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xffff) }, /* rms voltage */ \ { 0x0506, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage min */ \ { 0x0507, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage max */ \ @@ -2010,7 +2130,7 @@ { 0x4001, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OnTime */ \ { 0x4002, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OffWaitTime */ \ { 0x4003, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* StartUpOnOff */ \ - { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3887) }, /* FeatureMap */ \ + { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3477) }, /* FeatureMap */ \ { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(4) }, /* ClusterRevision */ \ \ /* Endpoint: 2, Cluster: Descriptor (server) */ \ @@ -2299,25 +2419,25 @@ 0x050E, ZAP_ATTRIBUTE_INDEX(454), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Account Login (server) */ \ { \ - 0x050F, ZAP_ATTRIBUTE_INDEX(455), 44, 2680, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x050F, ZAP_ATTRIBUTE_INDEX(455), 76, 2284, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Test Cluster (server) */ \ { \ - 0x0B04, ZAP_ATTRIBUTE_INDEX(499), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0B04, ZAP_ATTRIBUTE_INDEX(531), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Electrical Measurement (server) */ \ { \ - 0xF000, ZAP_ATTRIBUTE_INDEX(511), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0xF000, ZAP_ATTRIBUTE_INDEX(543), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Binding (server) */ \ { 0x0006, \ - ZAP_ATTRIBUTE_INDEX(512), \ + ZAP_ATTRIBUTE_INDEX(544), \ 7, \ 13, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ chipFuncArrayOnOffServer }, /* Endpoint: 2, Cluster: On/Off (server) */ \ { \ - 0x001D, ZAP_ATTRIBUTE_INDEX(519), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x001D, ZAP_ATTRIBUTE_INDEX(551), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 2, Cluster: Descriptor (server) */ \ { 0x0406, \ - ZAP_ATTRIBUTE_INDEX(524), \ + ZAP_ATTRIBUTE_INDEX(556), \ 4, \ 5, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ @@ -2329,7 +2449,7 @@ // This is an array of EmberAfEndpointType structures. #define GENERATED_ENDPOINT_TYPES \ { \ - { ZAP_CLUSTER_INDEX(0), 18, 1919 }, { ZAP_CLUSTER_INDEX(18), 44, 6430 }, { ZAP_CLUSTER_INDEX(62), 3, 18 }, \ + { ZAP_CLUSTER_INDEX(0), 18, 1919 }, { ZAP_CLUSTER_INDEX(18), 44, 6034 }, { ZAP_CLUSTER_INDEX(62), 3, 18 }, \ } // Largest attribute size is needed for various buffers @@ -2339,7 +2459,7 @@ #define ATTRIBUTE_SINGLETONS_SIZE (1333) // Total size of attribute storage -#define ATTRIBUTE_MAX_SIZE (8367) +#define ATTRIBUTE_MAX_SIZE (7971) // Number of fixed endpoints #define FIXED_ENDPOINT_COUNT (3) diff --git a/zzz_generated/app-common/app-common/zap-generated/attribute-id.h b/zzz_generated/app-common/app-common/zap-generated/attribute-id.h index 3420054b90337b..af463a18d9f1c1 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attribute-id.h +++ b/zzz_generated/app-common/app-common/zap-generated/attribute-id.h @@ -1400,14 +1400,24 @@ #define ZCL_BITMAP64_ATTRIBUTE_ID (0x0004) #define ZCL_INT8_U_ATTRIBUTE_ID (0x0005) #define ZCL_INT16_U_ATTRIBUTE_ID (0x0006) +#define ZCL_INT24_U_ATTRIBUTE_ID (0x0007) #define ZCL_INT32_U_ATTRIBUTE_ID (0x0008) +#define ZCL_INT40_U_ATTRIBUTE_ID (0x0009) +#define ZCL_INT48_U_ATTRIBUTE_ID (0x000A) +#define ZCL_INT56_U_ATTRIBUTE_ID (0x000B) #define ZCL_INT64_U_ATTRIBUTE_ID (0x000C) #define ZCL_INT8_S_ATTRIBUTE_ID (0x000D) #define ZCL_INT16_S_ATTRIBUTE_ID (0x000E) +#define ZCL_INT24_S_ATTRIBUTE_ID (0x000F) #define ZCL_INT32_S_ATTRIBUTE_ID (0x0010) +#define ZCL_INT40_S_ATTRIBUTE_ID (0x0011) +#define ZCL_INT48_S_ATTRIBUTE_ID (0x0012) +#define ZCL_INT56_S_ATTRIBUTE_ID (0x0013) #define ZCL_INT64_S_ATTRIBUTE_ID (0x0014) #define ZCL_ENUM8_ATTRIBUTE_ID (0x0015) #define ZCL_ENUM16_ATTRIBUTE_ID (0x0016) +#define ZCL_FLOAT_SINGLE_ATTRIBUTE_ID (0x0017) +#define ZCL_FLOAT_DOUBLE_ATTRIBUTE_ID (0x0018) #define ZCL_OCTET_STRING_ATTRIBUTE_ID (0x0019) #define ZCL_LIST_ATTRIBUTE_ID (0x001A) #define ZCL_LIST_OCTET_STRING_ATTRIBUTE_ID (0x001B) @@ -1419,6 +1429,12 @@ #define ZCL_EPOCH_S_ATTRIBUTE_ID (0x0021) #define ZCL_TEST_VENDOR_ID_ATTRIBUTE_ID (0x0022) #define ZCL_LIST_OF_STRUCTS_WITH_OPTIONALS_ATTRIBUTE_ID (0x0023) +#define ZCL_SIMPLE_ENUM_ATTRIBUTE_ID (0x0024) +#define ZCL_STRUCT_ATTRIBUTE_ID (0x0025) +#define ZCL_RANGE_RESTRICTED_INT8_U_ATTRIBUTE_ID (0x0026) +#define ZCL_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID (0x0027) +#define ZCL_RANGE_RESTRICTED_INT16_U_ATTRIBUTE_ID (0x0028) +#define ZCL_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID (0x0029) #define ZCL_UNSUPPORTED_ATTRIBUTE_ID (0x00FF) #define ZCL_NULLABLE_BOOLEAN_ATTRIBUTE_ID (0x8000) #define ZCL_NULLABLE_BITMAP8_ATTRIBUTE_ID (0x8001) @@ -1427,16 +1443,32 @@ #define ZCL_NULLABLE_BITMAP64_ATTRIBUTE_ID (0x8004) #define ZCL_NULLABLE_INT8_U_ATTRIBUTE_ID (0x8005) #define ZCL_NULLABLE_INT16_U_ATTRIBUTE_ID (0x8006) +#define ZCL_NULLABLE_INT24_U_ATTRIBUTE_ID (0x8007) #define ZCL_NULLABLE_INT32_U_ATTRIBUTE_ID (0x8008) +#define ZCL_NULLABLE_INT40_U_ATTRIBUTE_ID (0x8009) +#define ZCL_NULLABLE_INT48_U_ATTRIBUTE_ID (0x800A) +#define ZCL_NULLABLE_INT56_U_ATTRIBUTE_ID (0x800B) #define ZCL_NULLABLE_INT64_U_ATTRIBUTE_ID (0x800C) #define ZCL_NULLABLE_INT8_S_ATTRIBUTE_ID (0x800D) #define ZCL_NULLABLE_INT16_S_ATTRIBUTE_ID (0x800E) +#define ZCL_NULLABLE_INT24_S_ATTRIBUTE_ID (0x800F) #define ZCL_NULLABLE_INT32_S_ATTRIBUTE_ID (0x8010) +#define ZCL_NULLABLE_INT40_S_ATTRIBUTE_ID (0x8011) +#define ZCL_NULLABLE_INT48_S_ATTRIBUTE_ID (0x8012) +#define ZCL_NULLABLE_INT56_S_ATTRIBUTE_ID (0x8013) #define ZCL_NULLABLE_INT64_S_ATTRIBUTE_ID (0x8014) #define ZCL_NULLABLE_ENUM8_ATTRIBUTE_ID (0x8015) #define ZCL_NULLABLE_ENUM16_ATTRIBUTE_ID (0x8016) +#define ZCL_NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID (0x8017) +#define ZCL_NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID (0x8018) #define ZCL_NULLABLE_OCTET_STRING_ATTRIBUTE_ID (0x8019) #define ZCL_NULLABLE_CHAR_STRING_ATTRIBUTE_ID (0x801E) +#define ZCL_NULLABLE_SIMPLE_ENUM_ATTRIBUTE_ID (0x8024) +#define ZCL_NULLABLE_STRUCT_ATTRIBUTE_ID (0x8025) +#define ZCL_NULLABLE_RANGE_RESTRICTED_INT8_U_ATTRIBUTE_ID (0x8026) +#define ZCL_NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID (0x8027) +#define ZCL_NULLABLE_RANGE_RESTRICTED_INT16_U_ATTRIBUTE_ID (0x8028) +#define ZCL_NULLABLE_RANGE_RESTRICTED_INT16_S_ATTRIBUTE_ID (0x8029) // Attribute ids for cluster: Messaging 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 9772199aaed0e8..e7e52a95abcf1f 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 @@ -22232,6 +22232,35 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Int16u +namespace Int24u { + +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE); +} + +} // namespace Int24u + namespace Int32u { EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) @@ -22261,6 +22290,93 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) } // namespace Int32u +namespace Int40u { + +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE); +} + +} // namespace Int40u + +namespace Int48u { + +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE); +} + +} // namespace Int48u + +namespace Int56u { + +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE); +} + +} // namespace Int56u + namespace Int64u { EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value) @@ -22348,6 +22464,35 @@ EmberAfStatus Set(chip::EndpointId endpoint, int16_t value) } // namespace Int16s +namespace Int24s { + +EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int32_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE); +} + +} // namespace Int24s + namespace Int32s { EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value) @@ -22377,6 +22522,93 @@ EmberAfStatus Set(chip::EndpointId endpoint, int32_t value) } // namespace Int32s +namespace Int40s { + +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE); +} + +} // namespace Int40s + +namespace Int48s { + +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE); +} + +} // namespace Int48s + +namespace Int56s { + +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits>::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE); +} + +} // namespace Int56s + namespace Int64s { EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value) @@ -22464,6 +22696,64 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Enum16 +namespace FloatSingle { + +EmberAfStatus Get(chip::EndpointId endpoint, float * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, float value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE); +} + +} // namespace FloatSingle + +namespace FloatDouble { + +EmberAfStatus Get(chip::EndpointId endpoint, double * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, double value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE); +} + +} // namespace FloatDouble + namespace OctetString { EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableByteSpan value) @@ -22671,61 +22961,206 @@ EmberAfStatus Set(chip::EndpointId endpoint, chip::VendorId value) } // namespace VendorId -namespace Unsupported { +namespace EnumAttr { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value) +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - *value = NumericAttributeTraits::StorageToWorking(temp); + *value = NumericAttributeTraits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, bool value) +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); } -} // namespace Unsupported +} // namespace EnumAttr -namespace NullableBoolean { +namespace RangeRestrictedInt8u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) - { - value.SetNull(); - } - else + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } + *value = NumericAttributeTraits::StorageToWorking(temp); return status; } -EmberAfStatus Set(chip::EndpointId endpoint, bool value) +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); +} + +} // namespace RangeRestrictedInt8u + +namespace RangeRestrictedInt8s { + +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int8_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); +} + +} // namespace RangeRestrictedInt8s + +namespace RangeRestrictedInt16u { + +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace RangeRestrictedInt16u + +namespace RangeRestrictedInt16s { + +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int16_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); +} + +} // namespace RangeRestrictedInt16s + +namespace Unsupported { + +EmberAfStatus Get(chip::EndpointId endpoint, bool * value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = NumericAttributeTraits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, bool value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); +} + +} // namespace Unsupported + +namespace NullableBoolean { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, bool value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); } @@ -23050,6 +23485,56 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable } // namespace NullableInt16u +namespace NullableInt24u { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits>::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24U_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt24u + namespace NullableInt32u { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) @@ -23100,42 +23585,42 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable } // namespace NullableInt32u -namespace NullableInt64u { +namespace NullableInt40u { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits>::IsNullValue(temp)) { value.SetNull(); } else { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); } return status; } EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40U_ATTRIBUTE_TYPE); } EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) @@ -23148,47 +23633,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableInt64u +} // namespace NullableInt40u -namespace NullableInt8s { +namespace NullableInt48u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits>::IsNullValue(temp)) { value.SetNull(); } else { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, int8_t value) +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48U_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23198,47 +23683,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & return Set(endpoint, value.Value()); } -} // namespace NullableInt8s +} // namespace NullableInt48u -namespace NullableInt16s { +namespace NullableInt56u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits>::IsNullValue(temp)) { value.SetNull(); } else { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, int16_t value) +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56U_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23248,47 +23733,743 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableInt16s +} // namespace NullableInt56u -namespace NullableInt32s { +namespace NullableInt64u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64U_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt64u + +namespace NullableInt8s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int8_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt8s + +namespace NullableInt16s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int16_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt16s + +namespace NullableInt24s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits>::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int32_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT24S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt24s + +namespace NullableInt32s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int32_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt32s + +namespace NullableInt40s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits>::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT40S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt40s + +namespace NullableInt48s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits>::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT48S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt48s + +namespace NullableInt56s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits>::StorageType temp; + uint8_t * readable = NumericAttributeTraits>::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits>::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits>::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits>::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits>::StorageType storageValue; + NumericAttributeTraits>::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits>::StorageType value; + NumericAttributeTraits>::SetNull(value); + uint8_t * writable = NumericAttributeTraits>::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT56S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt56s + +namespace NullableInt64s { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableInt64s + +namespace NullableEnum8 { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableEnum8 + +namespace NullableEnum16 { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableEnum16 + +namespace NullableFloatSingle { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, float value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_SINGLE_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableFloatSingle + +namespace NullableFloatDouble { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (NumericAttributeTraits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, double value) +{ + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_DOUBLE_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace NullableFloatDouble + +namespace NullableOctetString { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + uint8_t zclString[10 + 1]; + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, sizeof(zclString)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + size_t length = emberAfStringLength(zclString); + if (length == NumericAttributeTraits::kNullValue) { value.SetNull(); + return EMBER_ZCL_STATUS_SUCCESS; } - else + auto & span = value.SetNonNull(); + + VerifyOrReturnError(span.size() == 10, EMBER_ZCL_STATUS_INVALID_DATA_TYPE); + memcpy(span.data(), &zclString[1], 10); + span.reduce_size(length); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value) +{ + static_assert(10 < NumericAttributeTraits::kNullValue, "value.size() might be too big"); + VerifyOrReturnError(value.size() <= 10, EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + uint8_t zclString[10 + 1]; + emberAfCopyInt8u(zclString, 0, static_cast(value.size())); + memcpy(&zclString[1], value.data(), value.size()); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + uint8_t zclString[1] = { 0xFF }; + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +{ + if (value.IsNull()) { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + return SetNull(endpoint); } - return status; + + return Set(endpoint, value.Value()); } -EmberAfStatus Set(chip::EndpointId endpoint, int32_t value) + +} // namespace NullableOctetString + +namespace NullableCharString { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + uint8_t zclString[10 + 1]; + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, sizeof(zclString)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + size_t length = emberAfStringLength(zclString); + if (length == NumericAttributeTraits::kNullValue) { - return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + value.SetNull(); + return EMBER_ZCL_STATUS_SUCCESS; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE); + auto & span = value.SetNonNull(); + + VerifyOrReturnError(span.size() == 10, EMBER_ZCL_STATUS_INVALID_DATA_TYPE); + memcpy(span.data(), &zclString[1], 10); + span.reduce_size(length); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value) +{ + static_assert(10 < NumericAttributeTraits::kNullValue, "value.size() might be too big"); + VerifyOrReturnError(value.size() <= 10, EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + uint8_t zclString[10 + 1]; + emberAfCopyInt8u(zclString, 0, static_cast(value.size())); + memcpy(&zclString[1], value.data(), value.size()); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT32S_ATTRIBUTE_TYPE); + uint8_t zclString[1] = { 0xFF }; + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23298,47 +24479,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableInt32s +} // namespace NullableCharString -namespace NullableInt64s { +namespace NullableEnumAttr { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits::IsNullValue(temp)) { value.SetNull(); } else { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, int64_t value) +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT64S_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23348,9 +24529,9 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableInt64s +} // namespace NullableEnumAttr -namespace NullableEnum8 { +namespace NullableRangeRestrictedInt8u { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { @@ -23377,7 +24558,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value) NumericAttributeTraits::StorageType storageValue; NumericAttributeTraits::WorkingToStorage(value, storageValue); uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) @@ -23385,7 +24566,7 @@ EmberAfStatus SetNull(chip::EndpointId endpoint) NumericAttributeTraits::StorageType value; NumericAttributeTraits::SetNull(value); uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); } EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) @@ -23398,47 +24579,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableEnum8 +} // namespace NullableRangeRestrictedInt8u -namespace NullableEnum16 { +namespace NullableRangeRestrictedInt8s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - NumericAttributeTraits::StorageType temp; - uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - if (NumericAttributeTraits::IsNullValue(temp)) + if (NumericAttributeTraits::IsNullValue(temp)) { value.SetNull(); } else { - value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +EmberAfStatus Set(chip::EndpointId endpoint, int8_t value) { - if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) { return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; } - NumericAttributeTraits::StorageType storageValue; - NumericAttributeTraits::WorkingToStorage(value, storageValue); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - NumericAttributeTraits::StorageType value; - NumericAttributeTraits::SetNull(value); - uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_ENUM16_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT8S_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23448,45 +24629,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable return Set(endpoint, value.Value()); } -} // namespace NullableEnum16 +} // namespace NullableRangeRestrictedInt8s -namespace NullableOctetString { +namespace NullableRangeRestrictedInt16u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - uint8_t zclString[10 + 1]; - EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, sizeof(zclString)); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - size_t length = emberAfStringLength(zclString); - if (length == NumericAttributeTraits::kNullValue) + if (NumericAttributeTraits::IsNullValue(temp)) { value.SetNull(); - return EMBER_ZCL_STATUS_SUCCESS; } - auto & span = value.SetNonNull(); - - VerifyOrReturnError(span.size() == 10, EMBER_ZCL_STATUS_INVALID_DATA_TYPE); - memcpy(span.data(), &zclString[1], 10); - span.reduce_size(length); + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value) +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) { - static_assert(10 < NumericAttributeTraits::kNullValue, "value.size() might be too big"); - VerifyOrReturnError(value.size() <= 10, EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - uint8_t zclString[10 + 1]; - emberAfCopyInt8u(zclString, 0, static_cast(value.size())); - memcpy(&zclString[1], value.data(), value.size()); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - uint8_t zclString[1] = { 0xFF }; - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_OCTET_STRING_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23496,45 +24679,47 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) { - uint8_t zclString[10 + 1]; - EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, sizeof(zclString)); + NumericAttributeTraits::StorageType temp; + uint8_t * readable = NumericAttributeTraits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadServerAttribute(endpoint, Clusters::TestCluster::Id, Id, readable, sizeof(temp)); VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); - size_t length = emberAfStringLength(zclString); - if (length == NumericAttributeTraits::kNullValue) + if (NumericAttributeTraits::IsNullValue(temp)) { value.SetNull(); - return EMBER_ZCL_STATUS_SUCCESS; } - auto & span = value.SetNonNull(); - - VerifyOrReturnError(span.size() == 10, EMBER_ZCL_STATUS_INVALID_DATA_TYPE); - memcpy(span.data(), &zclString[1], 10); - span.reduce_size(length); + else + { + value.SetNonNull() = NumericAttributeTraits::StorageToWorking(temp); + } return status; } -EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value) +EmberAfStatus Set(chip::EndpointId endpoint, int16_t value) { - static_assert(10 < NumericAttributeTraits::kNullValue, "value.size() might be too big"); - VerifyOrReturnError(value.size() <= 10, EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - uint8_t zclString[10 + 1]; - emberAfCopyInt8u(zclString, 0, static_cast(value.size())); - memcpy(&zclString[1], value.data(), value.size()); - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); + if (!NumericAttributeTraits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + NumericAttributeTraits::StorageType storageValue; + NumericAttributeTraits::WorkingToStorage(value, storageValue); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); } EmberAfStatus SetNull(chip::EndpointId endpoint) { - uint8_t zclString[1] = { 0xFF }; - return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, zclString, ZCL_CHAR_STRING_ATTRIBUTE_TYPE); + NumericAttributeTraits::StorageType value; + NumericAttributeTraits::SetNull(value); + uint8_t * writable = NumericAttributeTraits::ToAttributeStoreRepresentation(value); + return emberAfWriteServerAttribute(endpoint, Clusters::TestCluster::Id, Id, writable, ZCL_INT16S_ATTRIBUTE_TYPE); } -EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value) { if (value.IsNull()) { @@ -23544,7 +24729,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableInt16u +namespace NullableInt24u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt24u + namespace NullableInt32u { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); @@ -4355,6 +4437,27 @@ EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableInt32u +namespace NullableInt40u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40u +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt40u + +namespace NullableInt48u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48u +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt48u + +namespace NullableInt56u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56u +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt56u + namespace NullableInt64u { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); @@ -4376,6 +4479,13 @@ EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableInt16s +namespace NullableInt24s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24s +EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt24s + namespace NullableInt32s { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32s EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); @@ -4383,6 +4493,27 @@ EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableInt32s +namespace NullableInt40s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40s +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt40s + +namespace NullableInt48s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48s +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt48s + +namespace NullableInt56s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56s +EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableInt56s + namespace NullableInt64s { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64s EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); @@ -4404,6 +4535,20 @@ EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableEnum16 +namespace NullableFloatSingle { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // single +EmberAfStatus Set(chip::EndpointId endpoint, float value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableFloatSingle + +namespace NullableFloatDouble { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // double +EmberAfStatus Set(chip::EndpointId endpoint, double value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableFloatDouble + namespace NullableOctetString { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); @@ -4418,6 +4563,41 @@ EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); } // namespace NullableCharString +namespace NullableEnumAttr { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // SimpleEnum +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableEnumAttr + +namespace NullableRangeRestrictedInt8u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableRangeRestrictedInt8u + +namespace NullableRangeRestrictedInt8s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s +EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableRangeRestrictedInt8s + +namespace NullableRangeRestrictedInt16u { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableRangeRestrictedInt16u + +namespace NullableRangeRestrictedInt16s { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const DataModel::Nullable & value); +} // namespace NullableRangeRestrictedInt16s + } // namespace Attributes } // namespace TestCluster 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 7855833487e92e..ab6f51ca9d1aa7 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 @@ -28691,6 +28691,17 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::Int16u::Id; } }; } // namespace Int16u +namespace Int24u { +struct TypeInfo +{ + using Type = uint32_t; + using DecodableType = uint32_t; + using DecodableArgType = uint32_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int24u::Id; } +}; +} // namespace Int24u namespace Int32u { struct TypeInfo { @@ -28702,6 +28713,39 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::Int32u::Id; } }; } // namespace Int32u +namespace Int40u { +struct TypeInfo +{ + using Type = uint64_t; + using DecodableType = uint64_t; + using DecodableArgType = uint64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int40u::Id; } +}; +} // namespace Int40u +namespace Int48u { +struct TypeInfo +{ + using Type = uint64_t; + using DecodableType = uint64_t; + using DecodableArgType = uint64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int48u::Id; } +}; +} // namespace Int48u +namespace Int56u { +struct TypeInfo +{ + using Type = uint64_t; + using DecodableType = uint64_t; + using DecodableArgType = uint64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int56u::Id; } +}; +} // namespace Int56u namespace Int64u { struct TypeInfo { @@ -28735,6 +28779,17 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::Int16s::Id; } }; } // namespace Int16s +namespace Int24s { +struct TypeInfo +{ + using Type = int32_t; + using DecodableType = int32_t; + using DecodableArgType = int32_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int24s::Id; } +}; +} // namespace Int24s namespace Int32s { struct TypeInfo { @@ -28746,6 +28801,39 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::Int32s::Id; } }; } // namespace Int32s +namespace Int40s { +struct TypeInfo +{ + using Type = int64_t; + using DecodableType = int64_t; + using DecodableArgType = int64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int40s::Id; } +}; +} // namespace Int40s +namespace Int48s { +struct TypeInfo +{ + using Type = int64_t; + using DecodableType = int64_t; + using DecodableArgType = int64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int48s::Id; } +}; +} // namespace Int48s +namespace Int56s { +struct TypeInfo +{ + using Type = int64_t; + using DecodableType = int64_t; + using DecodableArgType = int64_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Int56s::Id; } +}; +} // namespace Int56s namespace Int64s { struct TypeInfo { @@ -28779,6 +28867,28 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::Enum16::Id; } }; } // namespace Enum16 +namespace FloatSingle { +struct TypeInfo +{ + using Type = float; + using DecodableType = float; + using DecodableArgType = float; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::FloatSingle::Id; } +}; +} // namespace FloatSingle +namespace FloatDouble { +struct TypeInfo +{ + using Type = double; + using DecodableType = double; + using DecodableArgType = double; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::FloatDouble::Id; } +}; +} // namespace FloatDouble namespace OctetString { struct TypeInfo { @@ -28900,6 +29010,72 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::ListNullablesAndOptionalsStruct::Id; } }; } // namespace ListNullablesAndOptionalsStruct +namespace EnumAttr { +struct TypeInfo +{ + using Type = SimpleEnum; + using DecodableType = SimpleEnum; + using DecodableArgType = SimpleEnum; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::EnumAttr::Id; } +}; +} // namespace EnumAttr +namespace Struct { +struct TypeInfo +{ + using Type = Structs::SimpleStruct::Type; + using DecodableType = Structs::SimpleStruct::DecodableType; + using DecodableArgType = const Structs::SimpleStruct::DecodableType &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Struct::Id; } +}; +} // namespace Struct +namespace RangeRestrictedInt8u { +struct TypeInfo +{ + using Type = uint8_t; + using DecodableType = uint8_t; + using DecodableArgType = uint8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt8u::Id; } +}; +} // namespace RangeRestrictedInt8u +namespace RangeRestrictedInt8s { +struct TypeInfo +{ + using Type = int8_t; + using DecodableType = int8_t; + using DecodableArgType = int8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt8s::Id; } +}; +} // namespace RangeRestrictedInt8s +namespace RangeRestrictedInt16u { +struct TypeInfo +{ + using Type = uint16_t; + using DecodableType = uint16_t; + using DecodableArgType = uint16_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt16u::Id; } +}; +} // namespace RangeRestrictedInt16u +namespace RangeRestrictedInt16s { +struct TypeInfo +{ + using Type = int16_t; + using DecodableType = int16_t; + using DecodableArgType = int16_t; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::RangeRestrictedInt16s::Id; } +}; +} // namespace RangeRestrictedInt16s namespace Unsupported { struct TypeInfo { @@ -28988,6 +29164,17 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt16u::Id; } }; } // namespace NullableInt16u +namespace NullableInt24u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt24u::Id; } +}; +} // namespace NullableInt24u namespace NullableInt32u { struct TypeInfo { @@ -28999,6 +29186,39 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt32u::Id; } }; } // namespace NullableInt32u +namespace NullableInt40u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt40u::Id; } +}; +} // namespace NullableInt40u +namespace NullableInt48u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt48u::Id; } +}; +} // namespace NullableInt48u +namespace NullableInt56u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt56u::Id; } +}; +} // namespace NullableInt56u namespace NullableInt64u { struct TypeInfo { @@ -29032,6 +29252,17 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt16s::Id; } }; } // namespace NullableInt16s +namespace NullableInt24s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt24s::Id; } +}; +} // namespace NullableInt24s namespace NullableInt32s { struct TypeInfo { @@ -29043,6 +29274,39 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt32s::Id; } }; } // namespace NullableInt32s +namespace NullableInt40s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt40s::Id; } +}; +} // namespace NullableInt40s +namespace NullableInt48s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt48s::Id; } +}; +} // namespace NullableInt48s +namespace NullableInt56s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableInt56s::Id; } +}; +} // namespace NullableInt56s namespace NullableInt64s { struct TypeInfo { @@ -29076,6 +29340,28 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableEnum16::Id; } }; } // namespace NullableEnum16 +namespace NullableFloatSingle { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableFloatSingle::Id; } +}; +} // namespace NullableFloatSingle +namespace NullableFloatDouble { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableFloatDouble::Id; } +}; +} // namespace NullableFloatDouble namespace NullableOctetString { struct TypeInfo { @@ -29098,6 +29384,72 @@ struct TypeInfo static constexpr AttributeId GetAttributeId() { return Attributes::NullableCharString::Id; } }; } // namespace NullableCharString +namespace NullableEnumAttr { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableEnumAttr::Id; } +}; +} // namespace NullableEnumAttr +namespace NullableStruct { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableStruct::Id; } +}; +} // namespace NullableStruct +namespace NullableRangeRestrictedInt8u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt8u::Id; } +}; +} // namespace NullableRangeRestrictedInt8u +namespace NullableRangeRestrictedInt8s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt8s::Id; } +}; +} // namespace NullableRangeRestrictedInt8s +namespace NullableRangeRestrictedInt16u { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt16u::Id; } +}; +} // namespace NullableRangeRestrictedInt16u +namespace NullableRangeRestrictedInt16s { +struct TypeInfo +{ + using Type = DataModel::Nullable; + using DecodableType = DataModel::Nullable; + using DecodableArgType = const DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::NullableRangeRestrictedInt16s::Id; } +}; +} // namespace NullableRangeRestrictedInt16s namespace FeatureMap { struct TypeInfo { 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 6d2abd1247bc8e..44c1d38baba723 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 @@ -4498,10 +4498,26 @@ namespace Int16u { static constexpr AttributeId Id = 0x00000006; } // namespace Int16u +namespace Int24u { +static constexpr AttributeId Id = 0x00000007; +} // namespace Int24u + namespace Int32u { static constexpr AttributeId Id = 0x00000008; } // namespace Int32u +namespace Int40u { +static constexpr AttributeId Id = 0x00000009; +} // namespace Int40u + +namespace Int48u { +static constexpr AttributeId Id = 0x0000000A; +} // namespace Int48u + +namespace Int56u { +static constexpr AttributeId Id = 0x0000000B; +} // namespace Int56u + namespace Int64u { static constexpr AttributeId Id = 0x0000000C; } // namespace Int64u @@ -4514,10 +4530,26 @@ namespace Int16s { static constexpr AttributeId Id = 0x0000000E; } // namespace Int16s +namespace Int24s { +static constexpr AttributeId Id = 0x0000000F; +} // namespace Int24s + namespace Int32s { static constexpr AttributeId Id = 0x00000010; } // namespace Int32s +namespace Int40s { +static constexpr AttributeId Id = 0x00000011; +} // namespace Int40s + +namespace Int48s { +static constexpr AttributeId Id = 0x00000012; +} // namespace Int48s + +namespace Int56s { +static constexpr AttributeId Id = 0x00000013; +} // namespace Int56s + namespace Int64s { static constexpr AttributeId Id = 0x00000014; } // namespace Int64s @@ -4530,6 +4562,14 @@ namespace Enum16 { static constexpr AttributeId Id = 0x00000016; } // namespace Enum16 +namespace FloatSingle { +static constexpr AttributeId Id = 0x00000017; +} // namespace FloatSingle + +namespace FloatDouble { +static constexpr AttributeId Id = 0x00000018; +} // namespace FloatDouble + namespace OctetString { static constexpr AttributeId Id = 0x00000019; } // namespace OctetString @@ -4574,6 +4614,30 @@ namespace ListNullablesAndOptionalsStruct { static constexpr AttributeId Id = 0x00000023; } // namespace ListNullablesAndOptionalsStruct +namespace EnumAttr { +static constexpr AttributeId Id = 0x00000024; +} // namespace EnumAttr + +namespace Struct { +static constexpr AttributeId Id = 0x00000025; +} // namespace Struct + +namespace RangeRestrictedInt8u { +static constexpr AttributeId Id = 0x00000026; +} // namespace RangeRestrictedInt8u + +namespace RangeRestrictedInt8s { +static constexpr AttributeId Id = 0x00000027; +} // namespace RangeRestrictedInt8s + +namespace RangeRestrictedInt16u { +static constexpr AttributeId Id = 0x00000028; +} // namespace RangeRestrictedInt16u + +namespace RangeRestrictedInt16s { +static constexpr AttributeId Id = 0x00000029; +} // namespace RangeRestrictedInt16s + namespace Unsupported { static constexpr AttributeId Id = 0x000000FF; } // namespace Unsupported @@ -4606,10 +4670,26 @@ namespace NullableInt16u { static constexpr AttributeId Id = 0x00008006; } // namespace NullableInt16u +namespace NullableInt24u { +static constexpr AttributeId Id = 0x00008007; +} // namespace NullableInt24u + namespace NullableInt32u { static constexpr AttributeId Id = 0x00008008; } // namespace NullableInt32u +namespace NullableInt40u { +static constexpr AttributeId Id = 0x00008009; +} // namespace NullableInt40u + +namespace NullableInt48u { +static constexpr AttributeId Id = 0x0000800A; +} // namespace NullableInt48u + +namespace NullableInt56u { +static constexpr AttributeId Id = 0x0000800B; +} // namespace NullableInt56u + namespace NullableInt64u { static constexpr AttributeId Id = 0x0000800C; } // namespace NullableInt64u @@ -4622,10 +4702,26 @@ namespace NullableInt16s { static constexpr AttributeId Id = 0x0000800E; } // namespace NullableInt16s +namespace NullableInt24s { +static constexpr AttributeId Id = 0x0000800F; +} // namespace NullableInt24s + namespace NullableInt32s { static constexpr AttributeId Id = 0x00008010; } // namespace NullableInt32s +namespace NullableInt40s { +static constexpr AttributeId Id = 0x00008011; +} // namespace NullableInt40s + +namespace NullableInt48s { +static constexpr AttributeId Id = 0x00008012; +} // namespace NullableInt48s + +namespace NullableInt56s { +static constexpr AttributeId Id = 0x00008013; +} // namespace NullableInt56s + namespace NullableInt64s { static constexpr AttributeId Id = 0x00008014; } // namespace NullableInt64s @@ -4638,6 +4734,14 @@ namespace NullableEnum16 { static constexpr AttributeId Id = 0x00008016; } // namespace NullableEnum16 +namespace NullableFloatSingle { +static constexpr AttributeId Id = 0x00008017; +} // namespace NullableFloatSingle + +namespace NullableFloatDouble { +static constexpr AttributeId Id = 0x00008018; +} // namespace NullableFloatDouble + namespace NullableOctetString { static constexpr AttributeId Id = 0x00008019; } // namespace NullableOctetString @@ -4646,6 +4750,30 @@ namespace NullableCharString { static constexpr AttributeId Id = 0x0000801E; } // namespace NullableCharString +namespace NullableEnumAttr { +static constexpr AttributeId Id = 0x00008024; +} // namespace NullableEnumAttr + +namespace NullableStruct { +static constexpr AttributeId Id = 0x00008025; +} // namespace NullableStruct + +namespace NullableRangeRestrictedInt8u { +static constexpr AttributeId Id = 0x00008026; +} // namespace NullableRangeRestrictedInt8u + +namespace NullableRangeRestrictedInt8s { +static constexpr AttributeId Id = 0x00008027; +} // namespace NullableRangeRestrictedInt8s + +namespace NullableRangeRestrictedInt16u { +static constexpr AttributeId Id = 0x00008028; +} // namespace NullableRangeRestrictedInt16u + +namespace NullableRangeRestrictedInt16s { +static constexpr AttributeId Id = 0x00008029; +} // namespace NullableRangeRestrictedInt16s + namespace FeatureMap { static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id; } // namespace FeatureMap diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 56e9902f9c99f5..2f0b0ba0b7bd2e 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -36320,14 +36320,24 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | * Bitmap64 | 0x0004 | | * Int8u | 0x0005 | | * Int16u | 0x0006 | +| * Int24u | 0x0007 | | * Int32u | 0x0008 | +| * Int40u | 0x0009 | +| * Int48u | 0x000A | +| * Int56u | 0x000B | | * Int64u | 0x000C | | * Int8s | 0x000D | | * Int16s | 0x000E | +| * Int24s | 0x000F | | * Int32s | 0x0010 | +| * Int40s | 0x0011 | +| * Int48s | 0x0012 | +| * Int56s | 0x0013 | | * Int64s | 0x0014 | | * Enum8 | 0x0015 | | * Enum16 | 0x0016 | +| * FloatSingle | 0x0017 | +| * FloatDouble | 0x0018 | | * OctetString | 0x0019 | | * ListInt8u | 0x001A | | * ListOctetString | 0x001B | @@ -36339,6 +36349,12 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | * EpochS | 0x0021 | | * VendorId | 0x0022 | | * ListNullablesAndOptionalsStruct | 0x0023 | +| * EnumAttr | 0x0024 | +| * Struct | 0x0025 | +| * RangeRestrictedInt8u | 0x0026 | +| * RangeRestrictedInt8s | 0x0027 | +| * RangeRestrictedInt16u | 0x0028 | +| * RangeRestrictedInt16s | 0x0029 | | * Unsupported | 0x00FF | | * NullableBoolean | 0x8000 | | * NullableBitmap8 | 0x8001 | @@ -36347,16 +36363,32 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | * NullableBitmap64 | 0x8004 | | * NullableInt8u | 0x8005 | | * NullableInt16u | 0x8006 | +| * NullableInt24u | 0x8007 | | * NullableInt32u | 0x8008 | +| * NullableInt40u | 0x8009 | +| * NullableInt48u | 0x800A | +| * NullableInt56u | 0x800B | | * NullableInt64u | 0x800C | | * NullableInt8s | 0x800D | | * NullableInt16s | 0x800E | +| * NullableInt24s | 0x800F | | * NullableInt32s | 0x8010 | +| * NullableInt40s | 0x8011 | +| * NullableInt48s | 0x8012 | +| * NullableInt56s | 0x8013 | | * NullableInt64s | 0x8014 | | * NullableEnum8 | 0x8015 | | * NullableEnum16 | 0x8016 | +| * NullableFloatSingle | 0x8017 | +| * NullableFloatDouble | 0x8018 | | * NullableOctetString | 0x8019 | | * NullableCharString | 0x801E | +| * NullableEnumAttr | 0x8024 | +| * NullableStruct | 0x8025 | +| * NullableRangeRestrictedInt8u | 0x8026 | +| * NullableRangeRestrictedInt8s | 0x8027 | +| * NullableRangeRestrictedInt16u | 0x8028 | +| * NullableRangeRestrictedInt16s | 0x8029 | | * ClusterRevision | 0xFFFD | \*----------------------------------------------------------------------------*/ @@ -37537,18 +37569,18 @@ class ReportTestClusterInt16u : public ModelCommand }; /* - * Attribute Int32u + * Attribute Int24u */ -class ReadTestClusterInt32u : public ModelCommand +class ReadTestClusterInt24u : public ModelCommand { public: - ReadTestClusterInt32u() : ModelCommand("read") + ReadTestClusterInt24u() : ModelCommand("read") { - AddArgument("attr-name", "int32u"); + AddArgument("attr-name", "int24u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt32u() + ~ReadTestClusterInt24u() { delete onSuccessCallback; delete onFailureCallback; @@ -37560,7 +37592,7 @@ class ReadTestClusterInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt24u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: @@ -37570,17 +37602,17 @@ class ReadTestClusterInt32u : public ModelCommand new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt32u : public ModelCommand +class WriteTestClusterInt24u : public ModelCommand { public: - WriteTestClusterInt32u() : ModelCommand("write") + WriteTestClusterInt24u() : ModelCommand("write") { - AddArgument("attr-name", "int32u"); + AddArgument("attr-name", "int24u"); AddArgument("attr-value", 0, UINT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt32u() + ~WriteTestClusterInt24u() { delete onSuccessCallback; delete onFailureCallback; @@ -37592,7 +37624,7 @@ class WriteTestClusterInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt24u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -37603,19 +37635,19 @@ class WriteTestClusterInt32u : public ModelCommand uint32_t mValue; }; -class ReportTestClusterInt32u : public ModelCommand +class ReportTestClusterInt24u : public ModelCommand { public: - ReportTestClusterInt32u() : ModelCommand("report") + ReportTestClusterInt24u() : ModelCommand("report") { - AddArgument("attr-name", "int32u"); + AddArgument("attr-name", "int24u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt32u() + ~ReportTestClusterInt24u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -37630,10 +37662,10 @@ class ReportTestClusterInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt32u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt24u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt32u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt24u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -37656,18 +37688,18 @@ class ReportTestClusterInt32u : public ModelCommand }; /* - * Attribute Int64u + * Attribute Int32u */ -class ReadTestClusterInt64u : public ModelCommand +class ReadTestClusterInt32u : public ModelCommand { public: - ReadTestClusterInt64u() : ModelCommand("read") + ReadTestClusterInt32u() : ModelCommand("read") { - AddArgument("attr-name", "int64u"); + AddArgument("attr-name", "int32u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt64u() + ~ReadTestClusterInt32u() { delete onSuccessCallback; delete onFailureCallback; @@ -37679,27 +37711,27 @@ class ReadTestClusterInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt64u : public ModelCommand +class WriteTestClusterInt32u : public ModelCommand { public: - WriteTestClusterInt64u() : ModelCommand("write") + WriteTestClusterInt32u() : ModelCommand("write") { - AddArgument("attr-name", "int64u"); - AddArgument("attr-value", 0, UINT64_MAX, &mValue); + AddArgument("attr-name", "int32u"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt64u() + ~WriteTestClusterInt32u() { delete onSuccessCallback; delete onFailureCallback; @@ -37711,7 +37743,7 @@ class WriteTestClusterInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -37719,22 +37751,22 @@ class WriteTestClusterInt64u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint64_t mValue; + uint32_t mValue; }; -class ReportTestClusterInt64u : public ModelCommand +class ReportTestClusterInt32u : public ModelCommand { public: - ReportTestClusterInt64u() : ModelCommand("report") + ReportTestClusterInt32u() : ModelCommand("report") { - AddArgument("attr-name", "int64u"); + AddArgument("attr-name", "int32u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt64u() + ~ReportTestClusterInt32u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -37749,10 +37781,10 @@ class ReportTestClusterInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt64u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt32u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt64u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt32u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -37767,26 +37799,26 @@ class ReportTestClusterInt64u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Int8s + * Attribute Int40u */ -class ReadTestClusterInt8s : public ModelCommand +class ReadTestClusterInt40u : public ModelCommand { public: - ReadTestClusterInt8s() : ModelCommand("read") + ReadTestClusterInt40u() : ModelCommand("read") { - AddArgument("attr-name", "int8s"); + AddArgument("attr-name", "int40u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt8s() + ~ReadTestClusterInt40u() { delete onSuccessCallback; delete onFailureCallback; @@ -37798,27 +37830,27 @@ class ReadTestClusterInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt40u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt8sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt8s : public ModelCommand +class WriteTestClusterInt40u : public ModelCommand { public: - WriteTestClusterInt8s() : ModelCommand("write") + WriteTestClusterInt40u() : ModelCommand("write") { - AddArgument("attr-name", "int8s"); - AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); + AddArgument("attr-name", "int40u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt8s() + ~WriteTestClusterInt40u() { delete onSuccessCallback; delete onFailureCallback; @@ -37830,7 +37862,7 @@ class WriteTestClusterInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt40u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -37838,22 +37870,22 @@ class WriteTestClusterInt8s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int8_t mValue; + uint64_t mValue; }; -class ReportTestClusterInt8s : public ModelCommand +class ReportTestClusterInt40u : public ModelCommand { public: - ReportTestClusterInt8s() : ModelCommand("report") + ReportTestClusterInt40u() : ModelCommand("report") { - AddArgument("attr-name", "int8s"); + AddArgument("attr-name", "int40u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt8s() + ~ReportTestClusterInt40u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -37868,10 +37900,10 @@ class ReportTestClusterInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt8s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt40u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt40u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -37886,26 +37918,26 @@ class ReportTestClusterInt8s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt8sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Int16s + * Attribute Int48u */ -class ReadTestClusterInt16s : public ModelCommand +class ReadTestClusterInt48u : public ModelCommand { public: - ReadTestClusterInt16s() : ModelCommand("read") + ReadTestClusterInt48u() : ModelCommand("read") { - AddArgument("attr-name", "int16s"); + AddArgument("attr-name", "int48u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt16s() + ~ReadTestClusterInt48u() { delete onSuccessCallback; delete onFailureCallback; @@ -37917,27 +37949,27 @@ class ReadTestClusterInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt48u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt16s : public ModelCommand +class WriteTestClusterInt48u : public ModelCommand { public: - WriteTestClusterInt16s() : ModelCommand("write") + WriteTestClusterInt48u() : ModelCommand("write") { - AddArgument("attr-name", "int16s"); - AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); + AddArgument("attr-name", "int48u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt16s() + ~WriteTestClusterInt48u() { delete onSuccessCallback; delete onFailureCallback; @@ -37949,7 +37981,7 @@ class WriteTestClusterInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt48u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -37957,22 +37989,22 @@ class WriteTestClusterInt16s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int16_t mValue; + uint64_t mValue; }; -class ReportTestClusterInt16s : public ModelCommand +class ReportTestClusterInt48u : public ModelCommand { public: - ReportTestClusterInt16s() : ModelCommand("report") + ReportTestClusterInt48u() : ModelCommand("report") { - AddArgument("attr-name", "int16s"); + AddArgument("attr-name", "int48u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt16s() + ~ReportTestClusterInt48u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -37987,10 +38019,10 @@ class ReportTestClusterInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt16s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt48u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt48u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38005,26 +38037,26 @@ class ReportTestClusterInt16s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Int32s + * Attribute Int56u */ -class ReadTestClusterInt32s : public ModelCommand +class ReadTestClusterInt56u : public ModelCommand { public: - ReadTestClusterInt32s() : ModelCommand("read") + ReadTestClusterInt56u() : ModelCommand("read") { - AddArgument("attr-name", "int32s"); + AddArgument("attr-name", "int56u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt32s() + ~ReadTestClusterInt56u() { delete onSuccessCallback; delete onFailureCallback; @@ -38036,27 +38068,27 @@ class ReadTestClusterInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt56u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt32sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt32s : public ModelCommand +class WriteTestClusterInt56u : public ModelCommand { public: - WriteTestClusterInt32s() : ModelCommand("write") + WriteTestClusterInt56u() : ModelCommand("write") { - AddArgument("attr-name", "int32s"); - AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); + AddArgument("attr-name", "int56u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt32s() + ~WriteTestClusterInt56u() { delete onSuccessCallback; delete onFailureCallback; @@ -38068,7 +38100,7 @@ class WriteTestClusterInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt56u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38076,22 +38108,22 @@ class WriteTestClusterInt32s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int32_t mValue; + uint64_t mValue; }; -class ReportTestClusterInt32s : public ModelCommand +class ReportTestClusterInt56u : public ModelCommand { public: - ReportTestClusterInt32s() : ModelCommand("report") + ReportTestClusterInt56u() : ModelCommand("report") { - AddArgument("attr-name", "int32s"); + AddArgument("attr-name", "int56u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt32s() + ~ReportTestClusterInt56u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38106,10 +38138,10 @@ class ReportTestClusterInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt32s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt56u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt32s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt56u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38124,26 +38156,26 @@ class ReportTestClusterInt32s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt32sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Int64s + * Attribute Int64u */ -class ReadTestClusterInt64s : public ModelCommand +class ReadTestClusterInt64u : public ModelCommand { public: - ReadTestClusterInt64s() : ModelCommand("read") + ReadTestClusterInt64u() : ModelCommand("read") { - AddArgument("attr-name", "int64s"); + AddArgument("attr-name", "int64u"); ModelCommand::AddArguments(); } - ~ReadTestClusterInt64s() + ~ReadTestClusterInt64u() { delete onSuccessCallback; delete onFailureCallback; @@ -38155,27 +38187,27 @@ class ReadTestClusterInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterInt64s : public ModelCommand +class WriteTestClusterInt64u : public ModelCommand { public: - WriteTestClusterInt64s() : ModelCommand("write") + WriteTestClusterInt64u() : ModelCommand("write") { - AddArgument("attr-name", "int64s"); - AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); + AddArgument("attr-name", "int64u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterInt64s() + ~WriteTestClusterInt64u() { delete onSuccessCallback; delete onFailureCallback; @@ -38187,7 +38219,7 @@ class WriteTestClusterInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38195,22 +38227,22 @@ class WriteTestClusterInt64s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int64_t mValue; + uint64_t mValue; }; -class ReportTestClusterInt64s : public ModelCommand +class ReportTestClusterInt64u : public ModelCommand { public: - ReportTestClusterInt64s() : ModelCommand("report") + ReportTestClusterInt64u() : ModelCommand("report") { - AddArgument("attr-name", "int64s"); + AddArgument("attr-name", "int64u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterInt64s() + ~ReportTestClusterInt64u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38225,10 +38257,10 @@ class ReportTestClusterInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeInt64s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt64u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeInt64s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt64u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38243,26 +38275,26 @@ class ReportTestClusterInt64s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Enum8 + * Attribute Int8s */ -class ReadTestClusterEnum8 : public ModelCommand +class ReadTestClusterInt8s : public ModelCommand { public: - ReadTestClusterEnum8() : ModelCommand("read") + ReadTestClusterInt8s() : ModelCommand("read") { - AddArgument("attr-name", "enum8"); + AddArgument("attr-name", "int8s"); ModelCommand::AddArguments(); } - ~ReadTestClusterEnum8() + ~ReadTestClusterInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -38274,27 +38306,27 @@ class ReadTestClusterEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterEnum8 : public ModelCommand +class WriteTestClusterInt8s : public ModelCommand { public: - WriteTestClusterEnum8() : ModelCommand("write") + WriteTestClusterInt8s() : ModelCommand("write") { - AddArgument("attr-name", "enum8"); - AddArgument("attr-value", 0, UINT8_MAX, &mValue); + AddArgument("attr-name", "int8s"); + AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterEnum8() + ~WriteTestClusterInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -38306,7 +38338,7 @@ class WriteTestClusterEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38314,22 +38346,22 @@ class WriteTestClusterEnum8 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint8_t mValue; + int8_t mValue; }; -class ReportTestClusterEnum8 : public ModelCommand +class ReportTestClusterInt8s : public ModelCommand { public: - ReportTestClusterEnum8() : ModelCommand("report") + ReportTestClusterInt8s() : ModelCommand("report") { - AddArgument("attr-name", "enum8"); + AddArgument("attr-name", "int8s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterEnum8() + ~ReportTestClusterInt8s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38344,10 +38376,10 @@ class ReportTestClusterEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeEnum8(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt8s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeEnum8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38362,26 +38394,26 @@ class ReportTestClusterEnum8 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt8uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute Enum16 + * Attribute Int16s */ -class ReadTestClusterEnum16 : public ModelCommand +class ReadTestClusterInt16s : public ModelCommand { public: - ReadTestClusterEnum16() : ModelCommand("read") + ReadTestClusterInt16s() : ModelCommand("read") { - AddArgument("attr-name", "enum16"); + AddArgument("attr-name", "int16s"); ModelCommand::AddArguments(); } - ~ReadTestClusterEnum16() + ~ReadTestClusterInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -38393,27 +38425,27 @@ class ReadTestClusterEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterEnum16 : public ModelCommand +class WriteTestClusterInt16s : public ModelCommand { public: - WriteTestClusterEnum16() : ModelCommand("write") + WriteTestClusterInt16s() : ModelCommand("write") { - AddArgument("attr-name", "enum16"); - AddArgument("attr-value", 0, UINT16_MAX, &mValue); + AddArgument("attr-name", "int16s"); + AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterEnum16() + ~WriteTestClusterInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -38425,7 +38457,7 @@ class WriteTestClusterEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38433,22 +38465,22 @@ class WriteTestClusterEnum16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint16_t mValue; + int16_t mValue; }; -class ReportTestClusterEnum16 : public ModelCommand +class ReportTestClusterInt16s : public ModelCommand { public: - ReportTestClusterEnum16() : ModelCommand("report") + ReportTestClusterInt16s() : ModelCommand("report") { - AddArgument("attr-name", "enum16"); + AddArgument("attr-name", "int16s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterEnum16() + ~ReportTestClusterInt16s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38463,10 +38495,10 @@ class ReportTestClusterEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeEnum16(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt16s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeEnum16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38481,26 +38513,26 @@ class ReportTestClusterEnum16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute OctetString + * Attribute Int24s */ -class ReadTestClusterOctetString : public ModelCommand +class ReadTestClusterInt24s : public ModelCommand { public: - ReadTestClusterOctetString() : ModelCommand("read") + ReadTestClusterInt24s() : ModelCommand("read") { - AddArgument("attr-name", "octet-string"); + AddArgument("attr-name", "int24s"); ModelCommand::AddArguments(); } - ~ReadTestClusterOctetString() + ~ReadTestClusterInt24s() { delete onSuccessCallback; delete onFailureCallback; @@ -38512,27 +38544,27 @@ class ReadTestClusterOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt24s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnOctetStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterOctetString : public ModelCommand +class WriteTestClusterInt24s : public ModelCommand { public: - WriteTestClusterOctetString() : ModelCommand("write") + WriteTestClusterInt24s() : ModelCommand("write") { - AddArgument("attr-name", "octet-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "int24s"); + AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterOctetString() + ~WriteTestClusterInt24s() { delete onSuccessCallback; delete onFailureCallback; @@ -38544,7 +38576,7 @@ class WriteTestClusterOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt24s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38552,22 +38584,22 @@ class WriteTestClusterOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::ByteSpan mValue; + int32_t mValue; }; -class ReportTestClusterOctetString : public ModelCommand +class ReportTestClusterInt24s : public ModelCommand { public: - ReportTestClusterOctetString() : ModelCommand("report") + ReportTestClusterInt24s() : ModelCommand("report") { - AddArgument("attr-name", "octet-string"); + AddArgument("attr-name", "int24s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterOctetString() + ~ReportTestClusterInt24s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38582,10 +38614,10 @@ class ReportTestClusterOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeOctetString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt24s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt24s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38600,26 +38632,26 @@ class ReportTestClusterOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnOctetStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute ListInt8u + * Attribute Int32s */ -class ReadTestClusterListInt8u : public ModelCommand +class ReadTestClusterInt32s : public ModelCommand { public: - ReadTestClusterListInt8u() : ModelCommand("read") + ReadTestClusterInt32s() : ModelCommand("read") { - AddArgument("attr-name", "list-int8u"); + AddArgument("attr-name", "int32s"); ModelCommand::AddArguments(); } - ~ReadTestClusterListInt8u() + ~ReadTestClusterInt32s() { delete onSuccessCallback; delete onFailureCallback; @@ -38631,29 +38663,27 @@ class ReadTestClusterListInt8u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeListInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnTestClusterListInt8uListAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -/* - * Attribute ListOctetString - */ -class ReadTestClusterListOctetString : public ModelCommand +class WriteTestClusterInt32s : public ModelCommand { public: - ReadTestClusterListOctetString() : ModelCommand("read") + WriteTestClusterInt32s() : ModelCommand("write") { - AddArgument("attr-name", "list-octet-string"); + AddArgument("attr-name", "int32s"); + AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~ReadTestClusterListOctetString() + ~WriteTestClusterInt32s() { delete onSuccessCallback; delete onFailureCallback; @@ -38661,69 +38691,86 @@ class ReadTestClusterListOctetString : public ModelCommand CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override { - ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeListOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.WriteAttributeInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback( - OnTestClusterListOctetStringListAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); + int32_t mValue; }; -/* - * Attribute ListStructOctetString - */ -class ReadTestClusterListStructOctetString : public ModelCommand +class ReportTestClusterInt32s : public ModelCommand { public: - ReadTestClusterListStructOctetString() : ModelCommand("read") + ReportTestClusterInt32s() : ModelCommand("report") { - AddArgument("attr-name", "list-struct-octet-string"); + AddArgument("attr-name", "int32s"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReadTestClusterListStructOctetString() + ~ReportTestClusterInt32s() { delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; delete onFailureCallback; + delete onReportCallback; } CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override { - ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeListStructOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + + ReturnErrorOnFailure(cluster.ReportAttributeInt32s(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeInt32s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback( - OnTestClusterListStructOctetStringListAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32sAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; }; /* - * Attribute LongOctetString + * Attribute Int40s */ -class ReadTestClusterLongOctetString : public ModelCommand +class ReadTestClusterInt40s : public ModelCommand { public: - ReadTestClusterLongOctetString() : ModelCommand("read") + ReadTestClusterInt40s() : ModelCommand("read") { - AddArgument("attr-name", "long-octet-string"); + AddArgument("attr-name", "int40s"); ModelCommand::AddArguments(); } - ~ReadTestClusterLongOctetString() + ~ReadTestClusterInt40s() { delete onSuccessCallback; delete onFailureCallback; @@ -38735,27 +38782,27 @@ class ReadTestClusterLongOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeLongOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt40s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnOctetStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterLongOctetString : public ModelCommand +class WriteTestClusterInt40s : public ModelCommand { public: - WriteTestClusterLongOctetString() : ModelCommand("write") + WriteTestClusterInt40s() : ModelCommand("write") { - AddArgument("attr-name", "long-octet-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "int40s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterLongOctetString() + ~WriteTestClusterInt40s() { delete onSuccessCallback; delete onFailureCallback; @@ -38767,7 +38814,7 @@ class WriteTestClusterLongOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeLongOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt40s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38775,22 +38822,22 @@ class WriteTestClusterLongOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::ByteSpan mValue; + int64_t mValue; }; -class ReportTestClusterLongOctetString : public ModelCommand +class ReportTestClusterInt40s : public ModelCommand { public: - ReportTestClusterLongOctetString() : ModelCommand("report") + ReportTestClusterInt40s() : ModelCommand("report") { - AddArgument("attr-name", "long-octet-string"); + AddArgument("attr-name", "int40s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterLongOctetString() + ~ReportTestClusterInt40s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38805,10 +38852,10 @@ class ReportTestClusterLongOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeLongOctetString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt40s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeLongOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt40s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38823,26 +38870,26 @@ class ReportTestClusterLongOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnOctetStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute CharString + * Attribute Int48s */ -class ReadTestClusterCharString : public ModelCommand +class ReadTestClusterInt48s : public ModelCommand { public: - ReadTestClusterCharString() : ModelCommand("read") + ReadTestClusterInt48s() : ModelCommand("read") { - AddArgument("attr-name", "char-string"); + AddArgument("attr-name", "int48s"); ModelCommand::AddArguments(); } - ~ReadTestClusterCharString() + ~ReadTestClusterInt48s() { delete onSuccessCallback; delete onFailureCallback; @@ -38854,27 +38901,27 @@ class ReadTestClusterCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt48s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterCharString : public ModelCommand +class WriteTestClusterInt48s : public ModelCommand { public: - WriteTestClusterCharString() : ModelCommand("write") + WriteTestClusterInt48s() : ModelCommand("write") { - AddArgument("attr-name", "char-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "int48s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterCharString() + ~WriteTestClusterInt48s() { delete onSuccessCallback; delete onFailureCallback; @@ -38886,7 +38933,7 @@ class WriteTestClusterCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt48s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -38894,22 +38941,22 @@ class WriteTestClusterCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::CharSpan mValue; + int64_t mValue; }; -class ReportTestClusterCharString : public ModelCommand +class ReportTestClusterInt48s : public ModelCommand { public: - ReportTestClusterCharString() : ModelCommand("report") + ReportTestClusterInt48s() : ModelCommand("report") { - AddArgument("attr-name", "char-string"); + AddArgument("attr-name", "int48s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterCharString() + ~ReportTestClusterInt48s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -38924,10 +38971,10 @@ class ReportTestClusterCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeCharString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt48s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt48s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -38942,26 +38989,26 @@ class ReportTestClusterCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnCharStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute LongCharString + * Attribute Int56s */ -class ReadTestClusterLongCharString : public ModelCommand +class ReadTestClusterInt56s : public ModelCommand { public: - ReadTestClusterLongCharString() : ModelCommand("read") + ReadTestClusterInt56s() : ModelCommand("read") { - AddArgument("attr-name", "long-char-string"); + AddArgument("attr-name", "int56s"); ModelCommand::AddArguments(); } - ~ReadTestClusterLongCharString() + ~ReadTestClusterInt56s() { delete onSuccessCallback; delete onFailureCallback; @@ -38973,27 +39020,27 @@ class ReadTestClusterLongCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeLongCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt56s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterLongCharString : public ModelCommand +class WriteTestClusterInt56s : public ModelCommand { public: - WriteTestClusterLongCharString() : ModelCommand("write") + WriteTestClusterInt56s() : ModelCommand("write") { - AddArgument("attr-name", "long-char-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "int56s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterLongCharString() + ~WriteTestClusterInt56s() { delete onSuccessCallback; delete onFailureCallback; @@ -39005,7 +39052,7 @@ class WriteTestClusterLongCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeLongCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt56s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39013,22 +39060,22 @@ class WriteTestClusterLongCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::CharSpan mValue; + int64_t mValue; }; -class ReportTestClusterLongCharString : public ModelCommand +class ReportTestClusterInt56s : public ModelCommand { public: - ReportTestClusterLongCharString() : ModelCommand("report") + ReportTestClusterInt56s() : ModelCommand("report") { - AddArgument("attr-name", "long-char-string"); + AddArgument("attr-name", "int56s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterLongCharString() + ~ReportTestClusterInt56s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39043,10 +39090,10 @@ class ReportTestClusterLongCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeLongCharString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeInt56s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeLongCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeInt56s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39061,26 +39108,26 @@ class ReportTestClusterLongCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnCharStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute EpochUs + * Attribute Int64s */ -class ReadTestClusterEpochUs : public ModelCommand +class ReadTestClusterInt64s : public ModelCommand { public: - ReadTestClusterEpochUs() : ModelCommand("read") + ReadTestClusterInt64s() : ModelCommand("read") { - AddArgument("attr-name", "epoch-us"); + AddArgument("attr-name", "int64s"); ModelCommand::AddArguments(); } - ~ReadTestClusterEpochUs() + ~ReadTestClusterInt64s() { delete onSuccessCallback; delete onFailureCallback; @@ -39092,27 +39139,27 @@ class ReadTestClusterEpochUs : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeEpochUs(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterEpochUs : public ModelCommand +class WriteTestClusterInt64s : public ModelCommand { public: - WriteTestClusterEpochUs() : ModelCommand("write") + WriteTestClusterInt64s() : ModelCommand("write") { - AddArgument("attr-name", "epoch-us"); - AddArgument("attr-value", 0, UINT64_MAX, &mValue); + AddArgument("attr-name", "int64s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterEpochUs() + ~WriteTestClusterInt64s() { delete onSuccessCallback; delete onFailureCallback; @@ -39124,7 +39171,7 @@ class WriteTestClusterEpochUs : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeEpochUs(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39132,22 +39179,2664 @@ class WriteTestClusterEpochUs : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint64_t mValue; + int64_t mValue; +}; + +class ReportTestClusterInt64s : public ModelCommand +{ +public: + ReportTestClusterInt64s() : ModelCommand("report") + { + AddArgument("attr-name", "int64s"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterInt64s() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeInt64s(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeInt64s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute Enum8 + */ +class ReadTestClusterEnum8 : public ModelCommand +{ +public: + ReadTestClusterEnum8() : ModelCommand("read") + { + AddArgument("attr-name", "enum8"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterEnum8() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterEnum8 : public ModelCommand +{ +public: + WriteTestClusterEnum8() : ModelCommand("write") + { + AddArgument("attr-name", "enum8"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterEnum8() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint8_t mValue; +}; + +class ReportTestClusterEnum8 : public ModelCommand +{ +public: + ReportTestClusterEnum8() : ModelCommand("report") + { + AddArgument("attr-name", "enum8"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterEnum8() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeEnum8(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeEnum8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute Enum16 + */ +class ReadTestClusterEnum16 : public ModelCommand +{ +public: + ReadTestClusterEnum16() : ModelCommand("read") + { + AddArgument("attr-name", "enum16"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterEnum16() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterEnum16 : public ModelCommand +{ +public: + WriteTestClusterEnum16() : ModelCommand("write") + { + AddArgument("attr-name", "enum16"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterEnum16() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint16_t mValue; +}; + +class ReportTestClusterEnum16 : public ModelCommand +{ +public: + ReportTestClusterEnum16() : ModelCommand("report") + { + AddArgument("attr-name", "enum16"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterEnum16() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeEnum16(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeEnum16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute OctetString + */ +class ReadTestClusterOctetString : public ModelCommand +{ +public: + ReadTestClusterOctetString() : ModelCommand("read") + { + AddArgument("attr-name", "octet-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnOctetStringAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterOctetString : public ModelCommand +{ +public: + WriteTestClusterOctetString() : ModelCommand("write") + { + AddArgument("attr-name", "octet-string"); + AddArgument("attr-value", &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::ByteSpan mValue; +}; + +class ReportTestClusterOctetString : public ModelCommand +{ +public: + ReportTestClusterOctetString() : ModelCommand("report") + { + AddArgument("attr-name", "octet-string"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterOctetString() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeOctetString(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnOctetStringAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute ListInt8u + */ +class ReadTestClusterListInt8u : public ModelCommand +{ +public: + ReadTestClusterListInt8u() : ModelCommand("read") + { + AddArgument("attr-name", "list-int8u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterListInt8u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeListInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnTestClusterListInt8uListAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +/* + * Attribute ListOctetString + */ +class ReadTestClusterListOctetString : public ModelCommand +{ +public: + ReadTestClusterListOctetString() : ModelCommand("read") + { + AddArgument("attr-name", "list-octet-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterListOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeListOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback( + OnTestClusterListOctetStringListAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +/* + * Attribute ListStructOctetString + */ +class ReadTestClusterListStructOctetString : public ModelCommand +{ +public: + ReadTestClusterListStructOctetString() : ModelCommand("read") + { + AddArgument("attr-name", "list-struct-octet-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterListStructOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeListStructOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback( + OnTestClusterListStructOctetStringListAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +/* + * Attribute LongOctetString + */ +class ReadTestClusterLongOctetString : public ModelCommand +{ +public: + ReadTestClusterLongOctetString() : ModelCommand("read") + { + AddArgument("attr-name", "long-octet-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterLongOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeLongOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnOctetStringAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterLongOctetString : public ModelCommand +{ +public: + WriteTestClusterLongOctetString() : ModelCommand("write") + { + AddArgument("attr-name", "long-octet-string"); + AddArgument("attr-value", &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterLongOctetString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeLongOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::ByteSpan mValue; +}; + +class ReportTestClusterLongOctetString : public ModelCommand +{ +public: + ReportTestClusterLongOctetString() : ModelCommand("report") + { + AddArgument("attr-name", "long-octet-string"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterLongOctetString() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeLongOctetString(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeLongOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnOctetStringAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute CharString + */ +class ReadTestClusterCharString : public ModelCommand +{ +public: + ReadTestClusterCharString() : ModelCommand("read") + { + AddArgument("attr-name", "char-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterCharString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterCharString : public ModelCommand +{ +public: + WriteTestClusterCharString() : ModelCommand("write") + { + AddArgument("attr-name", "char-string"); + AddArgument("attr-value", &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterCharString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::CharSpan mValue; +}; + +class ReportTestClusterCharString : public ModelCommand +{ +public: + ReportTestClusterCharString() : ModelCommand("report") + { + AddArgument("attr-name", "char-string"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterCharString() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeCharString(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnCharStringAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute LongCharString + */ +class ReadTestClusterLongCharString : public ModelCommand +{ +public: + ReadTestClusterLongCharString() : ModelCommand("read") + { + AddArgument("attr-name", "long-char-string"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterLongCharString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeLongCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterLongCharString : public ModelCommand +{ +public: + WriteTestClusterLongCharString() : ModelCommand("write") + { + AddArgument("attr-name", "long-char-string"); + AddArgument("attr-value", &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterLongCharString() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeLongCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::CharSpan mValue; +}; + +class ReportTestClusterLongCharString : public ModelCommand +{ +public: + ReportTestClusterLongCharString() : ModelCommand("report") + { + AddArgument("attr-name", "long-char-string"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterLongCharString() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeLongCharString(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeLongCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnCharStringAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute EpochUs + */ +class ReadTestClusterEpochUs : public ModelCommand +{ +public: + ReadTestClusterEpochUs() : ModelCommand("read") + { + AddArgument("attr-name", "epoch-us"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterEpochUs() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeEpochUs(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterEpochUs : public ModelCommand +{ +public: + WriteTestClusterEpochUs() : ModelCommand("write") + { + AddArgument("attr-name", "epoch-us"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterEpochUs() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeEpochUs(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint64_t mValue; +}; + +class ReportTestClusterEpochUs : public ModelCommand +{ +public: + ReportTestClusterEpochUs() : ModelCommand("report") + { + AddArgument("attr-name", "epoch-us"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterEpochUs() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeEpochUs(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeEpochUs(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute EpochS + */ +class ReadTestClusterEpochS : public ModelCommand +{ +public: + ReadTestClusterEpochS() : ModelCommand("read") + { + AddArgument("attr-name", "epoch-s"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterEpochS() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeEpochS(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterEpochS : public ModelCommand +{ +public: + WriteTestClusterEpochS() : ModelCommand("write") + { + AddArgument("attr-name", "epoch-s"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterEpochS() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeEpochS(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint32_t mValue; +}; + +class ReportTestClusterEpochS : public ModelCommand +{ +public: + ReportTestClusterEpochS() : ModelCommand("report") + { + AddArgument("attr-name", "epoch-s"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterEpochS() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeEpochS(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeEpochS(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute VendorId + */ +class ReadTestClusterVendorId : public ModelCommand +{ +public: + ReadTestClusterVendorId() : ModelCommand("read") + { + AddArgument("attr-name", "vendor-id"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterVendorId() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterVendorId : public ModelCommand +{ +public: + WriteTestClusterVendorId() : ModelCommand("write") + { + AddArgument("attr-name", "vendor-id"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterVendorId() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::VendorId mValue; +}; + +class ReportTestClusterVendorId : public ModelCommand +{ +public: + ReportTestClusterVendorId() : ModelCommand("report") + { + AddArgument("attr-name", "vendor-id"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterVendorId() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeVendorId(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeVendorId(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute ListNullablesAndOptionalsStruct + */ +class ReadTestClusterListNullablesAndOptionalsStruct : public ModelCommand +{ +public: + ReadTestClusterListNullablesAndOptionalsStruct() : ModelCommand("read") + { + AddArgument("attr-name", "list-nullables-and-optionals-struct"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterListNullablesAndOptionalsStruct() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeListNullablesAndOptionalsStruct(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback( + OnTestClusterListNullablesAndOptionalsStructListAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +/* + * Attribute RangeRestrictedInt8u + */ +class ReadTestClusterRangeRestrictedInt8u : public ModelCommand +{ +public: + ReadTestClusterRangeRestrictedInt8u() : ModelCommand("read") + { + AddArgument("attr-name", "range-restricted-int8u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterRangeRestrictedInt8u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeRangeRestrictedInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterRangeRestrictedInt8u : public ModelCommand +{ +public: + WriteTestClusterRangeRestrictedInt8u() : ModelCommand("write") + { + AddArgument("attr-name", "range-restricted-int8u"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterRangeRestrictedInt8u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeRangeRestrictedInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint8_t mValue; +}; + +class ReportTestClusterRangeRestrictedInt8u : public ModelCommand +{ +public: + ReportTestClusterRangeRestrictedInt8u() : ModelCommand("report") + { + AddArgument("attr-name", "range-restricted-int8u"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterRangeRestrictedInt8u() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeRangeRestrictedInt8u(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeRangeRestrictedInt8u(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute RangeRestrictedInt8s + */ +class ReadTestClusterRangeRestrictedInt8s : public ModelCommand +{ +public: + ReadTestClusterRangeRestrictedInt8s() : ModelCommand("read") + { + AddArgument("attr-name", "range-restricted-int8s"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterRangeRestrictedInt8s() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeRangeRestrictedInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterRangeRestrictedInt8s : public ModelCommand +{ +public: + WriteTestClusterRangeRestrictedInt8s() : ModelCommand("write") + { + AddArgument("attr-name", "range-restricted-int8s"); + AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterRangeRestrictedInt8s() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeRangeRestrictedInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + int8_t mValue; +}; + +class ReportTestClusterRangeRestrictedInt8s : public ModelCommand +{ +public: + ReportTestClusterRangeRestrictedInt8s() : ModelCommand("report") + { + AddArgument("attr-name", "range-restricted-int8s"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterRangeRestrictedInt8s() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeRangeRestrictedInt8s(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeRangeRestrictedInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8sAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute RangeRestrictedInt16u + */ +class ReadTestClusterRangeRestrictedInt16u : public ModelCommand +{ +public: + ReadTestClusterRangeRestrictedInt16u() : ModelCommand("read") + { + AddArgument("attr-name", "range-restricted-int16u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterRangeRestrictedInt16u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeRangeRestrictedInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterRangeRestrictedInt16u : public ModelCommand +{ +public: + WriteTestClusterRangeRestrictedInt16u() : ModelCommand("write") + { + AddArgument("attr-name", "range-restricted-int16u"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterRangeRestrictedInt16u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeRangeRestrictedInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint16_t mValue; +}; + +class ReportTestClusterRangeRestrictedInt16u : public ModelCommand +{ +public: + ReportTestClusterRangeRestrictedInt16u() : ModelCommand("report") + { + AddArgument("attr-name", "range-restricted-int16u"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterRangeRestrictedInt16u() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeRangeRestrictedInt16u(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeRangeRestrictedInt16u(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute RangeRestrictedInt16s + */ +class ReadTestClusterRangeRestrictedInt16s : public ModelCommand +{ +public: + ReadTestClusterRangeRestrictedInt16s() : ModelCommand("read") + { + AddArgument("attr-name", "range-restricted-int16s"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterRangeRestrictedInt16s() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeRangeRestrictedInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterRangeRestrictedInt16s : public ModelCommand +{ +public: + WriteTestClusterRangeRestrictedInt16s() : ModelCommand("write") + { + AddArgument("attr-name", "range-restricted-int16s"); + AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterRangeRestrictedInt16s() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeRangeRestrictedInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + int16_t mValue; +}; + +class ReportTestClusterRangeRestrictedInt16s : public ModelCommand +{ +public: + ReportTestClusterRangeRestrictedInt16s() : ModelCommand("report") + { + AddArgument("attr-name", "range-restricted-int16s"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterRangeRestrictedInt16s() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeRangeRestrictedInt16s(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeRangeRestrictedInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16sAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute Unsupported + */ +class ReadTestClusterUnsupported : public ModelCommand +{ +public: + ReadTestClusterUnsupported() : ModelCommand("read") + { + AddArgument("attr-name", "unsupported"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterUnsupported() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeUnsupported(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnBooleanAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterUnsupported : public ModelCommand +{ +public: + WriteTestClusterUnsupported() : ModelCommand("write") + { + AddArgument("attr-name", "unsupported"); + AddArgument("attr-value", 0, 1, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterUnsupported() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeUnsupported(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + bool mValue; +}; + +class ReportTestClusterUnsupported : public ModelCommand +{ +public: + ReportTestClusterUnsupported() : ModelCommand("report") + { + AddArgument("attr-name", "unsupported"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterUnsupported() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeUnsupported(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeUnsupported(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnBooleanAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableBoolean + */ +class ReadTestClusterNullableBoolean : public ModelCommand +{ +public: + ReadTestClusterNullableBoolean() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-boolean"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableBoolean() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableBoolean(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnBooleanAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableBoolean : public ModelCommand +{ +public: + WriteTestClusterNullableBoolean() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-boolean"); + AddArgument("attr-value", 0, 1, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableBoolean() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableBoolean(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + bool mValue; +}; + +class ReportTestClusterNullableBoolean : public ModelCommand +{ +public: + ReportTestClusterNullableBoolean() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-boolean"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableBoolean() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableBoolean(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableBoolean(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnBooleanAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableBitmap8 + */ +class ReadTestClusterNullableBitmap8 : public ModelCommand +{ +public: + ReadTestClusterNullableBitmap8() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-bitmap8"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableBitmap8() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableBitmap8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableBitmap8 : public ModelCommand +{ +public: + WriteTestClusterNullableBitmap8() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-bitmap8"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableBitmap8() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableBitmap8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint8_t mValue; +}; + +class ReportTestClusterNullableBitmap8 : public ModelCommand +{ +public: + ReportTestClusterNullableBitmap8() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-bitmap8"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableBitmap8() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap8(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableBitmap8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableBitmap16 + */ +class ReadTestClusterNullableBitmap16 : public ModelCommand +{ +public: + ReadTestClusterNullableBitmap16() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-bitmap16"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableBitmap16() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableBitmap16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableBitmap16 : public ModelCommand +{ +public: + WriteTestClusterNullableBitmap16() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-bitmap16"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableBitmap16() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableBitmap16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint16_t mValue; +}; + +class ReportTestClusterNullableBitmap16 : public ModelCommand +{ +public: + ReportTestClusterNullableBitmap16() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-bitmap16"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableBitmap16() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap16(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableBitmap16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableBitmap32 + */ +class ReadTestClusterNullableBitmap32 : public ModelCommand +{ +public: + ReadTestClusterNullableBitmap32() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-bitmap32"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableBitmap32() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableBitmap32(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableBitmap32 : public ModelCommand +{ +public: + WriteTestClusterNullableBitmap32() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-bitmap32"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableBitmap32() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableBitmap32(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint32_t mValue; +}; + +class ReportTestClusterNullableBitmap32 : public ModelCommand +{ +public: + ReportTestClusterNullableBitmap32() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-bitmap32"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableBitmap32() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap32(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableBitmap32(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableBitmap64 + */ +class ReadTestClusterNullableBitmap64 : public ModelCommand +{ +public: + ReadTestClusterNullableBitmap64() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-bitmap64"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableBitmap64() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableBitmap64(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableBitmap64 : public ModelCommand +{ +public: + WriteTestClusterNullableBitmap64() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-bitmap64"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableBitmap64() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableBitmap64(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint64_t mValue; +}; + +class ReportTestClusterNullableBitmap64 : public ModelCommand +{ +public: + ReportTestClusterNullableBitmap64() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-bitmap64"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableBitmap64() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap64(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableBitmap64(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableInt8u + */ +class ReadTestClusterNullableInt8u : public ModelCommand +{ +public: + ReadTestClusterNullableInt8u() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-int8u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableInt8u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableInt8u : public ModelCommand +{ +public: + WriteTestClusterNullableInt8u() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-int8u"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableInt8u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint8_t mValue; +}; + +class ReportTestClusterNullableInt8u : public ModelCommand +{ +public: + ReportTestClusterNullableInt8u() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-int8u"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableInt8u() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt8u(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableInt8u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableInt16u + */ +class ReadTestClusterNullableInt16u : public ModelCommand +{ +public: + ReadTestClusterNullableInt16u() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-int16u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableInt16u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableInt16u : public ModelCommand +{ +public: + WriteTestClusterNullableInt16u() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-int16u"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableInt16u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint16_t mValue; }; -class ReportTestClusterEpochUs : public ModelCommand +class ReportTestClusterNullableInt16u : public ModelCommand { public: - ReportTestClusterEpochUs() : ModelCommand("report") + ReportTestClusterNullableInt16u() : ModelCommand("report") { - AddArgument("attr-name", "epoch-us"); + AddArgument("attr-name", "nullable-int16u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterEpochUs() + ~ReportTestClusterNullableInt16u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39162,10 +41851,248 @@ class ReportTestClusterEpochUs : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeEpochUs(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt16u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeEpochUs(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt16u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableInt24u + */ +class ReadTestClusterNullableInt24u : public ModelCommand +{ +public: + ReadTestClusterNullableInt24u() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-int24u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableInt24u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableInt24u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableInt24u : public ModelCommand +{ +public: + WriteTestClusterNullableInt24u() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-int24u"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableInt24u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableInt24u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint32_t mValue; +}; + +class ReportTestClusterNullableInt24u : public ModelCommand +{ +public: + ReportTestClusterNullableInt24u() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-int24u"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableInt24u() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt24u(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableInt24u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32uAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableInt32u + */ +class ReadTestClusterNullableInt32u : public ModelCommand +{ +public: + ReadTestClusterNullableInt32u() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-int32u"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableInt32u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableInt32u : public ModelCommand +{ +public: + WriteTestClusterNullableInt32u() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-int32u"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableInt32u() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + uint32_t mValue; +}; + +class ReportTestClusterNullableInt32u : public ModelCommand +{ +public: + ReportTestClusterNullableInt32u() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-int32u"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableInt32u() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt32u(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableInt32u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39180,26 +42107,26 @@ class ReportTestClusterEpochUs : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute EpochS + * Attribute NullableInt40u */ -class ReadTestClusterEpochS : public ModelCommand +class ReadTestClusterNullableInt40u : public ModelCommand { public: - ReadTestClusterEpochS() : ModelCommand("read") + ReadTestClusterNullableInt40u() : ModelCommand("read") { - AddArgument("attr-name", "epoch-s"); + AddArgument("attr-name", "nullable-int40u"); ModelCommand::AddArguments(); } - ~ReadTestClusterEpochS() + ~ReadTestClusterNullableInt40u() { delete onSuccessCallback; delete onFailureCallback; @@ -39211,27 +42138,27 @@ class ReadTestClusterEpochS : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeEpochS(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt40u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterEpochS : public ModelCommand +class WriteTestClusterNullableInt40u : public ModelCommand { public: - WriteTestClusterEpochS() : ModelCommand("write") + WriteTestClusterNullableInt40u() : ModelCommand("write") { - AddArgument("attr-name", "epoch-s"); - AddArgument("attr-value", 0, UINT32_MAX, &mValue); + AddArgument("attr-name", "nullable-int40u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterEpochS() + ~WriteTestClusterNullableInt40u() { delete onSuccessCallback; delete onFailureCallback; @@ -39243,7 +42170,7 @@ class WriteTestClusterEpochS : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeEpochS(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt40u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39251,22 +42178,22 @@ class WriteTestClusterEpochS : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint32_t mValue; + uint64_t mValue; }; -class ReportTestClusterEpochS : public ModelCommand +class ReportTestClusterNullableInt40u : public ModelCommand { public: - ReportTestClusterEpochS() : ModelCommand("report") + ReportTestClusterNullableInt40u() : ModelCommand("report") { - AddArgument("attr-name", "epoch-s"); + AddArgument("attr-name", "nullable-int40u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterEpochS() + ~ReportTestClusterNullableInt40u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39281,10 +42208,10 @@ class ReportTestClusterEpochS : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeEpochS(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt40u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeEpochS(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt40u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39299,26 +42226,26 @@ class ReportTestClusterEpochS : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt32uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute VendorId + * Attribute NullableInt48u */ -class ReadTestClusterVendorId : public ModelCommand +class ReadTestClusterNullableInt48u : public ModelCommand { public: - ReadTestClusterVendorId() : ModelCommand("read") + ReadTestClusterNullableInt48u() : ModelCommand("read") { - AddArgument("attr-name", "vendor-id"); + AddArgument("attr-name", "nullable-int48u"); ModelCommand::AddArguments(); } - ~ReadTestClusterVendorId() + ~ReadTestClusterNullableInt48u() { delete onSuccessCallback; delete onFailureCallback; @@ -39330,27 +42257,27 @@ class ReadTestClusterVendorId : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt48u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterVendorId : public ModelCommand +class WriteTestClusterNullableInt48u : public ModelCommand { public: - WriteTestClusterVendorId() : ModelCommand("write") + WriteTestClusterNullableInt48u() : ModelCommand("write") { - AddArgument("attr-name", "vendor-id"); - AddArgument("attr-value", 0, UINT16_MAX, &mValue); + AddArgument("attr-name", "nullable-int48u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterVendorId() + ~WriteTestClusterNullableInt48u() { delete onSuccessCallback; delete onFailureCallback; @@ -39362,7 +42289,7 @@ class WriteTestClusterVendorId : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeVendorId(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt48u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39370,22 +42297,22 @@ class WriteTestClusterVendorId : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::VendorId mValue; + uint64_t mValue; }; -class ReportTestClusterVendorId : public ModelCommand +class ReportTestClusterNullableInt48u : public ModelCommand { public: - ReportTestClusterVendorId() : ModelCommand("report") + ReportTestClusterNullableInt48u() : ModelCommand("report") { - AddArgument("attr-name", "vendor-id"); + AddArgument("attr-name", "nullable-int48u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterVendorId() + ~ReportTestClusterNullableInt48u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39400,10 +42327,10 @@ class ReportTestClusterVendorId : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeVendorId(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt48u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeVendorId(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt48u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39418,61 +42345,26 @@ class ReportTestClusterVendorId : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute ListNullablesAndOptionalsStruct - */ -class ReadTestClusterListNullablesAndOptionalsStruct : public ModelCommand -{ -public: - ReadTestClusterListNullablesAndOptionalsStruct() : ModelCommand("read") - { - AddArgument("attr-name", "list-nullables-and-optionals-struct"); - ModelCommand::AddArguments(); - } - - ~ReadTestClusterListNullablesAndOptionalsStruct() - { - delete onSuccessCallback; - delete onFailureCallback; - } - - CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override - { - ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); - - chip::Controller::TestClusterCluster cluster; - cluster.Associate(device, endpointId); - return cluster.ReadAttributeListNullablesAndOptionalsStruct(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); - } - -private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback( - OnTestClusterListNullablesAndOptionalsStructListAttributeResponse, this); - chip::Callback::Callback * onFailureCallback = - new chip::Callback::Callback(OnDefaultFailureResponse, this); -}; - -/* - * Attribute Unsupported + * Attribute NullableInt56u */ -class ReadTestClusterUnsupported : public ModelCommand +class ReadTestClusterNullableInt56u : public ModelCommand { public: - ReadTestClusterUnsupported() : ModelCommand("read") + ReadTestClusterNullableInt56u() : ModelCommand("read") { - AddArgument("attr-name", "unsupported"); + AddArgument("attr-name", "nullable-int56u"); ModelCommand::AddArguments(); } - ~ReadTestClusterUnsupported() + ~ReadTestClusterNullableInt56u() { delete onSuccessCallback; delete onFailureCallback; @@ -39484,27 +42376,27 @@ class ReadTestClusterUnsupported : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeUnsupported(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt56u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnBooleanAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterUnsupported : public ModelCommand +class WriteTestClusterNullableInt56u : public ModelCommand { public: - WriteTestClusterUnsupported() : ModelCommand("write") + WriteTestClusterNullableInt56u() : ModelCommand("write") { - AddArgument("attr-name", "unsupported"); - AddArgument("attr-value", 0, 1, &mValue); + AddArgument("attr-name", "nullable-int56u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterUnsupported() + ~WriteTestClusterNullableInt56u() { delete onSuccessCallback; delete onFailureCallback; @@ -39516,7 +42408,7 @@ class WriteTestClusterUnsupported : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeUnsupported(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt56u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39524,22 +42416,22 @@ class WriteTestClusterUnsupported : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - bool mValue; + uint64_t mValue; }; -class ReportTestClusterUnsupported : public ModelCommand +class ReportTestClusterNullableInt56u : public ModelCommand { public: - ReportTestClusterUnsupported() : ModelCommand("report") + ReportTestClusterNullableInt56u() : ModelCommand("report") { - AddArgument("attr-name", "unsupported"); + AddArgument("attr-name", "nullable-int56u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterUnsupported() + ~ReportTestClusterNullableInt56u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39554,10 +42446,10 @@ class ReportTestClusterUnsupported : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeUnsupported(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt56u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeUnsupported(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt56u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39572,26 +42464,26 @@ class ReportTestClusterUnsupported : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnBooleanAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableBoolean + * Attribute NullableInt64u */ -class ReadTestClusterNullableBoolean : public ModelCommand +class ReadTestClusterNullableInt64u : public ModelCommand { public: - ReadTestClusterNullableBoolean() : ModelCommand("read") + ReadTestClusterNullableInt64u() : ModelCommand("read") { - AddArgument("attr-name", "nullable-boolean"); + AddArgument("attr-name", "nullable-int64u"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableBoolean() + ~ReadTestClusterNullableInt64u() { delete onSuccessCallback; delete onFailureCallback; @@ -39603,27 +42495,27 @@ class ReadTestClusterNullableBoolean : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableBoolean(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnBooleanAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableBoolean : public ModelCommand +class WriteTestClusterNullableInt64u : public ModelCommand { public: - WriteTestClusterNullableBoolean() : ModelCommand("write") + WriteTestClusterNullableInt64u() : ModelCommand("write") { - AddArgument("attr-name", "nullable-boolean"); - AddArgument("attr-value", 0, 1, &mValue); + AddArgument("attr-name", "nullable-int64u"); + AddArgument("attr-value", 0, UINT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableBoolean() + ~WriteTestClusterNullableInt64u() { delete onSuccessCallback; delete onFailureCallback; @@ -39635,7 +42527,7 @@ class WriteTestClusterNullableBoolean : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableBoolean(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39643,22 +42535,22 @@ class WriteTestClusterNullableBoolean : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - bool mValue; + uint64_t mValue; }; -class ReportTestClusterNullableBoolean : public ModelCommand +class ReportTestClusterNullableInt64u : public ModelCommand { public: - ReportTestClusterNullableBoolean() : ModelCommand("report") + ReportTestClusterNullableInt64u() : ModelCommand("report") { - AddArgument("attr-name", "nullable-boolean"); + AddArgument("attr-name", "nullable-int64u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableBoolean() + ~ReportTestClusterNullableInt64u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39673,10 +42565,10 @@ class ReportTestClusterNullableBoolean : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableBoolean(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt64u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableBoolean(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt64u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39691,26 +42583,26 @@ class ReportTestClusterNullableBoolean : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnBooleanAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableBitmap8 + * Attribute NullableInt8s */ -class ReadTestClusterNullableBitmap8 : public ModelCommand +class ReadTestClusterNullableInt8s : public ModelCommand { public: - ReadTestClusterNullableBitmap8() : ModelCommand("read") + ReadTestClusterNullableInt8s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-bitmap8"); + AddArgument("attr-name", "nullable-int8s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableBitmap8() + ~ReadTestClusterNullableInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -39722,27 +42614,27 @@ class ReadTestClusterNullableBitmap8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableBitmap8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableBitmap8 : public ModelCommand +class WriteTestClusterNullableInt8s : public ModelCommand { public: - WriteTestClusterNullableBitmap8() : ModelCommand("write") + WriteTestClusterNullableInt8s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-bitmap8"); - AddArgument("attr-value", 0, UINT8_MAX, &mValue); + AddArgument("attr-name", "nullable-int8s"); + AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableBitmap8() + ~WriteTestClusterNullableInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -39754,7 +42646,7 @@ class WriteTestClusterNullableBitmap8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableBitmap8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39762,22 +42654,22 @@ class WriteTestClusterNullableBitmap8 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint8_t mValue; + int8_t mValue; }; -class ReportTestClusterNullableBitmap8 : public ModelCommand +class ReportTestClusterNullableInt8s : public ModelCommand { public: - ReportTestClusterNullableBitmap8() : ModelCommand("report") + ReportTestClusterNullableInt8s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-bitmap8"); + AddArgument("attr-name", "nullable-int8s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableBitmap8() + ~ReportTestClusterNullableInt8s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39792,10 +42684,10 @@ class ReportTestClusterNullableBitmap8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap8(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt8s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableBitmap8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39810,26 +42702,26 @@ class ReportTestClusterNullableBitmap8 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt8uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableBitmap16 + * Attribute NullableInt16s */ -class ReadTestClusterNullableBitmap16 : public ModelCommand +class ReadTestClusterNullableInt16s : public ModelCommand { public: - ReadTestClusterNullableBitmap16() : ModelCommand("read") + ReadTestClusterNullableInt16s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-bitmap16"); + AddArgument("attr-name", "nullable-int16s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableBitmap16() + ~ReadTestClusterNullableInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -39841,27 +42733,27 @@ class ReadTestClusterNullableBitmap16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableBitmap16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableBitmap16 : public ModelCommand +class WriteTestClusterNullableInt16s : public ModelCommand { public: - WriteTestClusterNullableBitmap16() : ModelCommand("write") + WriteTestClusterNullableInt16s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-bitmap16"); - AddArgument("attr-value", 0, UINT16_MAX, &mValue); + AddArgument("attr-name", "nullable-int16s"); + AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableBitmap16() + ~WriteTestClusterNullableInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -39873,7 +42765,7 @@ class WriteTestClusterNullableBitmap16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableBitmap16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -39881,22 +42773,22 @@ class WriteTestClusterNullableBitmap16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint16_t mValue; + int16_t mValue; }; -class ReportTestClusterNullableBitmap16 : public ModelCommand +class ReportTestClusterNullableInt16s : public ModelCommand { public: - ReportTestClusterNullableBitmap16() : ModelCommand("report") + ReportTestClusterNullableInt16s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-bitmap16"); + AddArgument("attr-name", "nullable-int16s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableBitmap16() + ~ReportTestClusterNullableInt16s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -39911,10 +42803,10 @@ class ReportTestClusterNullableBitmap16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap16(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt16s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableBitmap16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -39929,26 +42821,26 @@ class ReportTestClusterNullableBitmap16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableBitmap32 + * Attribute NullableInt24s */ -class ReadTestClusterNullableBitmap32 : public ModelCommand +class ReadTestClusterNullableInt24s : public ModelCommand { public: - ReadTestClusterNullableBitmap32() : ModelCommand("read") + ReadTestClusterNullableInt24s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-bitmap32"); + AddArgument("attr-name", "nullable-int24s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableBitmap32() + ~ReadTestClusterNullableInt24s() { delete onSuccessCallback; delete onFailureCallback; @@ -39960,27 +42852,27 @@ class ReadTestClusterNullableBitmap32 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableBitmap32(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt24s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableBitmap32 : public ModelCommand +class WriteTestClusterNullableInt24s : public ModelCommand { public: - WriteTestClusterNullableBitmap32() : ModelCommand("write") + WriteTestClusterNullableInt24s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-bitmap32"); - AddArgument("attr-value", 0, UINT32_MAX, &mValue); + AddArgument("attr-name", "nullable-int24s"); + AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableBitmap32() + ~WriteTestClusterNullableInt24s() { delete onSuccessCallback; delete onFailureCallback; @@ -39992,7 +42884,7 @@ class WriteTestClusterNullableBitmap32 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableBitmap32(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt24s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40000,22 +42892,22 @@ class WriteTestClusterNullableBitmap32 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint32_t mValue; + int32_t mValue; }; -class ReportTestClusterNullableBitmap32 : public ModelCommand +class ReportTestClusterNullableInt24s : public ModelCommand { public: - ReportTestClusterNullableBitmap32() : ModelCommand("report") + ReportTestClusterNullableInt24s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-bitmap32"); + AddArgument("attr-name", "nullable-int24s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableBitmap32() + ~ReportTestClusterNullableInt24s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40030,10 +42922,10 @@ class ReportTestClusterNullableBitmap32 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap32(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt24s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableBitmap32(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt24s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40048,26 +42940,26 @@ class ReportTestClusterNullableBitmap32 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt32uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableBitmap64 + * Attribute NullableInt32s */ -class ReadTestClusterNullableBitmap64 : public ModelCommand +class ReadTestClusterNullableInt32s : public ModelCommand { public: - ReadTestClusterNullableBitmap64() : ModelCommand("read") + ReadTestClusterNullableInt32s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-bitmap64"); + AddArgument("attr-name", "nullable-int32s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableBitmap64() + ~ReadTestClusterNullableInt32s() { delete onSuccessCallback; delete onFailureCallback; @@ -40079,27 +42971,27 @@ class ReadTestClusterNullableBitmap64 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableBitmap64(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableBitmap64 : public ModelCommand +class WriteTestClusterNullableInt32s : public ModelCommand { public: - WriteTestClusterNullableBitmap64() : ModelCommand("write") + WriteTestClusterNullableInt32s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-bitmap64"); - AddArgument("attr-value", 0, UINT64_MAX, &mValue); + AddArgument("attr-name", "nullable-int32s"); + AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableBitmap64() + ~WriteTestClusterNullableInt32s() { delete onSuccessCallback; delete onFailureCallback; @@ -40111,7 +43003,7 @@ class WriteTestClusterNullableBitmap64 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableBitmap64(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40119,22 +43011,22 @@ class WriteTestClusterNullableBitmap64 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint64_t mValue; + int32_t mValue; }; -class ReportTestClusterNullableBitmap64 : public ModelCommand +class ReportTestClusterNullableInt32s : public ModelCommand { public: - ReportTestClusterNullableBitmap64() : ModelCommand("report") + ReportTestClusterNullableInt32s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-bitmap64"); + AddArgument("attr-name", "nullable-int32s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableBitmap64() + ~ReportTestClusterNullableInt32s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40149,10 +43041,10 @@ class ReportTestClusterNullableBitmap64 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableBitmap64(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt32s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableBitmap64(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt32s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40167,26 +43059,26 @@ class ReportTestClusterNullableBitmap64 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt32sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt8u + * Attribute NullableInt40s */ -class ReadTestClusterNullableInt8u : public ModelCommand +class ReadTestClusterNullableInt40s : public ModelCommand { public: - ReadTestClusterNullableInt8u() : ModelCommand("read") + ReadTestClusterNullableInt40s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int8u"); + AddArgument("attr-name", "nullable-int40s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt8u() + ~ReadTestClusterNullableInt40s() { delete onSuccessCallback; delete onFailureCallback; @@ -40198,27 +43090,27 @@ class ReadTestClusterNullableInt8u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt40s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt8u : public ModelCommand +class WriteTestClusterNullableInt40s : public ModelCommand { public: - WriteTestClusterNullableInt8u() : ModelCommand("write") + WriteTestClusterNullableInt40s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int8u"); - AddArgument("attr-value", 0, UINT8_MAX, &mValue); + AddArgument("attr-name", "nullable-int40s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt8u() + ~WriteTestClusterNullableInt40s() { delete onSuccessCallback; delete onFailureCallback; @@ -40230,7 +43122,7 @@ class WriteTestClusterNullableInt8u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt40s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40238,22 +43130,22 @@ class WriteTestClusterNullableInt8u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint8_t mValue; + int64_t mValue; }; -class ReportTestClusterNullableInt8u : public ModelCommand +class ReportTestClusterNullableInt40s : public ModelCommand { public: - ReportTestClusterNullableInt8u() : ModelCommand("report") + ReportTestClusterNullableInt40s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int8u"); + AddArgument("attr-name", "nullable-int40s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt8u() + ~ReportTestClusterNullableInt40s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40268,10 +43160,10 @@ class ReportTestClusterNullableInt8u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt8u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt40s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt8u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt40s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40286,26 +43178,26 @@ class ReportTestClusterNullableInt8u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt8uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt16u + * Attribute NullableInt48s */ -class ReadTestClusterNullableInt16u : public ModelCommand +class ReadTestClusterNullableInt48s : public ModelCommand { public: - ReadTestClusterNullableInt16u() : ModelCommand("read") + ReadTestClusterNullableInt48s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int16u"); + AddArgument("attr-name", "nullable-int48s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt16u() + ~ReadTestClusterNullableInt48s() { delete onSuccessCallback; delete onFailureCallback; @@ -40317,27 +43209,27 @@ class ReadTestClusterNullableInt16u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt48s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt16u : public ModelCommand +class WriteTestClusterNullableInt48s : public ModelCommand { public: - WriteTestClusterNullableInt16u() : ModelCommand("write") + WriteTestClusterNullableInt48s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int16u"); - AddArgument("attr-value", 0, UINT16_MAX, &mValue); + AddArgument("attr-name", "nullable-int48s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt16u() + ~WriteTestClusterNullableInt48s() { delete onSuccessCallback; delete onFailureCallback; @@ -40349,7 +43241,7 @@ class WriteTestClusterNullableInt16u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt48s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40357,22 +43249,22 @@ class WriteTestClusterNullableInt16u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint16_t mValue; + int64_t mValue; }; -class ReportTestClusterNullableInt16u : public ModelCommand +class ReportTestClusterNullableInt48s : public ModelCommand { public: - ReportTestClusterNullableInt16u() : ModelCommand("report") + ReportTestClusterNullableInt48s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int16u"); + AddArgument("attr-name", "nullable-int48s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt16u() + ~ReportTestClusterNullableInt48s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40387,10 +43279,10 @@ class ReportTestClusterNullableInt16u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt16u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt48s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt16u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt48s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40405,26 +43297,26 @@ class ReportTestClusterNullableInt16u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt32u + * Attribute NullableInt56s */ -class ReadTestClusterNullableInt32u : public ModelCommand +class ReadTestClusterNullableInt56s : public ModelCommand { public: - ReadTestClusterNullableInt32u() : ModelCommand("read") + ReadTestClusterNullableInt56s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int32u"); + AddArgument("attr-name", "nullable-int56s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt32u() + ~ReadTestClusterNullableInt56s() { delete onSuccessCallback; delete onFailureCallback; @@ -40436,27 +43328,27 @@ class ReadTestClusterNullableInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt56s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt32u : public ModelCommand +class WriteTestClusterNullableInt56s : public ModelCommand { public: - WriteTestClusterNullableInt32u() : ModelCommand("write") + WriteTestClusterNullableInt56s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int32u"); - AddArgument("attr-value", 0, UINT32_MAX, &mValue); + AddArgument("attr-name", "nullable-int56s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt32u() + ~WriteTestClusterNullableInt56s() { delete onSuccessCallback; delete onFailureCallback; @@ -40468,7 +43360,7 @@ class WriteTestClusterNullableInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt32u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt56s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40476,22 +43368,22 @@ class WriteTestClusterNullableInt32u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint32_t mValue; + int64_t mValue; }; -class ReportTestClusterNullableInt32u : public ModelCommand +class ReportTestClusterNullableInt56s : public ModelCommand { public: - ReportTestClusterNullableInt32u() : ModelCommand("report") + ReportTestClusterNullableInt56s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int32u"); + AddArgument("attr-name", "nullable-int56s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt32u() + ~ReportTestClusterNullableInt56s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40506,10 +43398,10 @@ class ReportTestClusterNullableInt32u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt32u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt56s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt32u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt56s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40524,26 +43416,26 @@ class ReportTestClusterNullableInt32u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt32uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt64u + * Attribute NullableInt64s */ -class ReadTestClusterNullableInt64u : public ModelCommand +class ReadTestClusterNullableInt64s : public ModelCommand { public: - ReadTestClusterNullableInt64u() : ModelCommand("read") + ReadTestClusterNullableInt64s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int64u"); + AddArgument("attr-name", "nullable-int64s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt64u() + ~ReadTestClusterNullableInt64s() { delete onSuccessCallback; delete onFailureCallback; @@ -40555,27 +43447,27 @@ class ReadTestClusterNullableInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt64u : public ModelCommand +class WriteTestClusterNullableInt64s : public ModelCommand { public: - WriteTestClusterNullableInt64u() : ModelCommand("write") + WriteTestClusterNullableInt64s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int64u"); - AddArgument("attr-value", 0, UINT64_MAX, &mValue); + AddArgument("attr-name", "nullable-int64s"); + AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt64u() + ~WriteTestClusterNullableInt64s() { delete onSuccessCallback; delete onFailureCallback; @@ -40587,7 +43479,7 @@ class WriteTestClusterNullableInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt64u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40595,22 +43487,22 @@ class WriteTestClusterNullableInt64u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint64_t mValue; + int64_t mValue; }; -class ReportTestClusterNullableInt64u : public ModelCommand +class ReportTestClusterNullableInt64s : public ModelCommand { public: - ReportTestClusterNullableInt64u() : ModelCommand("report") + ReportTestClusterNullableInt64s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int64u"); + AddArgument("attr-name", "nullable-int64s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt64u() + ~ReportTestClusterNullableInt64s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40625,10 +43517,10 @@ class ReportTestClusterNullableInt64u : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt64u(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableInt64s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt64u(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableInt64s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40643,26 +43535,26 @@ class ReportTestClusterNullableInt64u : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt64sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt8s + * Attribute NullableEnum8 */ -class ReadTestClusterNullableInt8s : public ModelCommand +class ReadTestClusterNullableEnum8 : public ModelCommand { public: - ReadTestClusterNullableInt8s() : ModelCommand("read") + ReadTestClusterNullableEnum8() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int8s"); + AddArgument("attr-name", "nullable-enum8"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt8s() + ~ReadTestClusterNullableEnum8() { delete onSuccessCallback; delete onFailureCallback; @@ -40674,27 +43566,27 @@ class ReadTestClusterNullableInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt8sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt8s : public ModelCommand +class WriteTestClusterNullableEnum8 : public ModelCommand { public: - WriteTestClusterNullableInt8s() : ModelCommand("write") + WriteTestClusterNullableEnum8() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int8s"); - AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); + AddArgument("attr-name", "nullable-enum8"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt8s() + ~WriteTestClusterNullableEnum8() { delete onSuccessCallback; delete onFailureCallback; @@ -40706,7 +43598,7 @@ class WriteTestClusterNullableInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40714,22 +43606,22 @@ class WriteTestClusterNullableInt8s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int8_t mValue; + uint8_t mValue; }; -class ReportTestClusterNullableInt8s : public ModelCommand +class ReportTestClusterNullableEnum8 : public ModelCommand { public: - ReportTestClusterNullableInt8s() : ModelCommand("report") + ReportTestClusterNullableEnum8() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int8s"); + AddArgument("attr-name", "nullable-enum8"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt8s() + ~ReportTestClusterNullableEnum8() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40744,10 +43636,10 @@ class ReportTestClusterNullableInt8s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt8s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableEnum8(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableEnum8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40762,26 +43654,26 @@ class ReportTestClusterNullableInt8s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt8sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt16s + * Attribute NullableEnum16 */ -class ReadTestClusterNullableInt16s : public ModelCommand +class ReadTestClusterNullableEnum16 : public ModelCommand { public: - ReadTestClusterNullableInt16s() : ModelCommand("read") + ReadTestClusterNullableEnum16() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int16s"); + AddArgument("attr-name", "nullable-enum16"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt16s() + ~ReadTestClusterNullableEnum16() { delete onSuccessCallback; delete onFailureCallback; @@ -40793,27 +43685,27 @@ class ReadTestClusterNullableInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt16s : public ModelCommand +class WriteTestClusterNullableEnum16 : public ModelCommand { public: - WriteTestClusterNullableInt16s() : ModelCommand("write") + WriteTestClusterNullableEnum16() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int16s"); - AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); + AddArgument("attr-name", "nullable-enum16"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt16s() + ~WriteTestClusterNullableEnum16() { delete onSuccessCallback; delete onFailureCallback; @@ -40825,7 +43717,7 @@ class WriteTestClusterNullableInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40833,22 +43725,22 @@ class WriteTestClusterNullableInt16s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int16_t mValue; + uint16_t mValue; }; -class ReportTestClusterNullableInt16s : public ModelCommand +class ReportTestClusterNullableEnum16 : public ModelCommand { public: - ReportTestClusterNullableInt16s() : ModelCommand("report") + ReportTestClusterNullableEnum16() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int16s"); + AddArgument("attr-name", "nullable-enum16"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt16s() + ~ReportTestClusterNullableEnum16() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40863,10 +43755,10 @@ class ReportTestClusterNullableInt16s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt16s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableEnum16(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableEnum16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -40881,26 +43773,26 @@ class ReportTestClusterNullableInt16s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt32s + * Attribute NullableOctetString */ -class ReadTestClusterNullableInt32s : public ModelCommand +class ReadTestClusterNullableOctetString : public ModelCommand { public: - ReadTestClusterNullableInt32s() : ModelCommand("read") + ReadTestClusterNullableOctetString() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int32s"); + AddArgument("attr-name", "nullable-octet-string"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt32s() + ~ReadTestClusterNullableOctetString() { delete onSuccessCallback; delete onFailureCallback; @@ -40912,27 +43804,27 @@ class ReadTestClusterNullableInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt32sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnOctetStringAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt32s : public ModelCommand +class WriteTestClusterNullableOctetString : public ModelCommand { public: - WriteTestClusterNullableInt32s() : ModelCommand("write") + WriteTestClusterNullableOctetString() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int32s"); - AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue); + AddArgument("attr-name", "nullable-octet-string"); + AddArgument("attr-value", &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt32s() + ~WriteTestClusterNullableOctetString() { delete onSuccessCallback; delete onFailureCallback; @@ -40944,7 +43836,7 @@ class WriteTestClusterNullableInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt32s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -40952,22 +43844,22 @@ class WriteTestClusterNullableInt32s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int32_t mValue; + chip::ByteSpan mValue; }; -class ReportTestClusterNullableInt32s : public ModelCommand +class ReportTestClusterNullableOctetString : public ModelCommand { public: - ReportTestClusterNullableInt32s() : ModelCommand("report") + ReportTestClusterNullableOctetString() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int32s"); + AddArgument("attr-name", "nullable-octet-string"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt32s() + ~ReportTestClusterNullableOctetString() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -40982,10 +43874,11 @@ class ReportTestClusterNullableInt32s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt32s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableOctetString(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt32s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41000,26 +43893,26 @@ class ReportTestClusterNullableInt32s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt32sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnOctetStringAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableInt64s + * Attribute NullableCharString */ -class ReadTestClusterNullableInt64s : public ModelCommand +class ReadTestClusterNullableCharString : public ModelCommand { public: - ReadTestClusterNullableInt64s() : ModelCommand("read") + ReadTestClusterNullableCharString() : ModelCommand("read") { - AddArgument("attr-name", "nullable-int64s"); + AddArgument("attr-name", "nullable-char-string"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableInt64s() + ~ReadTestClusterNullableCharString() { delete onSuccessCallback; delete onFailureCallback; @@ -41031,27 +43924,27 @@ class ReadTestClusterNullableInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnCharStringAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableInt64s : public ModelCommand +class WriteTestClusterNullableCharString : public ModelCommand { public: - WriteTestClusterNullableInt64s() : ModelCommand("write") + WriteTestClusterNullableCharString() : ModelCommand("write") { - AddArgument("attr-name", "nullable-int64s"); - AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue); + AddArgument("attr-name", "nullable-char-string"); + AddArgument("attr-value", &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableInt64s() + ~WriteTestClusterNullableCharString() { delete onSuccessCallback; delete onFailureCallback; @@ -41063,7 +43956,7 @@ class WriteTestClusterNullableInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableInt64s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -41071,22 +43964,22 @@ class WriteTestClusterNullableInt64s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - int64_t mValue; + chip::CharSpan mValue; }; -class ReportTestClusterNullableInt64s : public ModelCommand +class ReportTestClusterNullableCharString : public ModelCommand { public: - ReportTestClusterNullableInt64s() : ModelCommand("report") + ReportTestClusterNullableCharString() : ModelCommand("report") { - AddArgument("attr-name", "nullable-int64s"); + AddArgument("attr-name", "nullable-char-string"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableInt64s() + ~ReportTestClusterNullableCharString() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -41101,10 +43994,11 @@ class ReportTestClusterNullableInt64s : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableInt64s(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableCharString(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableInt64s(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41119,26 +44013,26 @@ class ReportTestClusterNullableInt64s : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt64sAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnCharStringAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableEnum8 + * Attribute NullableRangeRestrictedInt8u */ -class ReadTestClusterNullableEnum8 : public ModelCommand +class ReadTestClusterNullableRangeRestrictedInt8u : public ModelCommand { public: - ReadTestClusterNullableEnum8() : ModelCommand("read") + ReadTestClusterNullableRangeRestrictedInt8u() : ModelCommand("read") { - AddArgument("attr-name", "nullable-enum8"); + AddArgument("attr-name", "nullable-range-restricted-int8u"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableEnum8() + ~ReadTestClusterNullableRangeRestrictedInt8u() { delete onSuccessCallback; delete onFailureCallback; @@ -41150,7 +44044,7 @@ class ReadTestClusterNullableEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableRangeRestrictedInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: @@ -41160,17 +44054,17 @@ class ReadTestClusterNullableEnum8 : public ModelCommand new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableEnum8 : public ModelCommand +class WriteTestClusterNullableRangeRestrictedInt8u : public ModelCommand { public: - WriteTestClusterNullableEnum8() : ModelCommand("write") + WriteTestClusterNullableRangeRestrictedInt8u() : ModelCommand("write") { - AddArgument("attr-name", "nullable-enum8"); + AddArgument("attr-name", "nullable-range-restricted-int8u"); AddArgument("attr-value", 0, UINT8_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableEnum8() + ~WriteTestClusterNullableRangeRestrictedInt8u() { delete onSuccessCallback; delete onFailureCallback; @@ -41182,7 +44076,7 @@ class WriteTestClusterNullableEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableEnum8(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableRangeRestrictedInt8u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -41193,19 +44087,19 @@ class WriteTestClusterNullableEnum8 : public ModelCommand uint8_t mValue; }; -class ReportTestClusterNullableEnum8 : public ModelCommand +class ReportTestClusterNullableRangeRestrictedInt8u : public ModelCommand { public: - ReportTestClusterNullableEnum8() : ModelCommand("report") + ReportTestClusterNullableRangeRestrictedInt8u() : ModelCommand("report") { - AddArgument("attr-name", "nullable-enum8"); + AddArgument("attr-name", "nullable-range-restricted-int8u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableEnum8() + ~ReportTestClusterNullableRangeRestrictedInt8u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -41220,10 +44114,11 @@ class ReportTestClusterNullableEnum8 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableEnum8(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableRangeRestrictedInt8u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableEnum8(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableRangeRestrictedInt8u(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41246,18 +44141,18 @@ class ReportTestClusterNullableEnum8 : public ModelCommand }; /* - * Attribute NullableEnum16 + * Attribute NullableRangeRestrictedInt8s */ -class ReadTestClusterNullableEnum16 : public ModelCommand +class ReadTestClusterNullableRangeRestrictedInt8s : public ModelCommand { public: - ReadTestClusterNullableEnum16() : ModelCommand("read") + ReadTestClusterNullableRangeRestrictedInt8s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-enum16"); + AddArgument("attr-name", "nullable-range-restricted-int8s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableEnum16() + ~ReadTestClusterNullableRangeRestrictedInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -41269,27 +44164,27 @@ class ReadTestClusterNullableEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableRangeRestrictedInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableEnum16 : public ModelCommand +class WriteTestClusterNullableRangeRestrictedInt8s : public ModelCommand { public: - WriteTestClusterNullableEnum16() : ModelCommand("write") + WriteTestClusterNullableRangeRestrictedInt8s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-enum16"); - AddArgument("attr-value", 0, UINT16_MAX, &mValue); + AddArgument("attr-name", "nullable-range-restricted-int8s"); + AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableEnum16() + ~WriteTestClusterNullableRangeRestrictedInt8s() { delete onSuccessCallback; delete onFailureCallback; @@ -41301,7 +44196,7 @@ class WriteTestClusterNullableEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableEnum16(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableRangeRestrictedInt8s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); } private: @@ -41309,22 +44204,22 @@ class WriteTestClusterNullableEnum16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - uint16_t mValue; + int8_t mValue; }; -class ReportTestClusterNullableEnum16 : public ModelCommand +class ReportTestClusterNullableRangeRestrictedInt8s : public ModelCommand { public: - ReportTestClusterNullableEnum16() : ModelCommand("report") + ReportTestClusterNullableRangeRestrictedInt8s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-enum16"); + AddArgument("attr-name", "nullable-range-restricted-int8s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableEnum16() + ~ReportTestClusterNullableRangeRestrictedInt8s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -41339,10 +44234,11 @@ class ReportTestClusterNullableEnum16 : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableEnum16(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableRangeRestrictedInt8s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableEnum16(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + return cluster.SubscribeAttributeNullableRangeRestrictedInt8s(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41357,26 +44253,26 @@ class ReportTestClusterNullableEnum16 : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnInt16uAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt8sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableOctetString + * Attribute NullableRangeRestrictedInt16u */ -class ReadTestClusterNullableOctetString : public ModelCommand +class ReadTestClusterNullableRangeRestrictedInt16u : public ModelCommand { public: - ReadTestClusterNullableOctetString() : ModelCommand("read") + ReadTestClusterNullableRangeRestrictedInt16u() : ModelCommand("read") { - AddArgument("attr-name", "nullable-octet-string"); + AddArgument("attr-name", "nullable-range-restricted-int16u"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableOctetString() + ~ReadTestClusterNullableRangeRestrictedInt16u() { delete onSuccessCallback; delete onFailureCallback; @@ -41388,27 +44284,27 @@ class ReadTestClusterNullableOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableRangeRestrictedInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnOctetStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableOctetString : public ModelCommand +class WriteTestClusterNullableRangeRestrictedInt16u : public ModelCommand { public: - WriteTestClusterNullableOctetString() : ModelCommand("write") + WriteTestClusterNullableRangeRestrictedInt16u() : ModelCommand("write") { - AddArgument("attr-name", "nullable-octet-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "nullable-range-restricted-int16u"); + AddArgument("attr-value", 0, UINT16_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableOctetString() + ~WriteTestClusterNullableRangeRestrictedInt16u() { delete onSuccessCallback; delete onFailureCallback; @@ -41420,7 +44316,8 @@ class WriteTestClusterNullableOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableOctetString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableRangeRestrictedInt16u(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mValue); } private: @@ -41428,22 +44325,22 @@ class WriteTestClusterNullableOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::ByteSpan mValue; + uint16_t mValue; }; -class ReportTestClusterNullableOctetString : public ModelCommand +class ReportTestClusterNullableRangeRestrictedInt16u : public ModelCommand { public: - ReportTestClusterNullableOctetString() : ModelCommand("report") + ReportTestClusterNullableRangeRestrictedInt16u() : ModelCommand("report") { - AddArgument("attr-name", "nullable-octet-string"); + AddArgument("attr-name", "nullable-range-restricted-int16u"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableOctetString() + ~ReportTestClusterNullableRangeRestrictedInt16u() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -41458,11 +44355,11 @@ class ReportTestClusterNullableOctetString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableOctetString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableRangeRestrictedInt16u(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableOctetString(successCallback, onFailureCallback->Cancel(), mMinInterval, - mMaxInterval); + return cluster.SubscribeAttributeNullableRangeRestrictedInt16u(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41477,26 +44374,26 @@ class ReportTestClusterNullableOctetString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnOctetStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16uAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; }; /* - * Attribute NullableCharString + * Attribute NullableRangeRestrictedInt16s */ -class ReadTestClusterNullableCharString : public ModelCommand +class ReadTestClusterNullableRangeRestrictedInt16s : public ModelCommand { public: - ReadTestClusterNullableCharString() : ModelCommand("read") + ReadTestClusterNullableRangeRestrictedInt16s() : ModelCommand("read") { - AddArgument("attr-name", "nullable-char-string"); + AddArgument("attr-name", "nullable-range-restricted-int16s"); ModelCommand::AddArguments(); } - ~ReadTestClusterNullableCharString() + ~ReadTestClusterNullableRangeRestrictedInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -41508,27 +44405,27 @@ class ReadTestClusterNullableCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.ReadAttributeNullableCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + return cluster.ReadAttributeNullableRangeRestrictedInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); } private: - chip::Callback::Callback * onSuccessCallback = - new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); }; -class WriteTestClusterNullableCharString : public ModelCommand +class WriteTestClusterNullableRangeRestrictedInt16s : public ModelCommand { public: - WriteTestClusterNullableCharString() : ModelCommand("write") + WriteTestClusterNullableRangeRestrictedInt16s() : ModelCommand("write") { - AddArgument("attr-name", "nullable-char-string"); - AddArgument("attr-value", &mValue); + AddArgument("attr-name", "nullable-range-restricted-int16s"); + AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue); ModelCommand::AddArguments(); } - ~WriteTestClusterNullableCharString() + ~WriteTestClusterNullableRangeRestrictedInt16s() { delete onSuccessCallback; delete onFailureCallback; @@ -41540,7 +44437,8 @@ class WriteTestClusterNullableCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - return cluster.WriteAttributeNullableCharString(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + return cluster.WriteAttributeNullableRangeRestrictedInt16s(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mValue); } private: @@ -41548,22 +44446,22 @@ class WriteTestClusterNullableCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponse, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::CharSpan mValue; + int16_t mValue; }; -class ReportTestClusterNullableCharString : public ModelCommand +class ReportTestClusterNullableRangeRestrictedInt16s : public ModelCommand { public: - ReportTestClusterNullableCharString() : ModelCommand("report") + ReportTestClusterNullableRangeRestrictedInt16s() : ModelCommand("report") { - AddArgument("attr-name", "nullable-char-string"); + AddArgument("attr-name", "nullable-range-restricted-int16s"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); AddArgument("wait", 0, 1, &mWait); ModelCommand::AddArguments(); } - ~ReportTestClusterNullableCharString() + ~ReportTestClusterNullableRangeRestrictedInt16s() { delete onSuccessCallback; delete onSuccessCallbackWithoutExit; @@ -41578,11 +44476,11 @@ class ReportTestClusterNullableCharString : public ModelCommand chip::Controller::TestClusterCluster cluster; cluster.Associate(device, endpointId); - ReturnErrorOnFailure(cluster.ReportAttributeNullableCharString(onReportCallback->Cancel())); + ReturnErrorOnFailure(cluster.ReportAttributeNullableRangeRestrictedInt16s(onReportCallback->Cancel())); chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); - return cluster.SubscribeAttributeNullableCharString(successCallback, onFailureCallback->Cancel(), mMinInterval, - mMaxInterval); + return cluster.SubscribeAttributeNullableRangeRestrictedInt16s(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } chip::System::Clock::Timeout GetWaitDuration() const override @@ -41597,8 +44495,8 @@ class ReportTestClusterNullableCharString : public ModelCommand new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); chip::Callback::Callback * onFailureCallback = new chip::Callback::Callback(OnDefaultFailureResponse, this); - chip::Callback::Callback * onReportCallback = - new chip::Callback::Callback(OnCharStringAttributeReport, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnInt16sAttributeReport, this); uint16_t mMinInterval; uint16_t mMaxInterval; bool mWait; @@ -54324,9 +57222,21 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -54336,9 +57246,21 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -54373,6 +57295,18 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -54397,9 +57331,21 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -54409,9 +57355,21 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -54427,6 +57385,18 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // }; diff --git a/zzz_generated/chip-tool/zap-generated/reporting/Commands.h b/zzz_generated/chip-tool/zap-generated/reporting/Commands.h index 3f596275c4cc36..22ecf7b59fabff 100644 --- a/zzz_generated/chip-tool/zap-generated/reporting/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/reporting/Commands.h @@ -332,11 +332,19 @@ class Listen : public ReportingCommand delete onReportTestClusterBitmap64Callback; delete onReportTestClusterInt8uCallback; delete onReportTestClusterInt16uCallback; + delete onReportTestClusterInt24uCallback; delete onReportTestClusterInt32uCallback; + delete onReportTestClusterInt40uCallback; + delete onReportTestClusterInt48uCallback; + delete onReportTestClusterInt56uCallback; delete onReportTestClusterInt64uCallback; delete onReportTestClusterInt8sCallback; delete onReportTestClusterInt16sCallback; + delete onReportTestClusterInt24sCallback; delete onReportTestClusterInt32sCallback; + delete onReportTestClusterInt40sCallback; + delete onReportTestClusterInt48sCallback; + delete onReportTestClusterInt56sCallback; delete onReportTestClusterInt64sCallback; delete onReportTestClusterEnum8Callback; delete onReportTestClusterEnum16Callback; @@ -347,6 +355,10 @@ class Listen : public ReportingCommand delete onReportTestClusterEpochUsCallback; delete onReportTestClusterEpochSCallback; delete onReportTestClusterVendorIdCallback; + delete onReportTestClusterRangeRestrictedInt8uCallback; + delete onReportTestClusterRangeRestrictedInt8sCallback; + delete onReportTestClusterRangeRestrictedInt16uCallback; + delete onReportTestClusterRangeRestrictedInt16sCallback; delete onReportTestClusterUnsupportedCallback; delete onReportTestClusterNullableBooleanCallback; delete onReportTestClusterNullableBitmap8Callback; @@ -355,16 +367,28 @@ class Listen : public ReportingCommand delete onReportTestClusterNullableBitmap64Callback; delete onReportTestClusterNullableInt8uCallback; delete onReportTestClusterNullableInt16uCallback; + delete onReportTestClusterNullableInt24uCallback; delete onReportTestClusterNullableInt32uCallback; + delete onReportTestClusterNullableInt40uCallback; + delete onReportTestClusterNullableInt48uCallback; + delete onReportTestClusterNullableInt56uCallback; delete onReportTestClusterNullableInt64uCallback; delete onReportTestClusterNullableInt8sCallback; delete onReportTestClusterNullableInt16sCallback; + delete onReportTestClusterNullableInt24sCallback; delete onReportTestClusterNullableInt32sCallback; + delete onReportTestClusterNullableInt40sCallback; + delete onReportTestClusterNullableInt48sCallback; + delete onReportTestClusterNullableInt56sCallback; delete onReportTestClusterNullableInt64sCallback; delete onReportTestClusterNullableEnum8Callback; delete onReportTestClusterNullableEnum16Callback; delete onReportTestClusterNullableOctetStringCallback; delete onReportTestClusterNullableCharStringCallback; + delete onReportTestClusterNullableRangeRestrictedInt8uCallback; + delete onReportTestClusterNullableRangeRestrictedInt8sCallback; + delete onReportTestClusterNullableRangeRestrictedInt16uCallback; + delete onReportTestClusterNullableRangeRestrictedInt16sCallback; delete onReportTestClusterClusterRevisionCallback; delete onReportThermostatLocalTemperatureCallback; delete onReportThermostatAbsMinHeatSetpointLimitCallback; @@ -1250,16 +1274,32 @@ class Listen : public ReportingCommand BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0006, onReportTestClusterInt16uCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0007, onReportTestClusterInt24uCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0008, onReportTestClusterInt32uCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0009, onReportTestClusterInt40uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000A, onReportTestClusterInt48uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000B, onReportTestClusterInt56uCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000C, onReportTestClusterInt64uCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000D, onReportTestClusterInt8sCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000E, onReportTestClusterInt16sCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x000F, onReportTestClusterInt24sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0010, onReportTestClusterInt32sCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0011, onReportTestClusterInt40sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0012, onReportTestClusterInt48sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0013, onReportTestClusterInt56sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0014, onReportTestClusterInt64sCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0015, onReportTestClusterEnum8Callback->Cancel(), @@ -1280,6 +1320,18 @@ class Listen : public ReportingCommand BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0022, onReportTestClusterVendorIdCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0026, + onReportTestClusterRangeRestrictedInt8uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0027, + onReportTestClusterRangeRestrictedInt8sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0028, + onReportTestClusterRangeRestrictedInt16uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0029, + onReportTestClusterRangeRestrictedInt16sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x00FF, onReportTestClusterUnsupportedCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8000, onReportTestClusterNullableBooleanCallback->Cancel(), @@ -1296,16 +1348,32 @@ class Listen : public ReportingCommand BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8006, onReportTestClusterNullableInt16uCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8007, onReportTestClusterNullableInt24uCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8008, onReportTestClusterNullableInt32uCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8009, onReportTestClusterNullableInt40uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800A, onReportTestClusterNullableInt48uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800B, onReportTestClusterNullableInt56uCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800C, onReportTestClusterNullableInt64uCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800D, onReportTestClusterNullableInt8sCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800E, onReportTestClusterNullableInt16sCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x800F, onReportTestClusterNullableInt24sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8010, onReportTestClusterNullableInt32sCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8011, onReportTestClusterNullableInt40sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8012, onReportTestClusterNullableInt48sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8013, onReportTestClusterNullableInt56sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8014, onReportTestClusterNullableInt64sCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8015, onReportTestClusterNullableEnum8Callback->Cancel(), @@ -1318,6 +1386,18 @@ class Listen : public ReportingCommand callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x801E, onReportTestClusterNullableCharStringCallback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8026, + onReportTestClusterNullableRangeRestrictedInt8uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8027, + onReportTestClusterNullableRangeRestrictedInt8sCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8028, + onReportTestClusterNullableRangeRestrictedInt16uCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8029, + onReportTestClusterNullableRangeRestrictedInt16sCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0xFFFD, onReportTestClusterClusterRevisionCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x0201, 0x0000, onReportThermostatLocalTemperatureCallback->Cancel(), @@ -2298,16 +2378,32 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt16uCallback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt24uCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt32uCallback = new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt40uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt48uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt56uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt64uCallback = new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt8sCallback = new chip::Callback::Callback(OnInt8sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt16sCallback = new chip::Callback::Callback(OnInt16sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt24sCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt32sCallback = new chip::Callback::Callback(OnInt32sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt40sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt48sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterInt56sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterInt64sCallback = new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterEnum8Callback = @@ -2328,6 +2424,14 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnInt32uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterVendorIdCallback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterRangeRestrictedInt8uCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterRangeRestrictedInt8sCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterRangeRestrictedInt16uCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterRangeRestrictedInt16sCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterUnsupportedCallback = new chip::Callback::Callback(OnBooleanAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableBooleanCallback = @@ -2344,16 +2448,32 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt16uCallback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt24uCallback = + new chip::Callback::Callback(OnInt32uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt32uCallback = new chip::Callback::Callback(OnInt32uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt40uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt48uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt56uCallback = + new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt64uCallback = new chip::Callback::Callback(OnInt64uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt8sCallback = new chip::Callback::Callback(OnInt8sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt16sCallback = new chip::Callback::Callback(OnInt16sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt24sCallback = + new chip::Callback::Callback(OnInt32sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt32sCallback = new chip::Callback::Callback(OnInt32sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt40sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt48sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableInt56sCallback = + new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableInt64sCallback = new chip::Callback::Callback(OnInt64sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableEnum8Callback = @@ -2364,6 +2484,14 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnOctetStringAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableCharStringCallback = new chip::Callback::Callback(OnCharStringAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableRangeRestrictedInt8uCallback = + new chip::Callback::Callback(OnInt8uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableRangeRestrictedInt8sCallback = + new chip::Callback::Callback(OnInt8sAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableRangeRestrictedInt16uCallback = + new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableRangeRestrictedInt16sCallback = + new chip::Callback::Callback(OnInt16sAttributeResponse, this); chip::Callback::Callback * onReportTestClusterClusterRevisionCallback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); chip::Callback::Callback * onReportThermostatLocalTemperatureCallback = diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp index a63531d430b837..155fb4e7588233 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp @@ -16623,6 +16623,45 @@ CHIP_ERROR TestClusterCluster::ReportAttributeInt16u(Callback::Cancelable * onRe BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000007; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint32_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int24u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int24u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt24u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int24u::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -16662,6 +16701,123 @@ CHIP_ERROR TestClusterCluster::ReportAttributeInt32u(Callback::Cancelable * onRe BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000009; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int40u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int40u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt40u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int40u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000000A; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int48u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int48u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt48u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int48u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000000B; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int56u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int56u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt56u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int56u::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -16779,6 +16935,45 @@ CHIP_ERROR TestClusterCluster::ReportAttributeInt16s(Callback::Cancelable * onRe BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000000F; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int32_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int24s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int24s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt24s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int24s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -16818,6 +17013,123 @@ CHIP_ERROR TestClusterCluster::ReportAttributeInt32s(Callback::Cancelable * onRe BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000011; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int40s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int40s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt40s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int40s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000012; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int48s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int48s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt48s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int48s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000013; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::Int56s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::Int56s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeInt56s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::Int56s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17252,6 +17564,162 @@ CHIP_ERROR TestClusterCluster::ReadAttributeListNullablesAndOptionalsStruct(Call TestClusterClusterListNullablesAndOptionalsStructListAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000026; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::RangeRestrictedInt8u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::RangeRestrictedInt8u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeRangeRestrictedInt8u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::RangeRestrictedInt8u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000027; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int8_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::RangeRestrictedInt8s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::RangeRestrictedInt8s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeRangeRestrictedInt8s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::RangeRestrictedInt8s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000028; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::RangeRestrictedInt16u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::RangeRestrictedInt16u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeRangeRestrictedInt16u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::RangeRestrictedInt16u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000029; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::RangeRestrictedInt16s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::RangeRestrictedInt16s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeRangeRestrictedInt16s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::RangeRestrictedInt16s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17564,6 +18032,45 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt16u(Callback::Cancelabl BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008007; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint32_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt24u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt24u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt24u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt24u::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17603,6 +18110,123 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt32u(Callback::Cancelabl BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008009; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt40u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt40u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt40u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt40u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000800A; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt48u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt48u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt48u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt48u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000800B; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt56u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt56u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt56u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt56u::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17720,6 +18344,45 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt16s(Callback::Cancelabl BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x0000800F; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int32_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt24s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt24s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt24s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt24s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17759,6 +18422,123 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt32s(Callback::Cancelabl BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008011; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt40s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt40s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt40s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt40s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008012; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt48s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt48s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt48s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt48s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008013; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int64_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableInt56s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableInt56s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableInt56s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableInt56s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -17954,6 +18734,162 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableCharString(Callback::Cance BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008026; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableRangeRestrictedInt8u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008027; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int8_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableRangeRestrictedInt8s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008028; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableRangeRestrictedInt16u::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008029; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableRangeRestrictedInt16s::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h index 2c23c3386ab8dd..cb41b354703834 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h @@ -85,35 +85,35 @@ class DLL_EXPORT ApplicationBasicCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeApplicationName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeApplicationStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeApplicationName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeApplicationName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeApplicationName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeApplicationId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCatalogVendorId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeApplicationStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeApplicationStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeApplicationStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -135,14 +135,14 @@ class DLL_EXPORT ApplicationLauncherCluster : public ClusterBase CHIP_ERROR ReadAttributeApplicationLauncherList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCatalogVendorId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeApplicationId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeApplicationId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -164,11 +164,11 @@ class DLL_EXPORT AudioOutputCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeAudioOutputList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentAudioOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentAudioOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentAudioOutput(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -189,25 +189,25 @@ class DLL_EXPORT BarrierControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeBarrierMovingState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBarrierCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBarrierPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBarrierMovingState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBarrierMovingState(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBarrierSafetyStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBarrierCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBarrierCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBarrierCapabilities(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBarrierPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBarrierPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBarrierPosition(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -227,92 +227,92 @@ class DLL_EXPORT BasicCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeInteractionModelVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLocalConfigDisabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeUniqueID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); - CHIP_ERROR WriteAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); - CHIP_ERROR WriteAttributeLocalConfigDisabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - bool value); CHIP_ERROR SubscribeAttributeInteractionModelVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInteractionModelVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorID(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductID(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNodeLabel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLocation(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeHardwareVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeHardwareVersionString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSoftwareVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSoftwareVersionString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeManufacturingDate(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePartNumber(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductURL(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductLabel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSerialNumber(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLocalConfigDisabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLocalConfigDisabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + bool value); CHIP_ERROR SubscribeAttributeLocalConfigDisabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLocalConfigDisabled(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeReachable(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeUniqueID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -328,22 +328,22 @@ class DLL_EXPORT BinaryInputBasicCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeOutOfService(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStatusFlags(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOutOfService(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, bool value); - CHIP_ERROR WriteAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - bool value); CHIP_ERROR SubscribeAttributeOutOfService(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOutOfService(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + bool value); CHIP_ERROR SubscribeAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePresentValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStatusFlags(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStatusFlags(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStatusFlags(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -378,10 +378,10 @@ class DLL_EXPORT BooleanStateCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeStateValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStateValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStateValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -423,10 +423,10 @@ class DLL_EXPORT BridgedActionsCluster : public ClusterBase CHIP_ERROR ReadAttributeActionList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeEndpointList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSetupUrl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSetupUrl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSetupUrl(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -442,69 +442,69 @@ class DLL_EXPORT BridgedDeviceBasicCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); CHIP_ERROR SubscribeAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorID(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeNodeLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNodeLabel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeHardwareVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeHardwareVersionString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSoftwareVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSoftwareVersionString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeManufacturingDate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeManufacturingDate(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePartNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePartNumber(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductURL(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeProductLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeProductLabel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSerialNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSerialNumber(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeReachable(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeReachable(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -565,274 +565,274 @@ class DLL_EXPORT ColorControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDriftCompensation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCompensationText(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNumberOfPrimaries(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary1X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary1Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary1Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary2X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary2Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary2Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary3X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary3Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary3Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary4X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary4Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary4Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary5X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary5Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary5Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary6X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary6Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePrimary6Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEnhancedCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEnhancedColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorLoopActive(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorLoopDirection(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorLoopTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorLoopStartEnhancedHue(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorLoopStoredEnhancedHue(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorTempPhysicalMin(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeColorTempPhysicalMax(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR WriteAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR WriteAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR WriteAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint16_t value); CHIP_ERROR SubscribeAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentHue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentSaturation(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRemainingTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentX(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentY(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDriftCompensation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDriftCompensation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDriftCompensation(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCompensationText(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCompensationText(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCompensationText(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorTemperature(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorControlOptions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNumberOfPrimaries(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNumberOfPrimaries(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNumberOfPrimaries(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary1X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary1X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary1X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary1Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary1Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary1Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary1Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary1Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary1Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary2X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary2X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary2X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary2Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary2Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary2Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary2Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary2Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary2Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary3X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary3X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary3X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary3Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary3Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary3Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary3Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary3Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary3Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary4X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary4X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary4X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary4Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary4Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary4Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary4Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary4Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary4Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary5X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary5X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary5X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary5Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary5Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary5Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary5Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary5Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary5Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary6X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary6X(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary6X(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary6Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary6Y(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary6Y(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePrimary6Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePrimary6Intensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePrimary6Intensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeWhitePointX(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeWhitePointY(Callback::Cancelable * onReportCallback); - CHIP_ERROR SubscribeAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + CHIP_ERROR ReadAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); + CHIP_ERROR SubscribeAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointRX(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointRY(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointRIntensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointGX(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointGY(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointGIntensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointBX(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointBY(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorPointBIntensity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEnhancedCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEnhancedCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEnhancedCurrentHue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEnhancedColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEnhancedColorMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEnhancedColorMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorLoopActive(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorLoopActive(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorLoopActive(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorLoopDirection(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorLoopDirection(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorLoopDirection(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorLoopTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorLoopTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorLoopTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorLoopStartEnhancedHue(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorLoopStartEnhancedHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorLoopStartEnhancedHue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorLoopStoredEnhancedHue(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorLoopStoredEnhancedHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorLoopStoredEnhancedHue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorCapabilities(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorCapabilities(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorTempPhysicalMin(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorTempPhysicalMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorTempPhysicalMin(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeColorTempPhysicalMax(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeColorTempPhysicalMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeColorTempPhysicalMax(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t value); CHIP_ERROR SubscribeAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -944,18 +944,18 @@ class DLL_EXPORT DoorLockCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeLockState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLockType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActuatorEnabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeLockState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLockState(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLockType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeLockType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLockType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActuatorEnabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeActuatorEnabled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeActuatorEnabled(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -971,51 +971,51 @@ class DLL_EXPORT ElectricalMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasurementType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTotalActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsVoltageMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsVoltageMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsCurrent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsCurrentMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRmsCurrentMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActivePowerMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActivePowerMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasurementType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasurementType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTotalActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTotalActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTotalActivePower(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsVoltage(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsVoltageMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsVoltageMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsVoltageMin(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsVoltageMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsVoltageMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsVoltageMax(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsCurrent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsCurrent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsCurrent(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsCurrentMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsCurrentMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsCurrentMin(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRmsCurrentMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRmsCurrentMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRmsCurrentMax(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeActivePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeActivePower(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActivePowerMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeActivePowerMin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeActivePowerMin(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActivePowerMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeActivePowerMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeActivePowerMax(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1032,43 +1032,43 @@ class DLL_EXPORT EthernetNetworkDiagnosticsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributePHYRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFullDuplex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxErrCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCollisionCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCarrierDetect(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTimeSinceReset(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePHYRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePHYRate(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFullDuplex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFullDuplex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFullDuplex(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketRxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketTxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxErrCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxErrCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxErrCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCollisionCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCollisionCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCollisionCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOverrunCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCarrierDetect(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCarrierDetect(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCarrierDetect(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTimeSinceReset(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTimeSinceReset(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTimeSinceReset(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1098,24 +1098,24 @@ class DLL_EXPORT FlowMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTolerance(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1136,14 +1136,14 @@ class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t value); CHIP_ERROR SubscribeAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBreadcrumb(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1160,28 +1160,28 @@ class DLL_EXPORT GeneralDiagnosticsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeNetworkInterfaces(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeRebootCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeUpTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBootReasons(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveHardwareFaults(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveRadioFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveNetworkFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRebootCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRebootCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeUpTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeUpTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeUpTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTotalOperationalHours(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBootReasons(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBootReasons(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBootReasons(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActiveHardwareFaults(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeActiveRadioFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeActiveNetworkFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1221,10 +1221,10 @@ class DLL_EXPORT GroupsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNameSupport(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1246,16 +1246,16 @@ class DLL_EXPORT IdentifyCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t value); CHIP_ERROR SubscribeAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeIdentifyTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeIdentifyType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1271,28 +1271,28 @@ class DLL_EXPORT IlluminanceMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLightSensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTolerance(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLightSensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeLightSensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLightSensorType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1341,81 +1341,81 @@ class DLL_EXPORT LevelControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOnOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOnLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOnTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDefaultMoveRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartUpCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeOnOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeOnLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeOnTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeDefaultMoveRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeStartUpCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRemainingTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentFrequency(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinFrequency(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxFrequency(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxFrequency(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeOptions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOptions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOnOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOnOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOnOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnOffTransitionTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOnLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOnLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeOnLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOnTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOnTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOnTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnTransitionTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOffTransitionTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOffTransitionTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDefaultMoveRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeDefaultMoveRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeDefaultMoveRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDefaultMoveRate(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartUpCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeStartUpCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeStartUpCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartUpCurrentLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1457,11 +1457,11 @@ class DLL_EXPORT MediaInputCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMediaInputList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentMediaInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentMediaInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentMediaInput(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1492,39 +1492,39 @@ class DLL_EXPORT MediaPlaybackCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributePlaybackState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDuration(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePlaybackState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePlaybackState(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDuration(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDuration(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDuration(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePositionUpdatedAt(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePosition(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePlaybackSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSeekRangeEnd(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSeekRangeStart(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1543,25 +1543,25 @@ class DLL_EXPORT ModeSelectCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeCurrentMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR SubscribeAttributeCurrentMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeCurrentMode(Callback::Cancelable * onReportCallback); CHIP_ERROR ReadAttributeSupportedModes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeOnMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartUpMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOnMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR SubscribeAttributeCurrentMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeCurrentMode(Callback::Cancelable * onReportCallback); CHIP_ERROR SubscribeAttributeOnMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartUpMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStartUpMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartUpMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDescription(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1595,10 +1595,10 @@ class DLL_EXPORT NetworkCommissioningCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1644,17 +1644,17 @@ class DLL_EXPORT OtaSoftwareUpdateRequestorCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeDefaultOtaProvider(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeUpdatePossible(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeDefaultOtaProvider(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan value); CHIP_ERROR SubscribeAttributeDefaultOtaProvider(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDefaultOtaProvider(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeUpdatePossible(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeUpdatePossible(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeUpdatePossible(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1670,21 +1670,21 @@ class DLL_EXPORT OccupancySensingCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeOccupancy(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOccupancySensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOccupancySensorTypeBitmap(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOccupancy(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOccupancy(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOccupancySensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOccupancySensorType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOccupancySensorType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOccupancySensorTypeBitmap(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOccupancySensorTypeBitmap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOccupancySensorTypeBitmap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1708,37 +1708,37 @@ class DLL_EXPORT OnOffCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR SubscribeAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeOnOff(Callback::Cancelable * onReportCallback); CHIP_ERROR ReadAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR SubscribeAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeGlobalSceneControl(Callback::Cancelable * onReportCallback); CHIP_ERROR ReadAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t value); - CHIP_ERROR WriteAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR SubscribeAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeOnOff(Callback::Cancelable * onReportCallback); - CHIP_ERROR SubscribeAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval); - CHIP_ERROR ReportAttributeGlobalSceneControl(Callback::Cancelable * onReportCallback); CHIP_ERROR SubscribeAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOffWaitTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartUpOnOff(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1754,16 +1754,16 @@ class DLL_EXPORT OnOffSwitchConfigurationCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeSwitchType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSwitchActions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeSwitchActions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeSwitchType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSwitchType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSwitchActions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeSwitchActions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeSwitchActions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSwitchActions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1798,23 +1798,23 @@ class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeFabricsList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSupportedFabrics(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCommissionedFabrics(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentFabricIndex(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1830,49 +1830,49 @@ class DLL_EXPORT PowerSourceCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOrder(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBatteryVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBatteryPercentRemaining(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBatteryTimeRemaining(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBatteryChargeLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveBatteryFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBatteryChargeState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOrder(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOrder(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOrder(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDescription(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDescription(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBatteryVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBatteryVoltage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBatteryVoltage(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBatteryPercentRemaining(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBatteryPercentRemaining(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBatteryPercentRemaining(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBatteryTimeRemaining(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBatteryTimeRemaining(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBatteryTimeRemaining(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBatteryChargeLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBatteryChargeLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBatteryChargeLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActiveBatteryFaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeBatteryChargeState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBatteryChargeState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBatteryChargeState(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1886,20 +1886,20 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -1913,124 +1913,124 @@ class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMaxPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePumpStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLifetimeRunningHours(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLifetimeEnergyConsumed(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAlarmMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeLifetimeRunningHours(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint32_t value); - CHIP_ERROR WriteAttributeLifetimeEnergyConsumed(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint32_t value); - CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeMaxPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxFlow(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinConstPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxConstPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxConstPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinCompPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxCompPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxCompPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinConstSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxConstSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxConstSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinConstFlow(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxConstFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxConstFlow(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinConstTemp(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxConstTemp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxConstTemp(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePumpStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePumpStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePumpStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEffectiveOperationMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEffectiveControlMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCapacity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLifetimeRunningHours(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLifetimeRunningHours(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint32_t value); CHIP_ERROR SubscribeAttributeLifetimeRunningHours(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLifetimeRunningHours(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePower(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLifetimeEnergyConsumed(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLifetimeEnergyConsumed(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint32_t value); CHIP_ERROR SubscribeAttributeLifetimeEnergyConsumed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLifetimeEnergyConsumed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOperationMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeControlMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAlarmMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAlarmMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAlarmMask(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2044,24 +2044,24 @@ class DLL_EXPORT RelativeHumidityMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTolerance(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2092,26 +2092,26 @@ class DLL_EXPORT ScenesCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeSceneCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSceneValid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSceneCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSceneCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentScene(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentGroup(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSceneValid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSceneValid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSceneValid(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNameSupport(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2131,21 +2131,21 @@ class DLL_EXPORT SoftwareDiagnosticsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeThreadMetrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentHeapFree(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentHeapUsed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentHeapHighWatermark(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2161,23 +2161,23 @@ class DLL_EXPORT SwitchCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeNumberOfPositions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMultiPressMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNumberOfPositions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNumberOfPositions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPosition(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMultiPressMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMultiPressMax(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMultiPressMax(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2199,15 +2199,15 @@ class DLL_EXPORT TvChannelCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeTvChannelList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeTvChannelLineup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentTvChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTvChannelLineup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTvChannelLineup(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentTvChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentTvChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentTvChannel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2243,24 +2243,24 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTolerance(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTolerance(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2307,257 +2307,417 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeListInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeListOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeListStructOctetString(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLongOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLongCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEpochUs(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEpochS(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeListNullablesAndOptionalsStruct(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNullableCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, bool value); + CHIP_ERROR SubscribeAttributeBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeBoolean(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); + CHIP_ERROR SubscribeAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeBitmap8(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t value); + CHIP_ERROR SubscribeAttributeBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeBitmap16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint32_t value); + CHIP_ERROR SubscribeAttributeBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeBitmap32(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t value); - CHIP_ERROR WriteAttributeInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint32_t value); - CHIP_ERROR WriteAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint64_t value); - CHIP_ERROR WriteAttributeInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int8_t value); - CHIP_ERROR WriteAttributeInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int16_t value); - CHIP_ERROR WriteAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int32_t value); - CHIP_ERROR WriteAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int64_t value); - CHIP_ERROR WriteAttributeEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::ByteSpan value); - CHIP_ERROR WriteAttributeLongOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::ByteSpan value); - CHIP_ERROR WriteAttributeCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); - CHIP_ERROR WriteAttributeLongCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); - CHIP_ERROR WriteAttributeEpochUs(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint64_t value); - CHIP_ERROR WriteAttributeEpochS(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint32_t value); - CHIP_ERROR WriteAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::VendorId value); - CHIP_ERROR WriteAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - bool value); - CHIP_ERROR WriteAttributeNullableBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - bool value); - CHIP_ERROR WriteAttributeNullableBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeNullableBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeNullableBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint32_t value); - CHIP_ERROR WriteAttributeNullableBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint64_t value); - CHIP_ERROR WriteAttributeNullableInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeNullableInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint32_t value); - CHIP_ERROR WriteAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint64_t value); - CHIP_ERROR WriteAttributeNullableInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int8_t value); - CHIP_ERROR WriteAttributeNullableInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int16_t value); - CHIP_ERROR WriteAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int32_t value); - CHIP_ERROR WriteAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int64_t value); - CHIP_ERROR WriteAttributeNullableEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::ByteSpan value); - CHIP_ERROR WriteAttributeNullableCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - chip::CharSpan value); - CHIP_ERROR SubscribeAttributeBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeBoolean(Callback::Cancelable * onReportCallback); - CHIP_ERROR SubscribeAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeBitmap8(Callback::Cancelable * onReportCallback); - CHIP_ERROR SubscribeAttributeBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeBitmap16(Callback::Cancelable * onReportCallback); - CHIP_ERROR SubscribeAttributeBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval); - CHIP_ERROR ReportAttributeBitmap32(Callback::Cancelable * onReportCallback); CHIP_ERROR SubscribeAttributeBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBitmap64(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt8u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt16u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); + CHIP_ERROR SubscribeAttributeInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt24u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); CHIP_ERROR SubscribeAttributeInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt32u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt40u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt48u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt56u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); CHIP_ERROR SubscribeAttributeInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt64u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int8_t value); CHIP_ERROR SubscribeAttributeInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt8s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int16_t value); CHIP_ERROR SubscribeAttributeInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt16s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int32_t value); + CHIP_ERROR SubscribeAttributeInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt24s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int32_t value); CHIP_ERROR SubscribeAttributeInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt32s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt40s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt48s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeInt56s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); CHIP_ERROR SubscribeAttributeInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInt64s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEnum8(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEnum16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::ByteSpan value); CHIP_ERROR SubscribeAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOctetString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeListInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeListOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeListStructOctetString(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeLongOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLongOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::ByteSpan value); CHIP_ERROR SubscribeAttributeLongOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLongOctetString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCharString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLongCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeLongCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeLongCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLongCharString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEpochUs(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeEpochUs(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); CHIP_ERROR SubscribeAttributeEpochUs(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEpochUs(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEpochS(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeEpochS(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); CHIP_ERROR SubscribeAttributeEpochS(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEpochS(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::VendorId value); CHIP_ERROR SubscribeAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeVendorId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeListNullablesAndOptionalsStruct(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); + CHIP_ERROR SubscribeAttributeRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeRangeRestrictedInt8u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int8_t value); + CHIP_ERROR SubscribeAttributeRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeRangeRestrictedInt8s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t value); + CHIP_ERROR SubscribeAttributeRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeRangeRestrictedInt16u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); + CHIP_ERROR SubscribeAttributeRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeRangeRestrictedInt16s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + bool value); CHIP_ERROR SubscribeAttributeUnsupported(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeUnsupported(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + bool value); CHIP_ERROR SubscribeAttributeNullableBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableBoolean(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeNullableBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableBitmap8(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeNullableBitmap16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableBitmap16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); CHIP_ERROR SubscribeAttributeNullableBitmap32(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableBitmap32(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); CHIP_ERROR SubscribeAttributeNullableBitmap64(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableBitmap64(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeNullableInt8u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt8u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeNullableInt16u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt16u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); + CHIP_ERROR SubscribeAttributeNullableInt24u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt24u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint32_t value); CHIP_ERROR SubscribeAttributeNullableInt32u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt32u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeNullableInt40u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt40u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeNullableInt48u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt48u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); + CHIP_ERROR SubscribeAttributeNullableInt56u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt56u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint64_t value); CHIP_ERROR SubscribeAttributeNullableInt64u(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt64u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int8_t value); CHIP_ERROR SubscribeAttributeNullableInt8s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt8s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int16_t value); CHIP_ERROR SubscribeAttributeNullableInt16s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt16s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int32_t value); + CHIP_ERROR SubscribeAttributeNullableInt24s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt24s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int32_t value); CHIP_ERROR SubscribeAttributeNullableInt32s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt32s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeNullableInt40s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt40s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeNullableInt48s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt48s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); + CHIP_ERROR SubscribeAttributeNullableInt56s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableInt56s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int64_t value); CHIP_ERROR SubscribeAttributeNullableInt64s(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableInt64s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeNullableEnum8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableEnum8(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableEnum16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::ByteSpan value); CHIP_ERROR SubscribeAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableOctetString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::CharSpan value); CHIP_ERROR SubscribeAttributeNullableCharString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableCharString(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); + CHIP_ERROR SubscribeAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableRangeRestrictedInt8u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int8_t value); + CHIP_ERROR SubscribeAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableRangeRestrictedInt8s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t value); + CHIP_ERROR SubscribeAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableRangeRestrictedInt16u(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); + CHIP_ERROR SubscribeAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableRangeRestrictedInt16s(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2584,124 +2744,124 @@ class DLL_EXPORT ThermostatCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAbsMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAbsMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAbsMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAbsMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinSetpointDeadBand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeControlSequenceOfOperation(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartOfWeek(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNumberOfWeeklyTransitions(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNumberOfDailyTransitions(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, int16_t value); - CHIP_ERROR WriteAttributeMinSetpointDeadBand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - int8_t value); - CHIP_ERROR WriteAttributeControlSequenceOfOperation(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR WriteAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLocalTemperature(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAbsMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAbsMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAbsMinHeatSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAbsMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAbsMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAbsMaxHeatSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAbsMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAbsMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAbsMinCoolSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAbsMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAbsMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAbsMaxCoolSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOccupiedCoolingSetpoint(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOccupiedHeatingSetpoint(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinHeatSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeMaxHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxHeatSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeMinCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinCoolSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, int16_t value); CHIP_ERROR SubscribeAttributeMaxCoolSetpointLimit(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxCoolSetpointLimit(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinSetpointDeadBand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMinSetpointDeadBand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + int8_t value); CHIP_ERROR SubscribeAttributeMinSetpointDeadBand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinSetpointDeadBand(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeControlSequenceOfOperation(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeControlSequenceOfOperation(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeControlSequenceOfOperation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeControlSequenceOfOperation(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSystemMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartOfWeek(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStartOfWeek(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartOfWeek(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNumberOfWeeklyTransitions(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNumberOfWeeklyTransitions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNumberOfWeeklyTransitions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNumberOfDailyTransitions(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNumberOfDailyTransitions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNumberOfDailyTransitions(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2718,27 +2878,27 @@ class DLL_EXPORT ThermostatUserInterfaceConfigurationCluster : public ClusterBas // Cluster Attributes CHIP_ERROR ReadAttributeTemperatureDisplayMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeKeypadLockout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeScheduleProgrammingVisibility(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeTemperatureDisplayMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR WriteAttributeKeypadLockout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); - CHIP_ERROR WriteAttributeScheduleProgrammingVisibility(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeTemperatureDisplayMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTemperatureDisplayMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeKeypadLockout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeKeypadLockout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeKeypadLockout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeKeypadLockout(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeScheduleProgrammingVisibility(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeScheduleProgrammingVisibility(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR SubscribeAttributeScheduleProgrammingVisibility(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeScheduleProgrammingVisibility(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -2755,279 +2915,279 @@ class DLL_EXPORT ThreadNetworkDiagnosticsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRoutingRole(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNetworkName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeExtendedPanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMeshLocalPrefix(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeNeighborTableList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRouteTableList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePartitionId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeWeighting(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStableDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLeaderRouterId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDetachedRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeChildRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRouterRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeLeaderRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeAttachAttemptCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePartitionIdChangeCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBetterPartitionAttachAttemptCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeParentChangeCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxAckRequestedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxAckedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxNoAckRequestedCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxRetryCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxDirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxIndirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxErrCcaCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxErrAbortCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTxErrBusyChannelCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxAddressFilteredCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxDestAddrFilteredCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxDuplicatedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrNoFrameCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrUnknownNeighborCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrInvalidSrcAddrCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrSecCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrFcsCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRxErrOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePendingTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeDelay(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSecurityPolicy(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeChannelMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOperationalDatasetComponents(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeActiveNetworkFaultsList(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeChannel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRoutingRole(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRoutingRole(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRoutingRole(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNetworkName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeNetworkName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNetworkName(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePanId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeExtendedPanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeExtendedPanId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeExtendedPanId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMeshLocalPrefix(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeshLocalPrefix(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeshLocalPrefix(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOverrunCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNeighborTableList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeRouteTableList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributePartitionId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePartitionId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePartitionId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeWeighting(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeWeighting(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeWeighting(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDataVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStableDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeStableDataVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStableDataVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLeaderRouterId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeLeaderRouterId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLeaderRouterId(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDetachedRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDetachedRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDetachedRoleCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeChildRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeChildRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeChildRoleCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRouterRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRouterRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRouterRoleCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeLeaderRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeLeaderRoleCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeLeaderRoleCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeAttachAttemptCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeAttachAttemptCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeAttachAttemptCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePartitionIdChangeCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePartitionIdChangeCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePartitionIdChangeCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBetterPartitionAttachAttemptCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBetterPartitionAttachAttemptCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBetterPartitionAttachAttemptCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeParentChangeCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeParentChangeCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeParentChangeCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxTotalCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxUnicastCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxBroadcastCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxAckRequestedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxAckRequestedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxAckRequestedCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxAckedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxAckedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxAckedCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxNoAckRequestedCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxNoAckRequestedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxNoAckRequestedCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxDataCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxDataPollCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxBeaconCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxBeaconRequestCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxOtherCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxRetryCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxRetryCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxRetryCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxDirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxDirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxDirectMaxRetryExpiryCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxIndirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxIndirectMaxRetryExpiryCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxIndirectMaxRetryExpiryCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxErrCcaCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxErrCcaCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxErrCcaCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxErrAbortCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxErrAbortCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxErrAbortCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTxErrBusyChannelCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTxErrBusyChannelCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTxErrBusyChannelCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxTotalCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxTotalCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxUnicastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxUnicastCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxBroadcastCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxBroadcastCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxDataCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxDataCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxDataPollCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxDataPollCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxBeaconCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxBeaconCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxBeaconRequestCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxBeaconRequestCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxOtherCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxAddressFilteredCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxAddressFilteredCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxAddressFilteredCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxDestAddrFilteredCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxDestAddrFilteredCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxDestAddrFilteredCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxDuplicatedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxDuplicatedCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxDuplicatedCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrNoFrameCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrNoFrameCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrNoFrameCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrUnknownNeighborCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrUnknownNeighborCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrUnknownNeighborCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrInvalidSrcAddrCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrInvalidSrcAddrCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrInvalidSrcAddrCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrSecCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrSecCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrSecCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrFcsCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrFcsCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrFcsCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRxErrOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRxErrOtherCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRxErrOtherCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeActiveTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeActiveTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeActiveTimestamp(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePendingTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePendingTimestamp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePendingTimestamp(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeDelay(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeDelay(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeDelay(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSecurityPolicy(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeChannelMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeChannelMask(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeChannelMask(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOperationalDatasetComponents(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeActiveNetworkFaultsList(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -3043,11 +3203,11 @@ class DLL_EXPORT WakeOnLanCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeWakeOnLanMacAddress(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeWakeOnLanMacAddress(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeWakeOnLanMacAddress(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -3064,67 +3224,67 @@ class DLL_EXPORT WiFiNetworkDiagnosticsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeBssid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSecurityType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeWiFiVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeChannelNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeRssi(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBeaconLostCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBeaconRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketMulticastRxCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketMulticastTxCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketUnicastRxCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributePacketUnicastTxCount(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentMaxRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBssid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBssid(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSecurityType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSecurityType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSecurityType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeWiFiVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeWiFiVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeWiFiVersion(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeChannelNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeChannelNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeChannelNumber(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeRssi(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeRssi(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeRssi(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBeaconLostCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBeaconLostCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBeaconLostCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBeaconRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeBeaconRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBeaconRxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketMulticastRxCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketMulticastRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketMulticastRxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketMulticastTxCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketMulticastTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketMulticastTxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketUnicastRxCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketUnicastRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketUnicastRxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributePacketUnicastTxCount(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributePacketUnicastTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePacketUnicastTxCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentMaxRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentMaxRate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentMaxRate(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOverrunCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOverrunCount(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -3153,107 +3313,107 @@ class DLL_EXPORT WindowCoveringCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionTilt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeConfigStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEndProductType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInstalledOpenLimitLift(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInstalledClosedLimitLift(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInstalledOpenLimitTilt(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeInstalledClosedLimitTilt(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionLift(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionTilt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionTilt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionTilt(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeConfigStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeConfigStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeConfigStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOperationalStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEndProductType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEndProductType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEndProductType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInstalledOpenLimitLift(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeInstalledOpenLimitLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInstalledOpenLimitLift(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInstalledClosedLimitLift(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeInstalledClosedLimitLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInstalledClosedLimitLift(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInstalledOpenLimitTilt(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeInstalledOpenLimitTilt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInstalledOpenLimitTilt(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeInstalledClosedLimitTilt(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeInstalledClosedLimitTilt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeInstalledClosedLimitTilt(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSafetyStatus(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); diff --git a/zzz_generated/lighting-app/zap-generated/CHIPClusters.h b/zzz_generated/lighting-app/zap-generated/CHIPClusters.h index 241a1160a0c53b..d514557c511a5d 100644 --- a/zzz_generated/lighting-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/lighting-app/zap-generated/CHIPClusters.h @@ -59,37 +59,37 @@ class DLL_EXPORT OnOffCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t value); - CHIP_ERROR WriteAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnOff(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeGlobalSceneControl(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOnTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t value); CHIP_ERROR SubscribeAttributeOffWaitTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOffWaitTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeStartUpOnOff(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeFeatureMap(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); diff --git a/zzz_generated/pump-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-app/zap-generated/CHIPClusters.h index 3007da1260fad8..4849861979beaa 100644 --- a/zzz_generated/pump-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-app/zap-generated/CHIPClusters.h @@ -38,20 +38,20 @@ class DLL_EXPORT FlowMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -65,20 +65,20 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -92,20 +92,20 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); diff --git a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h index ebd88dfdb937df..8ca14062d51cec 100644 --- a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h @@ -38,20 +38,20 @@ class DLL_EXPORT FlowMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -82,10 +82,10 @@ class DLL_EXPORT LevelControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -106,10 +106,10 @@ class DLL_EXPORT OnOffCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOnOff(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -125,20 +125,20 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -152,40 +152,40 @@ class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMaxPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t value); CHIP_ERROR SubscribeAttributeMaxPressure(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxPressure(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxSpeed(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxFlow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxFlow(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEffectiveOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEffectiveOperationMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeEffectiveControlMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEffectiveControlMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCapacity(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t value); CHIP_ERROR SubscribeAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOperationMode(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -199,20 +199,20 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMinMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMaxMeasuredValue(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); diff --git a/zzz_generated/thermostat/zap-generated/CHIPClusters.h b/zzz_generated/thermostat/zap-generated/CHIPClusters.h index b45f7582785e85..35e8dace54729e 100644 --- a/zzz_generated/thermostat/zap-generated/CHIPClusters.h +++ b/zzz_generated/thermostat/zap-generated/CHIPClusters.h @@ -42,16 +42,16 @@ class DLL_EXPORT IdentifyCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t value); CHIP_ERROR SubscribeAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeIdentifyTime(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeIdentifyType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeIdentifyType(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); diff --git a/zzz_generated/tv-app/zap-generated/CHIPClusters.h b/zzz_generated/tv-app/zap-generated/CHIPClusters.h index d229daccf3d6b7..c85ba4bce37044 100644 --- a/zzz_generated/tv-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/tv-app/zap-generated/CHIPClusters.h @@ -45,15 +45,15 @@ class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t value); CHIP_ERROR SubscribeAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeBreadcrumb(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback); @@ -112,23 +112,23 @@ class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase // Cluster Attributes CHIP_ERROR ReadAttributeFabricsList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeSupportedFabrics(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCommissionedFabrics(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback); + CHIP_ERROR ReadAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeCurrentFabricIndex(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentFabricIndex(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR SubscribeAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeClusterRevision(Callback::Cancelable * onReportCallback);